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"
87 #include "common/common-target.h"
88 #include "langhooks.h"
93 #include "gdb/gdb-index.h"
95 #include "stringpool.h"
98 static void dwarf2out_source_line (unsigned int, unsigned int, const char *,
100 static rtx_insn
*last_var_location_insn
;
101 static rtx_insn
*cached_next_real_insn
;
102 static void dwarf2out_decl (tree
);
104 #ifndef XCOFF_DEBUGGING_INFO
105 #define XCOFF_DEBUGGING_INFO 0
108 #ifndef HAVE_XCOFF_DWARF_EXTRAS
109 #define HAVE_XCOFF_DWARF_EXTRAS 0
112 #ifdef VMS_DEBUGGING_INFO
113 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
115 /* Define this macro to be a nonzero value if the directory specifications
116 which are output in the debug info should end with a separator. */
117 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
118 /* Define this macro to evaluate to a nonzero value if GCC should refrain
119 from generating indirect strings in DWARF2 debug information, for instance
120 if your target is stuck with an old version of GDB that is unable to
121 process them properly or uses VMS Debug. */
122 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
124 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
125 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
128 /* ??? Poison these here until it can be done generically. They've been
129 totally replaced in this file; make sure it stays that way. */
130 #undef DWARF2_UNWIND_INFO
131 #undef DWARF2_FRAME_INFO
132 #if (GCC_VERSION >= 3000)
133 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
136 /* The size of the target's pointer type. */
138 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
141 /* Array of RTXes referenced by the debugging information, which therefore
142 must be kept around forever. */
143 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
145 /* A pointer to the base of a list of incomplete types which might be
146 completed at some later time. incomplete_types_list needs to be a
147 vec<tree, va_gc> *because we want to tell the garbage collector about
149 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
151 /* A pointer to the base of a table of references to declaration
152 scopes. This table is a display which tracks the nesting
153 of declaration scopes at the current scope and containing
154 scopes. This table is used to find the proper place to
155 define type declaration DIE's. */
156 static GTY(()) vec
<tree
, va_gc
> *decl_scope_table
;
158 /* Pointers to various DWARF2 sections. */
159 static GTY(()) section
*debug_info_section
;
160 static GTY(()) section
*debug_skeleton_info_section
;
161 static GTY(()) section
*debug_abbrev_section
;
162 static GTY(()) section
*debug_skeleton_abbrev_section
;
163 static GTY(()) section
*debug_aranges_section
;
164 static GTY(()) section
*debug_addr_section
;
165 static GTY(()) section
*debug_macinfo_section
;
166 static const char *debug_macinfo_section_name
;
167 static unsigned macinfo_label_base
= 1;
168 static GTY(()) section
*debug_line_section
;
169 static GTY(()) section
*debug_skeleton_line_section
;
170 static GTY(()) section
*debug_loc_section
;
171 static GTY(()) section
*debug_pubnames_section
;
172 static GTY(()) section
*debug_pubtypes_section
;
173 static GTY(()) section
*debug_str_section
;
174 static GTY(()) section
*debug_line_str_section
;
175 static GTY(()) section
*debug_str_dwo_section
;
176 static GTY(()) section
*debug_str_offsets_section
;
177 static GTY(()) section
*debug_ranges_section
;
178 static GTY(()) section
*debug_frame_section
;
180 /* Maximum size (in bytes) of an artificially generated label. */
181 #define MAX_ARTIFICIAL_LABEL_BYTES 40
183 /* According to the (draft) DWARF 3 specification, the initial length
184 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
185 bytes are 0xffffffff, followed by the length stored in the next 8
188 However, the SGI/MIPS ABI uses an initial length which is equal to
189 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
191 #ifndef DWARF_INITIAL_LENGTH_SIZE
192 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
195 #ifndef DWARF_INITIAL_LENGTH_SIZE_STR
196 #define DWARF_INITIAL_LENGTH_SIZE_STR (DWARF_OFFSET_SIZE == 4 ? "-4" : "-12")
199 /* Round SIZE up to the nearest BOUNDARY. */
200 #define DWARF_ROUND(SIZE,BOUNDARY) \
201 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
203 /* CIE identifier. */
204 #if HOST_BITS_PER_WIDE_INT >= 64
205 #define DWARF_CIE_ID \
206 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
208 #define DWARF_CIE_ID DW_CIE_ID
212 /* A vector for a table that contains frame description
213 information for each routine. */
214 #define NOT_INDEXED (-1U)
215 #define NO_INDEX_ASSIGNED (-2U)
217 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
219 struct GTY((for_user
)) indirect_string_node
{
221 unsigned int refcount
;
222 enum dwarf_form form
;
227 struct indirect_string_hasher
: ggc_ptr_hash
<indirect_string_node
>
229 typedef const char *compare_type
;
231 static hashval_t
hash (indirect_string_node
*);
232 static bool equal (indirect_string_node
*, const char *);
235 static GTY (()) hash_table
<indirect_string_hasher
> *debug_str_hash
;
237 static GTY (()) hash_table
<indirect_string_hasher
> *debug_line_str_hash
;
239 /* With split_debug_info, both the comp_dir and dwo_name go in the
240 main object file, rather than the dwo, similar to the force_direct
241 parameter elsewhere but with additional complications:
243 1) The string is needed in both the main object file and the dwo.
244 That is, the comp_dir and dwo_name will appear in both places.
246 2) Strings can use four forms: DW_FORM_string, DW_FORM_strp,
247 DW_FORM_line_strp or DW_FORM_GNU_str_index.
249 3) GCC chooses the form to use late, depending on the size and
252 Rather than forcing the all debug string handling functions and
253 callers to deal with these complications, simply use a separate,
254 special-cased string table for any attribute that should go in the
255 main object file. This limits the complexity to just the places
258 static GTY (()) hash_table
<indirect_string_hasher
> *skeleton_debug_str_hash
;
260 static GTY(()) int dw2_string_counter
;
262 /* True if the compilation unit places functions in more than one section. */
263 static GTY(()) bool have_multiple_function_sections
= false;
265 /* 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 /* .debug_rnglists next index. */
289 static unsigned int rnglist_idx
;
291 /* Data and reference forms for relocatable data. */
292 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
293 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
295 #ifndef DEBUG_FRAME_SECTION
296 #define DEBUG_FRAME_SECTION ".debug_frame"
299 #ifndef FUNC_BEGIN_LABEL
300 #define FUNC_BEGIN_LABEL "LFB"
303 #ifndef FUNC_END_LABEL
304 #define FUNC_END_LABEL "LFE"
307 #ifndef PROLOGUE_END_LABEL
308 #define PROLOGUE_END_LABEL "LPE"
311 #ifndef EPILOGUE_BEGIN_LABEL
312 #define EPILOGUE_BEGIN_LABEL "LEB"
315 #ifndef FRAME_BEGIN_LABEL
316 #define FRAME_BEGIN_LABEL "Lframe"
318 #define CIE_AFTER_SIZE_LABEL "LSCIE"
319 #define CIE_END_LABEL "LECIE"
320 #define FDE_LABEL "LSFDE"
321 #define FDE_AFTER_SIZE_LABEL "LASFDE"
322 #define FDE_END_LABEL "LEFDE"
323 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
324 #define LINE_NUMBER_END_LABEL "LELT"
325 #define LN_PROLOG_AS_LABEL "LASLTP"
326 #define LN_PROLOG_END_LABEL "LELTP"
327 #define DIE_LABEL_PREFIX "DW"
329 /* Match the base name of a file to the base name of a compilation unit. */
332 matches_main_base (const char *path
)
334 /* Cache the last query. */
335 static const char *last_path
= NULL
;
336 static int last_match
= 0;
337 if (path
!= last_path
)
340 int length
= base_of_path (path
, &base
);
342 last_match
= (length
== main_input_baselength
343 && memcmp (base
, main_input_basename
, length
) == 0);
348 #ifdef DEBUG_DEBUG_STRUCT
351 dump_struct_debug (tree type
, enum debug_info_usage usage
,
352 enum debug_struct_file criterion
, int generic
,
353 int matches
, int result
)
355 /* Find the type name. */
356 tree type_decl
= TYPE_STUB_DECL (type
);
358 const char *name
= 0;
359 if (TREE_CODE (t
) == TYPE_DECL
)
362 name
= IDENTIFIER_POINTER (t
);
364 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
366 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
367 matches
? "bas" : "hdr",
368 generic
? "gen" : "ord",
369 usage
== DINFO_USAGE_DFN
? ";" :
370 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
372 (void*) type_decl
, name
);
375 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
376 dump_struct_debug (type, usage, criterion, generic, matches, result)
380 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
385 /* Get the number of HOST_WIDE_INTs needed to represent the precision
386 of the number. Some constants have a large uniform precision, so
387 we get the precision needed for the actual value of the number. */
390 get_full_len (const wide_int
&op
)
392 int prec
= wi::min_precision (op
, UNSIGNED
);
393 return ((prec
+ HOST_BITS_PER_WIDE_INT
- 1)
394 / HOST_BITS_PER_WIDE_INT
);
398 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
400 enum debug_struct_file criterion
;
402 bool generic
= lang_hooks
.types
.generic_p (type
);
405 criterion
= debug_struct_generic
[usage
];
407 criterion
= debug_struct_ordinary
[usage
];
409 if (criterion
== DINFO_STRUCT_FILE_NONE
)
410 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
411 if (criterion
== DINFO_STRUCT_FILE_ANY
)
412 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
414 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
416 if (type_decl
!= NULL
)
418 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
419 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
421 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
422 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
425 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
428 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
429 switch to the data section instead, and write out a synthetic start label
430 for collect2 the first time around. */
433 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED
)
435 if (eh_frame_section
== 0)
439 if (EH_TABLES_CAN_BE_READ_ONLY
)
445 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
447 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
449 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
452 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
453 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
454 && (per_encoding
& 0x70) != DW_EH_PE_absptr
455 && (per_encoding
& 0x70) != DW_EH_PE_aligned
456 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
457 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
458 ? 0 : SECTION_WRITE
);
461 flags
= SECTION_WRITE
;
463 #ifdef EH_FRAME_SECTION_NAME
464 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
466 eh_frame_section
= ((flags
== SECTION_WRITE
)
467 ? data_section
: readonly_data_section
);
468 #endif /* EH_FRAME_SECTION_NAME */
471 switch_to_section (eh_frame_section
);
473 #ifdef EH_FRAME_THROUGH_COLLECT2
474 /* We have no special eh_frame section. Emit special labels to guide
478 tree label
= get_file_function_name ("F");
479 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
480 targetm
.asm_out
.globalize_label (asm_out_file
,
481 IDENTIFIER_POINTER (label
));
482 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
487 /* Switch [BACK] to the eh or debug frame table section, depending on
491 switch_to_frame_table_section (int for_eh
, bool back
)
494 switch_to_eh_frame_section (back
);
497 if (!debug_frame_section
)
498 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
499 SECTION_DEBUG
, NULL
);
500 switch_to_section (debug_frame_section
);
504 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
506 enum dw_cfi_oprnd_type
507 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
512 case DW_CFA_GNU_window_save
:
513 case DW_CFA_remember_state
:
514 case DW_CFA_restore_state
:
515 return dw_cfi_oprnd_unused
;
518 case DW_CFA_advance_loc1
:
519 case DW_CFA_advance_loc2
:
520 case DW_CFA_advance_loc4
:
521 case DW_CFA_MIPS_advance_loc8
:
522 return dw_cfi_oprnd_addr
;
525 case DW_CFA_offset_extended
:
527 case DW_CFA_offset_extended_sf
:
528 case DW_CFA_def_cfa_sf
:
530 case DW_CFA_restore_extended
:
531 case DW_CFA_undefined
:
532 case DW_CFA_same_value
:
533 case DW_CFA_def_cfa_register
:
534 case DW_CFA_register
:
535 case DW_CFA_expression
:
536 case DW_CFA_val_expression
:
537 return dw_cfi_oprnd_reg_num
;
539 case DW_CFA_def_cfa_offset
:
540 case DW_CFA_GNU_args_size
:
541 case DW_CFA_def_cfa_offset_sf
:
542 return dw_cfi_oprnd_offset
;
544 case DW_CFA_def_cfa_expression
:
545 return dw_cfi_oprnd_loc
;
552 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
554 enum dw_cfi_oprnd_type
555 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
560 case DW_CFA_def_cfa_sf
:
562 case DW_CFA_offset_extended_sf
:
563 case DW_CFA_offset_extended
:
564 return dw_cfi_oprnd_offset
;
566 case DW_CFA_register
:
567 return dw_cfi_oprnd_reg_num
;
569 case DW_CFA_expression
:
570 case DW_CFA_val_expression
:
571 return dw_cfi_oprnd_loc
;
574 return dw_cfi_oprnd_unused
;
578 /* Output one FDE. */
581 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
582 char *section_start_label
, int fde_encoding
, char *augmentation
,
583 bool any_lsda_needed
, int lsda_encoding
)
585 const char *begin
, *end
;
586 static unsigned int j
;
587 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
589 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
591 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
593 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
594 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
595 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
597 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
598 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
599 " indicating 64-bit DWARF extension");
600 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
603 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
606 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
608 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
609 debug_frame_section
, "FDE CIE offset");
611 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
612 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
616 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
617 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
618 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
619 "FDE initial location");
620 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
621 end
, begin
, "FDE address range");
625 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
626 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
633 int size
= size_of_encoded_value (lsda_encoding
);
635 if (lsda_encoding
== DW_EH_PE_aligned
)
637 int offset
= ( 4 /* Length */
639 + 2 * size_of_encoded_value (fde_encoding
)
640 + 1 /* Augmentation size */ );
641 int pad
= -offset
& (PTR_SIZE
- 1);
644 gcc_assert (size_of_uleb128 (size
) == 1);
647 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
649 if (fde
->uses_eh_lsda
)
651 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
652 fde
->funcdef_number
);
653 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
654 gen_rtx_SYMBOL_REF (Pmode
, l1
),
656 "Language Specific Data Area");
660 if (lsda_encoding
== DW_EH_PE_aligned
)
661 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
662 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
663 "Language Specific Data Area (none)");
667 dw2_asm_output_data_uleb128 (0, "Augmentation size");
670 /* Loop through the Call Frame Instructions associated with this FDE. */
671 fde
->dw_fde_current_label
= begin
;
673 size_t from
, until
, i
;
676 until
= vec_safe_length (fde
->dw_fde_cfi
);
678 if (fde
->dw_fde_second_begin
== NULL
)
681 until
= fde
->dw_fde_switch_cfi_index
;
683 from
= fde
->dw_fde_switch_cfi_index
;
685 for (i
= from
; i
< until
; i
++)
686 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
689 /* If we are to emit a ref/link from function bodies to their frame tables,
690 do it now. This is typically performed to make sure that tables
691 associated with functions are dragged with them and not discarded in
692 garbage collecting links. We need to do this on a per function basis to
693 cope with -ffunction-sections. */
695 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
696 /* Switch to the function section, emit the ref to the tables, and
697 switch *back* into the table section. */
698 switch_to_section (function_section (fde
->decl
));
699 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
700 switch_to_frame_table_section (for_eh
, true);
703 /* Pad the FDE out to an address sized boundary. */
704 ASM_OUTPUT_ALIGN (asm_out_file
,
705 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
706 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
711 /* Return true if frame description entry FDE is needed for EH. */
714 fde_needed_for_eh_p (dw_fde_ref fde
)
716 if (flag_asynchronous_unwind_tables
)
719 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
722 if (fde
->uses_eh_lsda
)
725 /* If exceptions are enabled, we have collected nothrow info. */
726 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
732 /* Output the call frame information used to record information
733 that relates to calculating the frame pointer, and records the
734 location of saved registers. */
737 output_call_frame_info (int for_eh
)
742 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
743 char section_start_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
744 bool any_lsda_needed
= false;
745 char augmentation
[6];
746 int augmentation_size
;
747 int fde_encoding
= DW_EH_PE_absptr
;
748 int per_encoding
= DW_EH_PE_absptr
;
749 int lsda_encoding
= DW_EH_PE_absptr
;
751 rtx personality
= NULL
;
754 /* Don't emit a CIE if there won't be any FDEs. */
758 /* Nothing to do if the assembler's doing it all. */
759 if (dwarf2out_do_cfi_asm ())
762 /* If we don't have any functions we'll want to unwind out of, don't emit
763 any EH unwind information. If we make FDEs linkonce, we may have to
764 emit an empty label for an FDE that wouldn't otherwise be emitted. We
765 want to avoid having an FDE kept around when the function it refers to
766 is discarded. Example where this matters: a primary function template
767 in C++ requires EH information, an explicit specialization doesn't. */
770 bool any_eh_needed
= false;
772 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
774 if (fde
->uses_eh_lsda
)
775 any_eh_needed
= any_lsda_needed
= true;
776 else if (fde_needed_for_eh_p (fde
))
777 any_eh_needed
= true;
778 else if (TARGET_USES_WEAK_UNWIND_INFO
)
779 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
786 /* We're going to be generating comments, so turn on app. */
790 /* Switch to the proper frame section, first time. */
791 switch_to_frame_table_section (for_eh
, false);
793 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
794 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
796 /* Output the CIE. */
797 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
798 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
799 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
801 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
802 dw2_asm_output_data (4, 0xffffffff,
803 "Initial length escape value indicating 64-bit DWARF extension");
804 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
805 "Length of Common Information Entry");
807 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
809 /* Now that the CIE pointer is PC-relative for EH,
810 use 0 to identify the CIE. */
811 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
812 (for_eh
? 0 : DWARF_CIE_ID
),
813 "CIE Identifier Tag");
815 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
816 use CIE version 1, unless that would produce incorrect results
817 due to overflowing the return register column. */
818 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
820 if (return_reg
>= 256 || dwarf_version
> 2)
822 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
825 augmentation_size
= 0;
827 personality
= current_unit_personality
;
833 z Indicates that a uleb128 is present to size the
834 augmentation section.
835 L Indicates the encoding (and thus presence) of
836 an LSDA pointer in the FDE augmentation.
837 R Indicates a non-default pointer encoding for
839 P Indicates the presence of an encoding + language
840 personality routine in the CIE augmentation. */
842 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
843 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
844 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
846 p
= augmentation
+ 1;
850 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
851 assemble_external_libcall (personality
);
856 augmentation_size
+= 1;
858 if (fde_encoding
!= DW_EH_PE_absptr
)
861 augmentation_size
+= 1;
863 if (p
> augmentation
+ 1)
865 augmentation
[0] = 'z';
869 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
870 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
872 int offset
= ( 4 /* Length */
874 + 1 /* CIE version */
875 + strlen (augmentation
) + 1 /* Augmentation */
876 + size_of_uleb128 (1) /* Code alignment */
877 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
879 + 1 /* Augmentation size */
880 + 1 /* Personality encoding */ );
881 int pad
= -offset
& (PTR_SIZE
- 1);
883 augmentation_size
+= pad
;
885 /* Augmentations should be small, so there's scarce need to
886 iterate for a solution. Die if we exceed one uleb128 byte. */
887 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
891 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
892 if (dw_cie_version
>= 4)
894 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
895 dw2_asm_output_data (1, 0, "CIE Segment Size");
897 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
898 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
899 "CIE Data Alignment Factor");
901 if (dw_cie_version
== 1)
902 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
904 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
908 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
911 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
912 eh_data_format_name (per_encoding
));
913 dw2_asm_output_encoded_addr_rtx (per_encoding
,
919 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
920 eh_data_format_name (lsda_encoding
));
922 if (fde_encoding
!= DW_EH_PE_absptr
)
923 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
924 eh_data_format_name (fde_encoding
));
927 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
928 output_cfi (cfi
, NULL
, for_eh
);
930 /* Pad the CIE out to an address sized boundary. */
931 ASM_OUTPUT_ALIGN (asm_out_file
,
932 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
933 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
935 /* Loop through all of the FDE's. */
936 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
940 /* Don't emit EH unwind info for leaf functions that don't need it. */
941 if (for_eh
&& !fde_needed_for_eh_p (fde
))
944 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
945 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
946 augmentation
, any_lsda_needed
, lsda_encoding
);
949 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
950 dw2_asm_output_data (4, 0, "End of Table");
952 /* Turn off app to make assembly quicker. */
957 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
960 dwarf2out_do_cfi_startproc (bool second
)
964 rtx personality
= get_personality_function (current_function_decl
);
966 fprintf (asm_out_file
, "\t.cfi_startproc\n");
970 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
973 /* ??? The GAS support isn't entirely consistent. We have to
974 handle indirect support ourselves, but PC-relative is done
975 in the assembler. Further, the assembler can't handle any
976 of the weirder relocation types. */
977 if (enc
& DW_EH_PE_indirect
)
978 ref
= dw2_force_const_mem (ref
, true);
980 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
981 output_addr_const (asm_out_file
, ref
);
982 fputc ('\n', asm_out_file
);
985 if (crtl
->uses_eh_lsda
)
987 char lab
[MAX_ARTIFICIAL_LABEL_BYTES
];
989 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
990 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
991 current_function_funcdef_no
);
992 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
993 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
995 if (enc
& DW_EH_PE_indirect
)
996 ref
= dw2_force_const_mem (ref
, true);
998 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
999 output_addr_const (asm_out_file
, ref
);
1000 fputc ('\n', asm_out_file
);
1004 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1005 this allocation may be done before pass_final. */
1008 dwarf2out_alloc_current_fde (void)
1012 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
1013 fde
->decl
= current_function_decl
;
1014 fde
->funcdef_number
= current_function_funcdef_no
;
1015 fde
->fde_index
= vec_safe_length (fde_vec
);
1016 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1017 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1018 fde
->nothrow
= crtl
->nothrow
;
1019 fde
->drap_reg
= INVALID_REGNUM
;
1020 fde
->vdrap_reg
= INVALID_REGNUM
;
1022 /* Record the FDE associated with this function. */
1024 vec_safe_push (fde_vec
, fde
);
1029 /* Output a marker (i.e. a label) for the beginning of a function, before
1033 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1034 unsigned int column ATTRIBUTE_UNUSED
,
1035 const char *file ATTRIBUTE_UNUSED
)
1037 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1043 current_function_func_begin_label
= NULL
;
1045 do_frame
= dwarf2out_do_frame ();
1047 /* ??? current_function_func_begin_label is also used by except.c for
1048 call-site information. We must emit this label if it might be used. */
1050 && (!flag_exceptions
1051 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1054 fnsec
= function_section (current_function_decl
);
1055 switch_to_section (fnsec
);
1056 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1057 current_function_funcdef_no
);
1058 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1059 current_function_funcdef_no
);
1060 dup_label
= xstrdup (label
);
1061 current_function_func_begin_label
= dup_label
;
1063 /* We can elide the fde allocation if we're not emitting debug info. */
1067 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1068 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1069 would include pass_dwarf2_frame. If we've not created the FDE yet,
1073 fde
= dwarf2out_alloc_current_fde ();
1075 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1076 fde
->dw_fde_begin
= dup_label
;
1077 fde
->dw_fde_current_label
= dup_label
;
1078 fde
->in_std_section
= (fnsec
== text_section
1079 || (cold_text_section
&& fnsec
== cold_text_section
));
1081 /* We only want to output line number information for the genuine dwarf2
1082 prologue case, not the eh frame case. */
1083 #ifdef DWARF2_DEBUGGING_INFO
1085 dwarf2out_source_line (line
, column
, file
, 0, true);
1088 if (dwarf2out_do_cfi_asm ())
1089 dwarf2out_do_cfi_startproc (false);
1092 rtx personality
= get_personality_function (current_function_decl
);
1093 if (!current_unit_personality
)
1094 current_unit_personality
= personality
;
1096 /* We cannot keep a current personality per function as without CFI
1097 asm, at the point where we emit the CFI data, there is no current
1098 function anymore. */
1099 if (personality
&& current_unit_personality
!= personality
)
1100 sorry ("multiple EH personalities are supported only with assemblers "
1101 "supporting .cfi_personality directive");
1105 /* Output a marker (i.e. a label) for the end of the generated code
1106 for a function prologue. This gets called *after* the prologue code has
1110 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1111 const char *file ATTRIBUTE_UNUSED
)
1113 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1115 /* Output a label to mark the endpoint of the code generated for this
1117 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1118 current_function_funcdef_no
);
1119 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1120 current_function_funcdef_no
);
1121 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1124 /* Output a marker (i.e. a label) for the beginning of the generated code
1125 for a function epilogue. This gets called *before* the prologue code has
1129 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1130 const char *file ATTRIBUTE_UNUSED
)
1132 dw_fde_ref fde
= cfun
->fde
;
1133 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1135 if (fde
->dw_fde_vms_begin_epilogue
)
1138 /* Output a label to mark the endpoint of the code generated for this
1140 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1141 current_function_funcdef_no
);
1142 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1143 current_function_funcdef_no
);
1144 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1147 /* Output a marker (i.e. a label) for the absolute end of the generated code
1148 for a function definition. This gets called *after* the epilogue code has
1152 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1153 const char *file ATTRIBUTE_UNUSED
)
1156 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1158 last_var_location_insn
= NULL
;
1159 cached_next_real_insn
= NULL
;
1161 if (dwarf2out_do_cfi_asm ())
1162 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1164 /* Output a label to mark the endpoint of the code generated for this
1166 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1167 current_function_funcdef_no
);
1168 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1170 gcc_assert (fde
!= NULL
);
1171 if (fde
->dw_fde_second_begin
== NULL
)
1172 fde
->dw_fde_end
= xstrdup (label
);
1176 dwarf2out_frame_finish (void)
1178 /* Output call frame information. */
1179 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1180 output_call_frame_info (0);
1182 /* Output another copy for the unwinder. */
1183 if ((flag_unwind_tables
|| flag_exceptions
)
1184 && targetm_common
.except_unwind_info (&global_options
) == UI_DWARF2
)
1185 output_call_frame_info (1);
1188 /* Note that the current function section is being used for code. */
1191 dwarf2out_note_section_used (void)
1193 section
*sec
= current_function_section ();
1194 if (sec
== text_section
)
1195 text_section_used
= true;
1196 else if (sec
== cold_text_section
)
1197 cold_text_section_used
= true;
1200 static void var_location_switch_text_section (void);
1201 static void set_cur_line_info_table (section
*);
1204 dwarf2out_switch_text_section (void)
1207 dw_fde_ref fde
= cfun
->fde
;
1209 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1211 if (!in_cold_section_p
)
1213 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1214 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1215 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1219 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1220 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1221 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1223 have_multiple_function_sections
= true;
1225 /* There is no need to mark used sections when not debugging. */
1226 if (cold_text_section
!= NULL
)
1227 dwarf2out_note_section_used ();
1229 if (dwarf2out_do_cfi_asm ())
1230 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1232 /* Now do the real section switch. */
1233 sect
= current_function_section ();
1234 switch_to_section (sect
);
1236 fde
->second_in_std_section
1237 = (sect
== text_section
1238 || (cold_text_section
&& sect
== cold_text_section
));
1240 if (dwarf2out_do_cfi_asm ())
1241 dwarf2out_do_cfi_startproc (true);
1243 var_location_switch_text_section ();
1245 if (cold_text_section
!= NULL
)
1246 set_cur_line_info_table (sect
);
1249 /* And now, the subset of the debugging information support code necessary
1250 for emitting location expressions. */
1252 /* Data about a single source file. */
1253 struct GTY((for_user
)) dwarf_file_data
{
1254 const char * filename
;
1258 /* Describe an entry into the .debug_addr section. */
1262 ate_kind_rtx_dtprel
,
1266 struct GTY((for_user
)) addr_table_entry
{
1268 unsigned int refcount
;
1270 union addr_table_entry_struct_union
1272 rtx
GTY ((tag ("0"))) rtl
;
1273 char * GTY ((tag ("1"))) label
;
1275 GTY ((desc ("%1.kind"))) addr
;
1278 /* Location lists are ranges + location descriptions for that range,
1279 so you can track variables that are in different places over
1280 their entire life. */
1281 typedef struct GTY(()) dw_loc_list_struct
{
1282 dw_loc_list_ref dw_loc_next
;
1283 const char *begin
; /* Label and addr_entry for start of range */
1284 addr_table_entry
*begin_entry
;
1285 const char *end
; /* Label for end of range */
1286 char *ll_symbol
; /* Label for beginning of location list.
1287 Only on head of list */
1288 const char *section
; /* Section this loclist is relative to */
1289 dw_loc_descr_ref expr
;
1291 /* True if all addresses in this and subsequent lists are known to be
1294 /* True if this list has been replaced by dw_loc_next. */
1296 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1298 unsigned char emitted
: 1;
1299 /* True if hash field is index rather than hash value. */
1300 unsigned char num_assigned
: 1;
1301 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1302 unsigned char offset_emitted
: 1;
1303 /* True if note_variable_value_in_expr has been called on it. */
1304 unsigned char noted_variable_value
: 1;
1305 /* True if the range should be emitted even if begin and end
1310 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
1311 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1313 /* Convert a DWARF stack opcode into its string name. */
1316 dwarf_stack_op_name (unsigned int op
)
1318 const char *name
= get_DW_OP_name (op
);
1323 return "OP_<unknown>";
1326 /* Return a pointer to a newly allocated location description. Location
1327 descriptions are simple expression terms that can be strung
1328 together to form more complicated location (address) descriptions. */
1330 static inline dw_loc_descr_ref
1331 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1332 unsigned HOST_WIDE_INT oprnd2
)
1334 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1336 descr
->dw_loc_opc
= op
;
1337 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1338 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1339 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1340 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1341 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1342 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1347 /* Return a pointer to a newly allocated location description for
1350 static inline dw_loc_descr_ref
1351 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
1354 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1357 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
1360 /* Add a location description term to a location description expression. */
1363 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1365 dw_loc_descr_ref
*d
;
1367 /* Find the end of the chain. */
1368 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1374 /* Compare two location operands for exact equality. */
1377 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1379 if (a
->val_class
!= b
->val_class
)
1381 switch (a
->val_class
)
1383 case dw_val_class_none
:
1385 case dw_val_class_addr
:
1386 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1388 case dw_val_class_offset
:
1389 case dw_val_class_unsigned_const
:
1390 case dw_val_class_const
:
1391 case dw_val_class_unsigned_const_implicit
:
1392 case dw_val_class_const_implicit
:
1393 case dw_val_class_range_list
:
1394 /* These are all HOST_WIDE_INT, signed or unsigned. */
1395 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1397 case dw_val_class_loc
:
1398 return a
->v
.val_loc
== b
->v
.val_loc
;
1399 case dw_val_class_loc_list
:
1400 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1401 case dw_val_class_die_ref
:
1402 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1403 case dw_val_class_fde_ref
:
1404 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1405 case dw_val_class_lbl_id
:
1406 case dw_val_class_lineptr
:
1407 case dw_val_class_macptr
:
1408 case dw_val_class_loclistsptr
:
1409 case dw_val_class_high_pc
:
1410 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1411 case dw_val_class_str
:
1412 return a
->v
.val_str
== b
->v
.val_str
;
1413 case dw_val_class_flag
:
1414 return a
->v
.val_flag
== b
->v
.val_flag
;
1415 case dw_val_class_file
:
1416 case dw_val_class_file_implicit
:
1417 return a
->v
.val_file
== b
->v
.val_file
;
1418 case dw_val_class_decl_ref
:
1419 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1421 case dw_val_class_const_double
:
1422 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1423 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1425 case dw_val_class_wide_int
:
1426 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1428 case dw_val_class_vec
:
1430 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1431 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1433 return (a_len
== b_len
1434 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1437 case dw_val_class_data8
:
1438 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1440 case dw_val_class_vms_delta
:
1441 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1442 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1444 case dw_val_class_discr_value
:
1445 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1446 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1447 case dw_val_class_discr_list
:
1448 /* It makes no sense comparing two discriminant value lists. */
1454 /* Compare two location atoms for exact equality. */
1457 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1459 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1462 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1463 address size, but since we always allocate cleared storage it
1464 should be zero for other types of locations. */
1465 if (a
->dtprel
!= b
->dtprel
)
1468 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1469 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1472 /* Compare two complete location expressions for exact equality. */
1475 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1481 if (a
== NULL
|| b
== NULL
)
1483 if (!loc_descr_equal_p_1 (a
, b
))
1492 /* Add a constant OFFSET to a location expression. */
1495 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
1497 dw_loc_descr_ref loc
;
1500 gcc_assert (*list_head
!= NULL
);
1505 /* Find the end of the chain. */
1506 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1510 if (loc
->dw_loc_opc
== DW_OP_fbreg
1511 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1512 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1513 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1514 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1516 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1517 offset. Don't optimize if an signed integer overflow would happen. */
1519 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1520 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1523 else if (offset
> 0)
1524 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1529 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT
) offset
);
1530 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1534 /* Add a constant OFFSET to a location list. */
1537 loc_list_plus_const (dw_loc_list_ref list_head
, HOST_WIDE_INT offset
)
1540 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1541 loc_descr_plus_const (&d
->expr
, offset
);
1544 #define DWARF_REF_SIZE \
1545 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1547 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1548 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1549 DW_FORM_data16 with 128 bits. */
1550 #define DWARF_LARGEST_DATA_FORM_BITS \
1551 (dwarf_version >= 5 ? 128 : 64)
1553 /* Utility inline function for construction of ops that were GNU extension
1555 static inline enum dwarf_location_atom
1556 dwarf_OP (enum dwarf_location_atom op
)
1560 case DW_OP_implicit_pointer
:
1561 if (dwarf_version
< 5)
1562 return DW_OP_GNU_implicit_pointer
;
1565 case DW_OP_entry_value
:
1566 if (dwarf_version
< 5)
1567 return DW_OP_GNU_entry_value
;
1570 case DW_OP_const_type
:
1571 if (dwarf_version
< 5)
1572 return DW_OP_GNU_const_type
;
1575 case DW_OP_regval_type
:
1576 if (dwarf_version
< 5)
1577 return DW_OP_GNU_regval_type
;
1580 case DW_OP_deref_type
:
1581 if (dwarf_version
< 5)
1582 return DW_OP_GNU_deref_type
;
1586 if (dwarf_version
< 5)
1587 return DW_OP_GNU_convert
;
1590 case DW_OP_reinterpret
:
1591 if (dwarf_version
< 5)
1592 return DW_OP_GNU_reinterpret
;
1601 /* Similarly for attributes. */
1602 static inline enum dwarf_attribute
1603 dwarf_AT (enum dwarf_attribute at
)
1607 case DW_AT_call_return_pc
:
1608 if (dwarf_version
< 5)
1609 return DW_AT_low_pc
;
1612 case DW_AT_call_tail_call
:
1613 if (dwarf_version
< 5)
1614 return DW_AT_GNU_tail_call
;
1617 case DW_AT_call_origin
:
1618 if (dwarf_version
< 5)
1619 return DW_AT_abstract_origin
;
1622 case DW_AT_call_target
:
1623 if (dwarf_version
< 5)
1624 return DW_AT_GNU_call_site_target
;
1627 case DW_AT_call_target_clobbered
:
1628 if (dwarf_version
< 5)
1629 return DW_AT_GNU_call_site_target_clobbered
;
1632 case DW_AT_call_parameter
:
1633 if (dwarf_version
< 5)
1634 return DW_AT_abstract_origin
;
1637 case DW_AT_call_value
:
1638 if (dwarf_version
< 5)
1639 return DW_AT_GNU_call_site_value
;
1642 case DW_AT_call_data_value
:
1643 if (dwarf_version
< 5)
1644 return DW_AT_GNU_call_site_data_value
;
1647 case DW_AT_call_all_calls
:
1648 if (dwarf_version
< 5)
1649 return DW_AT_GNU_all_call_sites
;
1652 case DW_AT_call_all_tail_calls
:
1653 if (dwarf_version
< 5)
1654 return DW_AT_GNU_all_tail_call_sites
;
1657 case DW_AT_dwo_name
:
1658 if (dwarf_version
< 5)
1659 return DW_AT_GNU_dwo_name
;
1668 /* And similarly for tags. */
1669 static inline enum dwarf_tag
1670 dwarf_TAG (enum dwarf_tag tag
)
1674 case DW_TAG_call_site
:
1675 if (dwarf_version
< 5)
1676 return DW_TAG_GNU_call_site
;
1679 case DW_TAG_call_site_parameter
:
1680 if (dwarf_version
< 5)
1681 return DW_TAG_GNU_call_site_parameter
;
1690 static unsigned long int get_base_type_offset (dw_die_ref
);
1692 /* Return the size of a location descriptor. */
1694 static unsigned long
1695 size_of_loc_descr (dw_loc_descr_ref loc
)
1697 unsigned long size
= 1;
1699 switch (loc
->dw_loc_opc
)
1702 size
+= DWARF2_ADDR_SIZE
;
1704 case DW_OP_GNU_addr_index
:
1705 case DW_OP_GNU_const_index
:
1706 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1707 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1726 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1729 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1734 case DW_OP_plus_uconst
:
1735 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1773 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1776 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1779 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1782 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1783 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1786 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1788 case DW_OP_bit_piece
:
1789 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1790 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1792 case DW_OP_deref_size
:
1793 case DW_OP_xderef_size
:
1802 case DW_OP_call_ref
:
1803 case DW_OP_GNU_variable_value
:
1804 size
+= DWARF_REF_SIZE
;
1806 case DW_OP_implicit_value
:
1807 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1808 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1810 case DW_OP_implicit_pointer
:
1811 case DW_OP_GNU_implicit_pointer
:
1812 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1814 case DW_OP_entry_value
:
1815 case DW_OP_GNU_entry_value
:
1817 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1818 size
+= size_of_uleb128 (op_size
) + op_size
;
1821 case DW_OP_const_type
:
1822 case DW_OP_GNU_const_type
:
1825 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1826 size
+= size_of_uleb128 (o
) + 1;
1827 switch (loc
->dw_loc_oprnd2
.val_class
)
1829 case dw_val_class_vec
:
1830 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1831 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1833 case dw_val_class_const
:
1834 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1836 case dw_val_class_const_double
:
1837 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1839 case dw_val_class_wide_int
:
1840 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1841 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1848 case DW_OP_regval_type
:
1849 case DW_OP_GNU_regval_type
:
1852 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1853 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1854 + size_of_uleb128 (o
);
1857 case DW_OP_deref_type
:
1858 case DW_OP_GNU_deref_type
:
1861 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1862 size
+= 1 + size_of_uleb128 (o
);
1866 case DW_OP_reinterpret
:
1867 case DW_OP_GNU_convert
:
1868 case DW_OP_GNU_reinterpret
:
1869 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1870 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1874 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1875 size
+= size_of_uleb128 (o
);
1878 case DW_OP_GNU_parameter_ref
:
1888 /* Return the size of a series of location descriptors. */
1891 size_of_locs (dw_loc_descr_ref loc
)
1896 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1897 field, to avoid writing to a PCH file. */
1898 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1900 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1902 size
+= size_of_loc_descr (l
);
1907 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1909 l
->dw_loc_addr
= size
;
1910 size
+= size_of_loc_descr (l
);
1916 /* Return the size of the value in a DW_AT_discr_value attribute. */
1919 size_of_discr_value (dw_discr_value
*discr_value
)
1921 if (discr_value
->pos
)
1922 return size_of_uleb128 (discr_value
->v
.uval
);
1924 return size_of_sleb128 (discr_value
->v
.sval
);
1927 /* Return the size of the value in a DW_AT_discr_list attribute. */
1930 size_of_discr_list (dw_discr_list_ref discr_list
)
1934 for (dw_discr_list_ref list
= discr_list
;
1936 list
= list
->dw_discr_next
)
1938 /* One byte for the discriminant value descriptor, and then one or two
1939 LEB128 numbers, depending on whether it's a single case label or a
1942 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
1943 if (list
->dw_discr_range
!= 0)
1944 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
1949 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
1950 static void get_ref_die_offset_label (char *, dw_die_ref
);
1951 static unsigned long int get_ref_die_offset (dw_die_ref
);
1953 /* Output location description stack opcode's operands (if any).
1954 The for_eh_or_skip parameter controls whether register numbers are
1955 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1956 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1957 info). This should be suppressed for the cases that have not been converted
1958 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1961 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
1963 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
1964 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
1966 switch (loc
->dw_loc_opc
)
1968 #ifdef DWARF2_DEBUGGING_INFO
1971 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
1976 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1977 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
1979 fputc ('\n', asm_out_file
);
1984 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
1989 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1990 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
1992 fputc ('\n', asm_out_file
);
1997 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
1998 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2005 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2006 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2008 dw2_asm_output_data (2, offset
, NULL
);
2011 case DW_OP_implicit_value
:
2012 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2013 switch (val2
->val_class
)
2015 case dw_val_class_const
:
2016 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2018 case dw_val_class_vec
:
2020 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2021 unsigned int len
= val2
->v
.val_vec
.length
;
2025 if (elt_size
> sizeof (HOST_WIDE_INT
))
2030 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2033 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2034 "fp or vector constant word %u", i
);
2037 case dw_val_class_const_double
:
2039 unsigned HOST_WIDE_INT first
, second
;
2041 if (WORDS_BIG_ENDIAN
)
2043 first
= val2
->v
.val_double
.high
;
2044 second
= val2
->v
.val_double
.low
;
2048 first
= val2
->v
.val_double
.low
;
2049 second
= val2
->v
.val_double
.high
;
2051 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2053 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2057 case dw_val_class_wide_int
:
2060 int len
= get_full_len (*val2
->v
.val_wide
);
2061 if (WORDS_BIG_ENDIAN
)
2062 for (i
= len
- 1; i
>= 0; --i
)
2063 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2064 val2
->v
.val_wide
->elt (i
), NULL
);
2066 for (i
= 0; i
< len
; ++i
)
2067 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2068 val2
->v
.val_wide
->elt (i
), NULL
);
2071 case dw_val_class_addr
:
2072 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2073 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2088 case DW_OP_implicit_value
:
2089 /* We currently don't make any attempt to make sure these are
2090 aligned properly like we do for the main unwind info, so
2091 don't support emitting things larger than a byte if we're
2092 only doing unwinding. */
2097 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2100 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2103 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2106 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2108 case DW_OP_plus_uconst
:
2109 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2143 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2147 unsigned r
= val1
->v
.val_unsigned
;
2148 if (for_eh_or_skip
>= 0)
2149 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2150 gcc_assert (size_of_uleb128 (r
)
2151 == size_of_uleb128 (val1
->v
.val_unsigned
));
2152 dw2_asm_output_data_uleb128 (r
, NULL
);
2156 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2160 unsigned r
= val1
->v
.val_unsigned
;
2161 if (for_eh_or_skip
>= 0)
2162 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2163 gcc_assert (size_of_uleb128 (r
)
2164 == size_of_uleb128 (val1
->v
.val_unsigned
));
2165 dw2_asm_output_data_uleb128 (r
, NULL
);
2166 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2170 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2172 case DW_OP_bit_piece
:
2173 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2174 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2176 case DW_OP_deref_size
:
2177 case DW_OP_xderef_size
:
2178 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2184 if (targetm
.asm_out
.output_dwarf_dtprel
)
2186 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2189 fputc ('\n', asm_out_file
);
2196 #ifdef DWARF2_DEBUGGING_INFO
2197 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2204 case DW_OP_GNU_addr_index
:
2205 case DW_OP_GNU_const_index
:
2206 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2207 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2208 "(index into .debug_addr)");
2214 unsigned long die_offset
2215 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2216 /* Make sure the offset has been computed and that we can encode it as
2218 gcc_assert (die_offset
> 0
2219 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
2222 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2227 case DW_OP_call_ref
:
2228 case DW_OP_GNU_variable_value
:
2230 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2231 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2232 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2233 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2234 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2238 case DW_OP_implicit_pointer
:
2239 case DW_OP_GNU_implicit_pointer
:
2241 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2242 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2243 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2244 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2245 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2246 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2250 case DW_OP_entry_value
:
2251 case DW_OP_GNU_entry_value
:
2252 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2253 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2256 case DW_OP_const_type
:
2257 case DW_OP_GNU_const_type
:
2259 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2261 dw2_asm_output_data_uleb128 (o
, NULL
);
2262 switch (val2
->val_class
)
2264 case dw_val_class_const
:
2265 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2266 dw2_asm_output_data (1, l
, NULL
);
2267 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2269 case dw_val_class_vec
:
2271 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2272 unsigned int len
= val2
->v
.val_vec
.length
;
2277 dw2_asm_output_data (1, l
, NULL
);
2278 if (elt_size
> sizeof (HOST_WIDE_INT
))
2283 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2286 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2287 "fp or vector constant word %u", i
);
2290 case dw_val_class_const_double
:
2292 unsigned HOST_WIDE_INT first
, second
;
2293 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2295 dw2_asm_output_data (1, 2 * l
, NULL
);
2296 if (WORDS_BIG_ENDIAN
)
2298 first
= val2
->v
.val_double
.high
;
2299 second
= val2
->v
.val_double
.low
;
2303 first
= val2
->v
.val_double
.low
;
2304 second
= val2
->v
.val_double
.high
;
2306 dw2_asm_output_data (l
, first
, NULL
);
2307 dw2_asm_output_data (l
, second
, NULL
);
2310 case dw_val_class_wide_int
:
2313 int len
= get_full_len (*val2
->v
.val_wide
);
2314 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2316 dw2_asm_output_data (1, len
* l
, NULL
);
2317 if (WORDS_BIG_ENDIAN
)
2318 for (i
= len
- 1; i
>= 0; --i
)
2319 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2321 for (i
= 0; i
< len
; ++i
)
2322 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2330 case DW_OP_regval_type
:
2331 case DW_OP_GNU_regval_type
:
2333 unsigned r
= val1
->v
.val_unsigned
;
2334 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2336 if (for_eh_or_skip
>= 0)
2338 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2339 gcc_assert (size_of_uleb128 (r
)
2340 == size_of_uleb128 (val1
->v
.val_unsigned
));
2342 dw2_asm_output_data_uleb128 (r
, NULL
);
2343 dw2_asm_output_data_uleb128 (o
, NULL
);
2346 case DW_OP_deref_type
:
2347 case DW_OP_GNU_deref_type
:
2349 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2351 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2352 dw2_asm_output_data_uleb128 (o
, NULL
);
2356 case DW_OP_reinterpret
:
2357 case DW_OP_GNU_convert
:
2358 case DW_OP_GNU_reinterpret
:
2359 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2360 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2363 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2365 dw2_asm_output_data_uleb128 (o
, NULL
);
2369 case DW_OP_GNU_parameter_ref
:
2372 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2373 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2374 dw2_asm_output_data (4, o
, NULL
);
2379 /* Other codes have no operands. */
2384 /* Output a sequence of location operations.
2385 The for_eh_or_skip parameter controls whether register numbers are
2386 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2387 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2388 info). This should be suppressed for the cases that have not been converted
2389 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2392 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2394 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2396 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2397 /* Output the opcode. */
2398 if (for_eh_or_skip
>= 0
2399 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2401 unsigned r
= (opc
- DW_OP_breg0
);
2402 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2403 gcc_assert (r
<= 31);
2404 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2406 else if (for_eh_or_skip
>= 0
2407 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2409 unsigned r
= (opc
- DW_OP_reg0
);
2410 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2411 gcc_assert (r
<= 31);
2412 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2415 dw2_asm_output_data (1, opc
,
2416 "%s", dwarf_stack_op_name (opc
));
2418 /* Output the operand(s) (if any). */
2419 output_loc_operands (loc
, for_eh_or_skip
);
2423 /* Output location description stack opcode's operands (if any).
2424 The output is single bytes on a line, suitable for .cfi_escape. */
2427 output_loc_operands_raw (dw_loc_descr_ref loc
)
2429 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2430 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2432 switch (loc
->dw_loc_opc
)
2435 case DW_OP_GNU_addr_index
:
2436 case DW_OP_GNU_const_index
:
2437 case DW_OP_implicit_value
:
2438 /* We cannot output addresses in .cfi_escape, only bytes. */
2444 case DW_OP_deref_size
:
2445 case DW_OP_xderef_size
:
2446 fputc (',', asm_out_file
);
2447 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2452 fputc (',', asm_out_file
);
2453 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2458 fputc (',', asm_out_file
);
2459 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2464 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2465 fputc (',', asm_out_file
);
2466 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2474 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2475 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2477 fputc (',', asm_out_file
);
2478 dw2_asm_output_data_raw (2, offset
);
2484 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2485 gcc_assert (size_of_uleb128 (r
)
2486 == size_of_uleb128 (val1
->v
.val_unsigned
));
2487 fputc (',', asm_out_file
);
2488 dw2_asm_output_data_uleb128_raw (r
);
2493 case DW_OP_plus_uconst
:
2495 fputc (',', asm_out_file
);
2496 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2499 case DW_OP_bit_piece
:
2500 fputc (',', asm_out_file
);
2501 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2502 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2539 fputc (',', asm_out_file
);
2540 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2545 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2546 gcc_assert (size_of_uleb128 (r
)
2547 == size_of_uleb128 (val1
->v
.val_unsigned
));
2548 fputc (',', asm_out_file
);
2549 dw2_asm_output_data_uleb128_raw (r
);
2550 fputc (',', asm_out_file
);
2551 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2555 case DW_OP_implicit_pointer
:
2556 case DW_OP_entry_value
:
2557 case DW_OP_const_type
:
2558 case DW_OP_regval_type
:
2559 case DW_OP_deref_type
:
2561 case DW_OP_reinterpret
:
2562 case DW_OP_GNU_implicit_pointer
:
2563 case DW_OP_GNU_entry_value
:
2564 case DW_OP_GNU_const_type
:
2565 case DW_OP_GNU_regval_type
:
2566 case DW_OP_GNU_deref_type
:
2567 case DW_OP_GNU_convert
:
2568 case DW_OP_GNU_reinterpret
:
2569 case DW_OP_GNU_parameter_ref
:
2574 /* Other codes have no operands. */
2580 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2584 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2585 /* Output the opcode. */
2586 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2588 unsigned r
= (opc
- DW_OP_breg0
);
2589 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2590 gcc_assert (r
<= 31);
2591 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2593 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2595 unsigned r
= (opc
- DW_OP_reg0
);
2596 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2597 gcc_assert (r
<= 31);
2598 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2600 /* Output the opcode. */
2601 fprintf (asm_out_file
, "%#x", opc
);
2602 output_loc_operands_raw (loc
);
2604 if (!loc
->dw_loc_next
)
2606 loc
= loc
->dw_loc_next
;
2608 fputc (',', asm_out_file
);
2612 /* This function builds a dwarf location descriptor sequence from a
2613 dw_cfa_location, adding the given OFFSET to the result of the
2616 struct dw_loc_descr_node
*
2617 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
2619 struct dw_loc_descr_node
*head
, *tmp
;
2621 offset
+= cfa
->offset
;
2625 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2626 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2627 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2628 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2629 add_loc_descr (&head
, tmp
);
2632 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
2633 add_loc_descr (&head
, tmp
);
2637 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2642 /* This function builds a dwarf location descriptor sequence for
2643 the address at OFFSET from the CFA when stack is aligned to
2646 struct dw_loc_descr_node
*
2647 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2648 HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
2650 struct dw_loc_descr_node
*head
;
2651 unsigned int dwarf_fp
2652 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2654 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2655 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2657 head
= new_reg_loc_descr (dwarf_fp
, 0);
2658 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2659 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2660 loc_descr_plus_const (&head
, offset
);
2663 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2667 /* And now, the support for symbolic debugging information. */
2669 /* .debug_str support. */
2671 static void dwarf2out_init (const char *);
2672 static void dwarf2out_finish (const char *);
2673 static void dwarf2out_early_finish (const char *);
2674 static void dwarf2out_assembly_start (void);
2675 static void dwarf2out_define (unsigned int, const char *);
2676 static void dwarf2out_undef (unsigned int, const char *);
2677 static void dwarf2out_start_source_file (unsigned, const char *);
2678 static void dwarf2out_end_source_file (unsigned);
2679 static void dwarf2out_function_decl (tree
);
2680 static void dwarf2out_begin_block (unsigned, unsigned);
2681 static void dwarf2out_end_block (unsigned, unsigned);
2682 static bool dwarf2out_ignore_block (const_tree
);
2683 static void dwarf2out_early_global_decl (tree
);
2684 static void dwarf2out_late_global_decl (tree
);
2685 static void dwarf2out_type_decl (tree
, int);
2686 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool, bool);
2687 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2689 static void dwarf2out_abstract_function (tree
);
2690 static void dwarf2out_var_location (rtx_insn
*);
2691 static void dwarf2out_size_function (tree
);
2692 static void dwarf2out_begin_function (tree
);
2693 static void dwarf2out_end_function (unsigned int);
2694 static void dwarf2out_register_main_translation_unit (tree unit
);
2695 static void dwarf2out_set_name (tree
, tree
);
2696 static void dwarf2out_register_external_die (tree decl
, const char *sym
,
2697 unsigned HOST_WIDE_INT off
);
2698 static bool dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
2699 unsigned HOST_WIDE_INT
*off
);
2701 /* The debug hooks structure. */
2703 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2707 dwarf2out_early_finish
,
2708 dwarf2out_assembly_start
,
2711 dwarf2out_start_source_file
,
2712 dwarf2out_end_source_file
,
2713 dwarf2out_begin_block
,
2714 dwarf2out_end_block
,
2715 dwarf2out_ignore_block
,
2716 dwarf2out_source_line
,
2717 dwarf2out_begin_prologue
,
2718 #if VMS_DEBUGGING_INFO
2719 dwarf2out_vms_end_prologue
,
2720 dwarf2out_vms_begin_epilogue
,
2722 debug_nothing_int_charstar
,
2723 debug_nothing_int_charstar
,
2725 dwarf2out_end_epilogue
,
2726 dwarf2out_begin_function
,
2727 dwarf2out_end_function
, /* end_function */
2728 dwarf2out_register_main_translation_unit
,
2729 dwarf2out_function_decl
, /* function_decl */
2730 dwarf2out_early_global_decl
,
2731 dwarf2out_late_global_decl
,
2732 dwarf2out_type_decl
, /* type_decl */
2733 dwarf2out_imported_module_or_decl
,
2734 dwarf2out_die_ref_for_decl
,
2735 dwarf2out_register_external_die
,
2736 debug_nothing_tree
, /* deferred_inline_function */
2737 /* The DWARF 2 backend tries to reduce debugging bloat by not
2738 emitting the abstract description of inline functions until
2739 something tries to reference them. */
2740 dwarf2out_abstract_function
, /* outlining_inline_function */
2741 debug_nothing_rtx_code_label
, /* label */
2742 debug_nothing_int
, /* handle_pch */
2743 dwarf2out_var_location
,
2744 dwarf2out_size_function
, /* size_function */
2745 dwarf2out_switch_text_section
,
2747 1, /* start_end_main_source_file */
2748 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2751 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2754 debug_nothing_charstar
,
2755 debug_nothing_charstar
,
2756 dwarf2out_assembly_start
,
2757 debug_nothing_int_charstar
,
2758 debug_nothing_int_charstar
,
2759 debug_nothing_int_charstar
,
2761 debug_nothing_int_int
, /* begin_block */
2762 debug_nothing_int_int
, /* end_block */
2763 debug_true_const_tree
, /* ignore_block */
2764 dwarf2out_source_line
, /* source_line */
2765 debug_nothing_int_int_charstar
, /* begin_prologue */
2766 debug_nothing_int_charstar
, /* end_prologue */
2767 debug_nothing_int_charstar
, /* begin_epilogue */
2768 debug_nothing_int_charstar
, /* end_epilogue */
2769 debug_nothing_tree
, /* begin_function */
2770 debug_nothing_int
, /* end_function */
2771 debug_nothing_tree
, /* register_main_translation_unit */
2772 debug_nothing_tree
, /* function_decl */
2773 debug_nothing_tree
, /* early_global_decl */
2774 debug_nothing_tree
, /* late_global_decl */
2775 debug_nothing_tree_int
, /* type_decl */
2776 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
2777 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
2778 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
2779 debug_nothing_tree
, /* deferred_inline_function */
2780 debug_nothing_tree
, /* outlining_inline_function */
2781 debug_nothing_rtx_code_label
, /* label */
2782 debug_nothing_int
, /* handle_pch */
2783 debug_nothing_rtx_insn
, /* var_location */
2784 debug_nothing_tree
, /* size_function */
2785 debug_nothing_void
, /* switch_text_section */
2786 debug_nothing_tree_tree
, /* set_name */
2787 0, /* start_end_main_source_file */
2788 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
2791 /* NOTE: In the comments in this file, many references are made to
2792 "Debugging Information Entries". This term is abbreviated as `DIE'
2793 throughout the remainder of this file. */
2795 /* An internal representation of the DWARF output is built, and then
2796 walked to generate the DWARF debugging info. The walk of the internal
2797 representation is done after the entire program has been compiled.
2798 The types below are used to describe the internal representation. */
2800 /* Whether to put type DIEs into their own section .debug_types instead
2801 of making them part of the .debug_info section. Only supported for
2802 Dwarf V4 or higher and the user didn't disable them through
2803 -fno-debug-types-section. It is more efficient to put them in a
2804 separate comdat sections since the linker will then be able to
2805 remove duplicates. But not all tools support .debug_types sections
2806 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
2807 it is DW_UT_type unit type in .debug_info section. */
2809 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2811 /* Various DIE's use offsets relative to the beginning of the
2812 .debug_info section to refer to each other. */
2814 typedef long int dw_offset
;
2816 struct comdat_type_node
;
2818 /* The entries in the line_info table more-or-less mirror the opcodes
2819 that are used in the real dwarf line table. Arrays of these entries
2820 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2823 enum dw_line_info_opcode
{
2824 /* Emit DW_LNE_set_address; the operand is the label index. */
2827 /* Emit a row to the matrix with the given line. This may be done
2828 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2832 /* Emit a DW_LNS_set_file. */
2835 /* Emit a DW_LNS_set_column. */
2838 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2841 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2842 LI_set_prologue_end
,
2843 LI_set_epilogue_begin
,
2845 /* Emit a DW_LNE_set_discriminator. */
2846 LI_set_discriminator
2849 typedef struct GTY(()) dw_line_info_struct
{
2850 enum dw_line_info_opcode opcode
;
2852 } dw_line_info_entry
;
2855 struct GTY(()) dw_line_info_table
{
2856 /* The label that marks the end of this section. */
2857 const char *end_label
;
2859 /* The values for the last row of the matrix, as collected in the table.
2860 These are used to minimize the changes to the next row. */
2861 unsigned int file_num
;
2862 unsigned int line_num
;
2863 unsigned int column_num
;
2868 vec
<dw_line_info_entry
, va_gc
> *entries
;
2872 /* Each DIE attribute has a field specifying the attribute kind,
2873 a link to the next attribute in the chain, and an attribute value.
2874 Attributes are typically linked below the DIE they modify. */
2876 typedef struct GTY(()) dw_attr_struct
{
2877 enum dwarf_attribute dw_attr
;
2878 dw_val_node dw_attr_val
;
2883 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2884 The children of each node form a circular list linked by
2885 die_sib. die_child points to the node *before* the "first" child node. */
2887 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
2888 union die_symbol_or_type_node
2890 const char * GTY ((tag ("0"))) die_symbol
;
2891 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
2893 GTY ((desc ("%0.comdat_type_p"))) die_id
;
2894 vec
<dw_attr_node
, va_gc
> *die_attr
;
2895 dw_die_ref die_parent
;
2896 dw_die_ref die_child
;
2898 dw_die_ref die_definition
; /* ref from a specification to its definition */
2899 dw_offset die_offset
;
2900 unsigned long die_abbrev
;
2902 unsigned int decl_id
;
2903 enum dwarf_tag die_tag
;
2904 /* Die is used and must not be pruned as unused. */
2905 BOOL_BITFIELD die_perennial_p
: 1;
2906 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
2907 /* For an external ref to die_symbol if die_offset contains an extra
2908 offset to that symbol. */
2909 BOOL_BITFIELD with_offset
: 1;
2910 /* Whether this DIE was removed from the DIE tree, for example via
2911 prune_unused_types. We don't consider those present from the
2912 DIE lookup routines. */
2913 BOOL_BITFIELD removed
: 1;
2914 /* Lots of spare bits. */
2918 /* Set to TRUE while dwarf2out_early_global_decl is running. */
2919 static bool early_dwarf
;
2920 static bool early_dwarf_finished
;
2921 struct set_early_dwarf
{
2923 set_early_dwarf () : saved(early_dwarf
)
2925 gcc_assert (! early_dwarf_finished
);
2928 ~set_early_dwarf () { early_dwarf
= saved
; }
2931 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2932 #define FOR_EACH_CHILD(die, c, expr) do { \
2933 c = die->die_child; \
2937 } while (c != die->die_child); \
2940 /* The pubname structure */
2942 typedef struct GTY(()) pubname_struct
{
2949 struct GTY(()) dw_ranges
{
2951 /* If this is positive, it's a block number, otherwise it's a
2952 bitwise-negated index into dw_ranges_by_label. */
2954 /* Index for the range list for DW_FORM_rnglistx. */
2955 unsigned int idx
: 31;
2956 /* True if this range might be possibly in a different section
2957 from previous entry. */
2958 unsigned int maybe_new_sec
: 1;
2961 /* A structure to hold a macinfo entry. */
2963 typedef struct GTY(()) macinfo_struct
{
2965 unsigned HOST_WIDE_INT lineno
;
2971 struct GTY(()) dw_ranges_by_label
{
2976 /* The comdat type node structure. */
2977 struct GTY(()) comdat_type_node
2979 dw_die_ref root_die
;
2980 dw_die_ref type_die
;
2981 dw_die_ref skeleton_die
;
2982 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
2983 comdat_type_node
*next
;
2986 /* A list of DIEs for which we can't determine ancestry (parent_die
2987 field) just yet. Later in dwarf2out_finish we will fill in the
2989 typedef struct GTY(()) limbo_die_struct
{
2991 /* The tree for which this DIE was created. We use this to
2992 determine ancestry later. */
2994 struct limbo_die_struct
*next
;
2998 typedef struct skeleton_chain_struct
3002 struct skeleton_chain_struct
*parent
;
3004 skeleton_chain_node
;
3006 /* Define a macro which returns nonzero for a TYPE_DECL which was
3007 implicitly generated for a type.
3009 Note that, unlike the C front-end (which generates a NULL named
3010 TYPE_DECL node for each complete tagged type, each array type,
3011 and each function type node created) the C++ front-end generates
3012 a _named_ TYPE_DECL node for each tagged type node created.
3013 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3014 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3015 front-end, but for each type, tagged or not. */
3017 #define TYPE_DECL_IS_STUB(decl) \
3018 (DECL_NAME (decl) == NULL_TREE \
3019 || (DECL_ARTIFICIAL (decl) \
3020 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3021 /* This is necessary for stub decls that \
3022 appear in nested inline functions. */ \
3023 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3024 && (decl_ultimate_origin (decl) \
3025 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3027 /* Information concerning the compilation unit's programming
3028 language, and compiler version. */
3030 /* Fixed size portion of the DWARF compilation unit header. */
3031 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3032 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE \
3033 + (dwarf_version >= 5 ? 4 : 3))
3035 /* Fixed size portion of the DWARF comdat type unit header. */
3036 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3037 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3038 + DWARF_TYPE_SIGNATURE_SIZE + DWARF_OFFSET_SIZE)
3040 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3041 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3042 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3044 /* Fixed size portion of public names info. */
3045 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3047 /* Fixed size portion of the address range info. */
3048 #define DWARF_ARANGES_HEADER_SIZE \
3049 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3050 DWARF2_ADDR_SIZE * 2) \
3051 - DWARF_INITIAL_LENGTH_SIZE)
3053 /* Size of padding portion in the address range info. It must be
3054 aligned to twice the pointer size. */
3055 #define DWARF_ARANGES_PAD_SIZE \
3056 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3057 DWARF2_ADDR_SIZE * 2) \
3058 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3060 /* Use assembler line directives if available. */
3061 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3062 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3063 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3065 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3069 /* Minimum line offset in a special line info. opcode.
3070 This value was chosen to give a reasonable range of values. */
3071 #define DWARF_LINE_BASE -10
3073 /* First special line opcode - leave room for the standard opcodes. */
3074 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3076 /* Range of line offsets in a special line info. opcode. */
3077 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3079 /* Flag that indicates the initial value of the is_stmt_start flag.
3080 In the present implementation, we do not mark any lines as
3081 the beginning of a source statement, because that information
3082 is not made available by the GCC front-end. */
3083 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3085 /* Maximum number of operations per instruction bundle. */
3086 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3087 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3090 /* This location is used by calc_die_sizes() to keep track
3091 the offset of each DIE within the .debug_info section. */
3092 static unsigned long next_die_offset
;
3094 /* Record the root of the DIE's built for the current compilation unit. */
3095 static GTY(()) dw_die_ref single_comp_unit_die
;
3097 /* A list of type DIEs that have been separated into comdat sections. */
3098 static GTY(()) comdat_type_node
*comdat_type_list
;
3100 /* A list of CU DIEs that have been separated. */
3101 static GTY(()) limbo_die_node
*cu_die_list
;
3103 /* A list of DIEs with a NULL parent waiting to be relocated. */
3104 static GTY(()) limbo_die_node
*limbo_die_list
;
3106 /* A list of DIEs for which we may have to generate
3107 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3108 static GTY(()) limbo_die_node
*deferred_asm_name
;
3110 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
3112 typedef const char *compare_type
;
3114 static hashval_t
hash (dwarf_file_data
*);
3115 static bool equal (dwarf_file_data
*, const char *);
3118 /* Filenames referenced by this compilation unit. */
3119 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
3121 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
3123 typedef tree compare_type
;
3125 static hashval_t
hash (die_node
*);
3126 static bool equal (die_node
*, tree
);
3128 /* A hash table of references to DIE's that describe declarations.
3129 The key is a DECL_UID() which is a unique number identifying each decl. */
3130 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
3132 struct GTY ((for_user
)) variable_value_struct
{
3133 unsigned int decl_id
;
3134 vec
<dw_die_ref
, va_gc
> *dies
;
3137 struct variable_value_hasher
: ggc_ptr_hash
<variable_value_struct
>
3139 typedef tree compare_type
;
3141 static hashval_t
hash (variable_value_struct
*);
3142 static bool equal (variable_value_struct
*, tree
);
3144 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3145 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3146 DECL_CONTEXT of the referenced VAR_DECLs. */
3147 static GTY (()) hash_table
<variable_value_hasher
> *variable_value_hash
;
3149 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
3151 static hashval_t
hash (die_struct
*);
3152 static bool equal (die_struct
*, die_struct
*);
3155 /* A hash table of references to DIE's that describe COMMON blocks.
3156 The key is DECL_UID() ^ die_parent. */
3157 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
3159 typedef struct GTY(()) die_arg_entry_struct
{
3165 /* Node of the variable location list. */
3166 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3167 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3168 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3169 in mode of the EXPR_LIST node and first EXPR_LIST operand
3170 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3171 location or NULL for padding. For larger bitsizes,
3172 mode is 0 and first operand is a CONCAT with bitsize
3173 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3174 NULL as second operand. */
3176 const char * GTY (()) label
;
3177 struct var_loc_node
* GTY (()) next
;
3180 /* Variable location list. */
3181 struct GTY ((for_user
)) var_loc_list_def
{
3182 struct var_loc_node
* GTY (()) first
;
3184 /* Pointer to the last but one or last element of the
3185 chained list. If the list is empty, both first and
3186 last are NULL, if the list contains just one node
3187 or the last node certainly is not redundant, it points
3188 to the last node, otherwise points to the last but one.
3189 Do not mark it for GC because it is marked through the chain. */
3190 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3192 /* Pointer to the last element before section switch,
3193 if NULL, either sections weren't switched or first
3194 is after section switch. */
3195 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3197 /* DECL_UID of the variable decl. */
3198 unsigned int decl_id
;
3200 typedef struct var_loc_list_def var_loc_list
;
3202 /* Call argument location list. */
3203 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3204 rtx
GTY (()) call_arg_loc_note
;
3205 const char * GTY (()) label
;
3206 tree
GTY (()) block
;
3208 rtx
GTY (()) symbol_ref
;
3209 struct call_arg_loc_node
* GTY (()) next
;
3213 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
3215 typedef const_tree compare_type
;
3217 static hashval_t
hash (var_loc_list
*);
3218 static bool equal (var_loc_list
*, const_tree
);
3221 /* Table of decl location linked lists. */
3222 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
3224 /* Head and tail of call_arg_loc chain. */
3225 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3226 static struct call_arg_loc_node
*call_arg_loc_last
;
3228 /* Number of call sites in the current function. */
3229 static int call_site_count
= -1;
3230 /* Number of tail call sites in the current function. */
3231 static int tail_call_site_count
= -1;
3233 /* A cached location list. */
3234 struct GTY ((for_user
)) cached_dw_loc_list_def
{
3235 /* The DECL_UID of the decl that this entry describes. */
3236 unsigned int decl_id
;
3238 /* The cached location list. */
3239 dw_loc_list_ref loc_list
;
3241 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3243 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3246 typedef const_tree compare_type
;
3248 static hashval_t
hash (cached_dw_loc_list
*);
3249 static bool equal (cached_dw_loc_list
*, const_tree
);
3252 /* Table of cached location lists. */
3253 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3255 /* A vector of references to DIE's that are uniquely identified by their tag,
3256 presence/absence of children DIE's, and list of attribute/value pairs. */
3257 static GTY(()) vec
<dw_die_ref
, va_gc
> *abbrev_die_table
;
3259 /* A hash map to remember the stack usage for DWARF procedures. The value
3260 stored is the stack size difference between before the DWARF procedure
3261 invokation and after it returned. In other words, for a DWARF procedure
3262 that consumes N stack slots and that pushes M ones, this stores M - N. */
3263 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3265 /* A global counter for generating labels for line number data. */
3266 static unsigned int line_info_label_num
;
3268 /* The current table to which we should emit line number information
3269 for the current function. This will be set up at the beginning of
3270 assembly for the function. */
3271 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3273 /* The two default tables of line number info. */
3274 static GTY(()) dw_line_info_table
*text_section_line_info
;
3275 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3277 /* The set of all non-default tables of line number info. */
3278 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3280 /* A flag to tell pubnames/types export if there is an info section to
3282 static bool info_section_emitted
;
3284 /* A pointer to the base of a table that contains a list of publicly
3285 accessible names. */
3286 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3288 /* A pointer to the base of a table that contains a list of publicly
3289 accessible types. */
3290 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3292 /* A pointer to the base of a table that contains a list of macro
3293 defines/undefines (and file start/end markers). */
3294 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3296 /* True if .debug_macinfo or .debug_macros section is going to be
3298 #define have_macinfo \
3299 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3300 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3301 && !macinfo_table->is_empty ())
3303 /* Vector of dies for which we should generate .debug_ranges info. */
3304 static GTY (()) vec
<dw_ranges
, va_gc
> *ranges_table
;
3306 /* Vector of pairs of labels referenced in ranges_table. */
3307 static GTY (()) vec
<dw_ranges_by_label
, va_gc
> *ranges_by_label
;
3309 /* Whether we have location lists that need outputting */
3310 static GTY(()) bool have_location_lists
;
3312 /* Unique label counter. */
3313 static GTY(()) unsigned int loclabel_num
;
3315 /* Unique label counter for point-of-call tables. */
3316 static GTY(()) unsigned int poc_label_num
;
3318 /* The last file entry emitted by maybe_emit_file(). */
3319 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3321 /* Number of internal labels generated by gen_internal_sym(). */
3322 static GTY(()) int label_num
;
3324 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3326 /* Instances of generic types for which we need to generate debug
3327 info that describe their generic parameters and arguments. That
3328 generation needs to happen once all types are properly laid out so
3329 we do it at the end of compilation. */
3330 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3332 /* Offset from the "steady-state frame pointer" to the frame base,
3333 within the current function. */
3334 static HOST_WIDE_INT frame_pointer_fb_offset
;
3335 static bool frame_pointer_fb_offset_valid
;
3337 static vec
<dw_die_ref
> base_types
;
3339 /* Flags to represent a set of attribute classes for attributes that represent
3340 a scalar value (bounds, pointers, ...). */
3343 dw_scalar_form_constant
= 0x01,
3344 dw_scalar_form_exprloc
= 0x02,
3345 dw_scalar_form_reference
= 0x04
3348 /* Forward declarations for functions defined in this file. */
3350 static int is_pseudo_reg (const_rtx
);
3351 static tree
type_main_variant (tree
);
3352 static int is_tagged_type (const_tree
);
3353 static const char *dwarf_tag_name (unsigned);
3354 static const char *dwarf_attr_name (unsigned);
3355 static const char *dwarf_form_name (unsigned);
3356 static tree
decl_ultimate_origin (const_tree
);
3357 static tree
decl_class_context (tree
);
3358 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3359 static inline enum dw_val_class
AT_class (dw_attr_node
*);
3360 static inline unsigned int AT_index (dw_attr_node
*);
3361 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3362 static inline unsigned AT_flag (dw_attr_node
*);
3363 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3364 static inline HOST_WIDE_INT
AT_int (dw_attr_node
*);
3365 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3366 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_node
*);
3367 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3368 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3369 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3370 unsigned int, unsigned char *);
3371 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3372 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3373 static inline const char *AT_string (dw_attr_node
*);
3374 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3375 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3376 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3377 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3378 static inline int AT_ref_external (dw_attr_node
*);
3379 static inline void set_AT_ref_external (dw_attr_node
*, int);
3380 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3381 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3382 static inline dw_loc_descr_ref
AT_loc (dw_attr_node
*);
3383 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3385 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3386 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3387 static void remove_addr_table_entry (addr_table_entry
*);
3388 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3389 static inline rtx
AT_addr (dw_attr_node
*);
3390 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3391 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3392 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3393 static void add_AT_loclistsptr (dw_die_ref
, enum dwarf_attribute
,
3395 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3396 unsigned HOST_WIDE_INT
);
3397 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3398 unsigned long, bool);
3399 static inline const char *AT_lbl (dw_attr_node
*);
3400 static dw_attr_node
*get_AT (dw_die_ref
, enum dwarf_attribute
);
3401 static const char *get_AT_low_pc (dw_die_ref
);
3402 static const char *get_AT_hi_pc (dw_die_ref
);
3403 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3404 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3405 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3406 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3407 static bool is_cxx (void);
3408 static bool is_cxx (const_tree
);
3409 static bool is_fortran (void);
3410 static bool is_ada (void);
3411 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3412 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3413 static void add_child_die (dw_die_ref
, dw_die_ref
);
3414 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3415 static dw_die_ref
lookup_type_die (tree
);
3416 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3417 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3418 static void equate_type_number_to_die (tree
, dw_die_ref
);
3419 static dw_die_ref
lookup_decl_die (tree
);
3420 static var_loc_list
*lookup_decl_loc (const_tree
);
3421 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3422 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *);
3423 static void print_spaces (FILE *);
3424 static void print_die (dw_die_ref
, FILE *);
3425 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3426 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3427 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3428 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3429 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3430 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3431 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3432 struct md5_ctx
*, int *);
3433 struct checksum_attributes
;
3434 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3435 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3436 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3437 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3438 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3439 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3440 static int same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3441 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3442 static int is_type_die (dw_die_ref
);
3443 static int is_comdat_die (dw_die_ref
);
3444 static inline bool is_template_instantiation (dw_die_ref
);
3445 static int is_declaration_die (dw_die_ref
);
3446 static int should_move_die_to_comdat (dw_die_ref
);
3447 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3448 static dw_die_ref
clone_die (dw_die_ref
);
3449 static dw_die_ref
clone_tree (dw_die_ref
);
3450 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3451 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3452 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3453 static dw_die_ref
generate_skeleton (dw_die_ref
);
3454 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3457 static void break_out_comdat_types (dw_die_ref
);
3458 static void copy_decls_for_unworthy_types (dw_die_ref
);
3460 static void add_sibling_attributes (dw_die_ref
);
3461 static void output_location_lists (dw_die_ref
);
3462 static int constant_size (unsigned HOST_WIDE_INT
);
3463 static unsigned long size_of_die (dw_die_ref
);
3464 static void calc_die_sizes (dw_die_ref
);
3465 static void calc_base_type_die_sizes (void);
3466 static void mark_dies (dw_die_ref
);
3467 static void unmark_dies (dw_die_ref
);
3468 static void unmark_all_dies (dw_die_ref
);
3469 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3470 static unsigned long size_of_aranges (void);
3471 static enum dwarf_form
value_format (dw_attr_node
*);
3472 static void output_value_format (dw_attr_node
*);
3473 static void output_abbrev_section (void);
3474 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3475 static void output_die_symbol (dw_die_ref
);
3476 static void output_die (dw_die_ref
);
3477 static void output_compilation_unit_header (enum dwarf_unit_type
);
3478 static void output_comp_unit (dw_die_ref
, int, const unsigned char *);
3479 static void output_comdat_type_unit (comdat_type_node
*);
3480 static const char *dwarf2_name (tree
, int);
3481 static void add_pubname (tree
, dw_die_ref
);
3482 static void add_enumerator_pubname (const char *, dw_die_ref
);
3483 static void add_pubname_string (const char *, dw_die_ref
);
3484 static void add_pubtype (tree
, dw_die_ref
);
3485 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3486 static void output_aranges (void);
3487 static unsigned int add_ranges (const_tree
, bool = false);
3488 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3490 static void output_ranges (void);
3491 static dw_line_info_table
*new_line_info_table (void);
3492 static void output_line_info (bool);
3493 static void output_file_names (void);
3494 static dw_die_ref
base_type_die (tree
, bool);
3495 static int is_base_type (tree
);
3496 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, tree
, dw_die_ref
);
3497 static int decl_quals (const_tree
);
3498 static dw_die_ref
modified_type_die (tree
, int, bool, dw_die_ref
);
3499 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3500 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3501 static int type_is_enum (const_tree
);
3502 static unsigned int dbx_reg_number (const_rtx
);
3503 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3504 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3505 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3506 enum var_init_status
);
3507 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3508 enum var_init_status
);
3509 static dw_loc_descr_ref
based_loc_descr (rtx
, HOST_WIDE_INT
,
3510 enum var_init_status
);
3511 static int is_based_loc (const_rtx
);
3512 static bool resolve_one_addr (rtx
*);
3513 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3514 enum var_init_status
);
3515 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3516 enum var_init_status
);
3517 struct loc_descr_context
;
3518 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3519 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3520 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3521 struct loc_descr_context
*);
3522 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3523 struct loc_descr_context
*);
3524 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3525 static tree
field_type (const_tree
);
3526 static unsigned int simple_type_align_in_bits (const_tree
);
3527 static unsigned int simple_decl_align_in_bits (const_tree
);
3528 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3530 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3532 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3534 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3535 struct vlr_context
*);
3536 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3537 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3538 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3539 static void insert_float (const_rtx
, unsigned char *);
3540 static rtx
rtl_for_decl_location (tree
);
3541 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3542 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3543 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3544 static void add_name_attribute (dw_die_ref
, const char *);
3545 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3546 static void add_comp_dir_attribute (dw_die_ref
);
3547 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3548 struct loc_descr_context
*);
3549 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3550 struct loc_descr_context
*);
3551 static void add_subscript_info (dw_die_ref
, tree
, bool);
3552 static void add_byte_size_attribute (dw_die_ref
, tree
);
3553 static void add_alignment_attribute (dw_die_ref
, tree
);
3554 static inline void add_bit_offset_attribute (dw_die_ref
, tree
,
3555 struct vlr_context
*);
3556 static void add_bit_size_attribute (dw_die_ref
, tree
);
3557 static void add_prototyped_attribute (dw_die_ref
, tree
);
3558 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3559 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3560 static void add_src_coords_attributes (dw_die_ref
, tree
);
3561 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
, bool = false);
3562 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3563 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3564 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3565 static void push_decl_scope (tree
);
3566 static void pop_decl_scope (void);
3567 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3568 static inline int local_scope_p (dw_die_ref
);
3569 static inline int class_scope_p (dw_die_ref
);
3570 static inline int class_or_namespace_scope_p (dw_die_ref
);
3571 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3572 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3573 static const char *type_tag (const_tree
);
3574 static tree
member_declared_type (const_tree
);
3576 static const char *decl_start_label (tree
);
3578 static void gen_array_type_die (tree
, dw_die_ref
);
3579 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3581 static void gen_entry_point_die (tree
, dw_die_ref
);
3583 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3584 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3585 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3586 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3587 static void gen_formal_types_die (tree
, dw_die_ref
);
3588 static void gen_subprogram_die (tree
, dw_die_ref
);
3589 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3590 static void gen_const_die (tree
, dw_die_ref
);
3591 static void gen_label_die (tree
, dw_die_ref
);
3592 static void gen_lexical_block_die (tree
, dw_die_ref
);
3593 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3594 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3595 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3596 static dw_die_ref
gen_compile_unit_die (const char *);
3597 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3598 static void gen_member_die (tree
, dw_die_ref
);
3599 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3600 enum debug_info_usage
);
3601 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3602 static void gen_typedef_die (tree
, dw_die_ref
);
3603 static void gen_type_die (tree
, dw_die_ref
);
3604 static void gen_block_die (tree
, dw_die_ref
);
3605 static void decls_for_scope (tree
, dw_die_ref
);
3606 static bool is_naming_typedef_decl (const_tree
);
3607 static inline dw_die_ref
get_context_die (tree
);
3608 static void gen_namespace_die (tree
, dw_die_ref
);
3609 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3610 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3611 static dw_die_ref
force_decl_die (tree
);
3612 static dw_die_ref
force_type_die (tree
);
3613 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3614 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3615 static struct dwarf_file_data
* lookup_filename (const char *);
3616 static void retry_incomplete_types (void);
3617 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3618 static void gen_generic_params_dies (tree
);
3619 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3620 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3621 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3622 static int file_info_cmp (const void *, const void *);
3623 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3624 const char *, const char *);
3625 static void output_loc_list (dw_loc_list_ref
);
3626 static char *gen_internal_sym (const char *);
3627 static bool want_pubnames (void);
3629 static void prune_unmark_dies (dw_die_ref
);
3630 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3631 static void prune_unused_types_mark (dw_die_ref
, int);
3632 static void prune_unused_types_walk (dw_die_ref
);
3633 static void prune_unused_types_walk_attribs (dw_die_ref
);
3634 static void prune_unused_types_prune (dw_die_ref
);
3635 static void prune_unused_types (void);
3636 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3637 static inline const char *AT_vms_delta1 (dw_attr_node
*);
3638 static inline const char *AT_vms_delta2 (dw_attr_node
*);
3639 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3640 const char *, const char *);
3641 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3642 static void gen_remaining_tmpl_value_param_die_attribute (void);
3643 static bool generic_type_p (tree
);
3644 static void schedule_generic_params_dies_gen (tree t
);
3645 static void gen_scheduled_generic_parms_dies (void);
3646 static void resolve_variable_values (void);
3648 static const char *comp_dir_string (void);
3650 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
3652 /* enum for tracking thread-local variables whose address is really an offset
3653 relative to the TLS pointer, which will need link-time relocation, but will
3654 not need relocation by the DWARF consumer. */
3662 /* Return the operator to use for an address of a variable. For dtprel_true, we
3663 use DW_OP_const*. For regular variables, which need both link-time
3664 relocation and consumer-level relocation (e.g., to account for shared objects
3665 loaded at a random address), we use DW_OP_addr*. */
3667 static inline enum dwarf_location_atom
3668 dw_addr_op (enum dtprel_bool dtprel
)
3670 if (dtprel
== dtprel_true
)
3671 return (dwarf_split_debug_info
? DW_OP_GNU_const_index
3672 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3674 return dwarf_split_debug_info
? DW_OP_GNU_addr_index
: DW_OP_addr
;
3677 /* Return a pointer to a newly allocated address location description. If
3678 dwarf_split_debug_info is true, then record the address with the appropriate
3680 static inline dw_loc_descr_ref
3681 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3683 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3685 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3686 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3687 ref
->dtprel
= dtprel
;
3688 if (dwarf_split_debug_info
)
3689 ref
->dw_loc_oprnd1
.val_entry
3690 = add_addr_table_entry (addr
,
3691 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3693 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3698 /* Section names used to hold DWARF debugging information. */
3700 #ifndef DEBUG_INFO_SECTION
3701 #define DEBUG_INFO_SECTION ".debug_info"
3703 #ifndef DEBUG_DWO_INFO_SECTION
3704 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3706 #ifndef DEBUG_LTO_DWO_INFO_SECTION
3707 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
3709 #ifndef DEBUG_LTO_INFO_SECTION
3710 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
3712 #ifndef DEBUG_ABBREV_SECTION
3713 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3715 #ifndef DEBUG_DWO_ABBREV_SECTION
3716 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3718 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
3719 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
3721 #ifndef DEBUG_LTO_ABBREV_SECTION
3722 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
3724 #ifndef DEBUG_ARANGES_SECTION
3725 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3727 #ifndef DEBUG_ADDR_SECTION
3728 #define DEBUG_ADDR_SECTION ".debug_addr"
3730 #ifndef DEBUG_MACINFO_SECTION
3731 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
3733 #ifndef DEBUG_DWO_MACINFO_SECTION
3734 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3736 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
3737 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
3739 #ifndef DEBUG_LTO_MACINFO_SECTION
3740 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
3742 #ifndef DEBUG_DWO_MACRO_SECTION
3743 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3745 #ifndef DEBUG_MACRO_SECTION
3746 #define DEBUG_MACRO_SECTION ".debug_macro"
3748 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
3749 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
3751 #ifndef DEBUG_LTO_MACRO_SECTION
3752 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
3754 #ifndef DEBUG_LINE_SECTION
3755 #define DEBUG_LINE_SECTION ".debug_line"
3757 #ifndef DEBUG_DWO_LINE_SECTION
3758 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3760 #ifndef DEBUG_LTO_LINE_SECTION
3761 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
3763 #ifndef DEBUG_LOC_SECTION
3764 #define DEBUG_LOC_SECTION ".debug_loc"
3766 #ifndef DEBUG_DWO_LOC_SECTION
3767 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3769 #ifndef DEBUG_LOCLISTS_SECTION
3770 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
3772 #ifndef DEBUG_DWO_LOCLISTS_SECTION
3773 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
3775 #ifndef DEBUG_PUBNAMES_SECTION
3776 #define DEBUG_PUBNAMES_SECTION \
3777 ((debug_generate_pub_sections == 2) \
3778 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3780 #ifndef DEBUG_PUBTYPES_SECTION
3781 #define DEBUG_PUBTYPES_SECTION \
3782 ((debug_generate_pub_sections == 2) \
3783 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3785 #ifndef DEBUG_STR_OFFSETS_SECTION
3786 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
3788 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
3789 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3791 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
3792 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
3794 #ifndef DEBUG_STR_DWO_SECTION
3795 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3797 #ifndef DEBUG_LTO_STR_DWO_SECTION
3798 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
3800 #ifndef DEBUG_STR_SECTION
3801 #define DEBUG_STR_SECTION ".debug_str"
3803 #ifndef DEBUG_LTO_STR_SECTION
3804 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
3806 #ifndef DEBUG_RANGES_SECTION
3807 #define DEBUG_RANGES_SECTION ".debug_ranges"
3809 #ifndef DEBUG_RNGLISTS_SECTION
3810 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
3812 #ifndef DEBUG_LINE_STR_SECTION
3813 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
3816 /* Standard ELF section names for compiled code and data. */
3817 #ifndef TEXT_SECTION_NAME
3818 #define TEXT_SECTION_NAME ".text"
3821 /* Section flags for .debug_str section. */
3822 #define DEBUG_STR_SECTION_FLAGS \
3823 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3824 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3827 /* Section flags for .debug_str.dwo section. */
3828 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3830 /* Attribute used to refer to the macro section. */
3831 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
3832 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
3834 /* Labels we insert at beginning sections we can reference instead of
3835 the section names themselves. */
3837 #ifndef TEXT_SECTION_LABEL
3838 #define TEXT_SECTION_LABEL "Ltext"
3840 #ifndef COLD_TEXT_SECTION_LABEL
3841 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3843 #ifndef DEBUG_LINE_SECTION_LABEL
3844 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3846 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3847 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3849 #ifndef DEBUG_INFO_SECTION_LABEL
3850 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3852 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3853 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3855 #ifndef DEBUG_ABBREV_SECTION_LABEL
3856 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3858 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3859 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3861 #ifndef DEBUG_ADDR_SECTION_LABEL
3862 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3864 #ifndef DEBUG_LOC_SECTION_LABEL
3865 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3867 #ifndef DEBUG_RANGES_SECTION_LABEL
3868 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3870 #ifndef DEBUG_MACINFO_SECTION_LABEL
3871 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3873 #ifndef DEBUG_MACRO_SECTION_LABEL
3874 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3876 #define SKELETON_COMP_DIE_ABBREV 1
3877 #define SKELETON_TYPE_DIE_ABBREV 2
3879 /* Definitions of defaults for formats and names of various special
3880 (artificial) labels which may be generated within this file (when the -g
3881 options is used and DWARF2_DEBUGGING_INFO is in effect.
3882 If necessary, these may be overridden from within the tm.h file, but
3883 typically, overriding these defaults is unnecessary. */
3885 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3886 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3887 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3888 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3889 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3890 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3891 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3892 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3893 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3894 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3895 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3896 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3897 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3898 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3899 static char ranges_base_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3901 #ifndef TEXT_END_LABEL
3902 #define TEXT_END_LABEL "Letext"
3904 #ifndef COLD_END_LABEL
3905 #define COLD_END_LABEL "Letext_cold"
3907 #ifndef BLOCK_BEGIN_LABEL
3908 #define BLOCK_BEGIN_LABEL "LBB"
3910 #ifndef BLOCK_END_LABEL
3911 #define BLOCK_END_LABEL "LBE"
3913 #ifndef LINE_CODE_LABEL
3914 #define LINE_CODE_LABEL "LM"
3918 /* Return the root of the DIE's built for the current compilation unit. */
3920 comp_unit_die (void)
3922 if (!single_comp_unit_die
)
3923 single_comp_unit_die
= gen_compile_unit_die (NULL
);
3924 return single_comp_unit_die
;
3927 /* We allow a language front-end to designate a function that is to be
3928 called to "demangle" any name before it is put into a DIE. */
3930 static const char *(*demangle_name_func
) (const char *);
3933 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3935 demangle_name_func
= func
;
3938 /* Test if rtl node points to a pseudo register. */
3941 is_pseudo_reg (const_rtx rtl
)
3943 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3944 || (GET_CODE (rtl
) == SUBREG
3945 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3948 /* Return a reference to a type, with its const and volatile qualifiers
3952 type_main_variant (tree type
)
3954 type
= TYPE_MAIN_VARIANT (type
);
3956 /* ??? There really should be only one main variant among any group of
3957 variants of a given type (and all of the MAIN_VARIANT values for all
3958 members of the group should point to that one type) but sometimes the C
3959 front-end messes this up for array types, so we work around that bug
3961 if (TREE_CODE (type
) == ARRAY_TYPE
)
3962 while (type
!= TYPE_MAIN_VARIANT (type
))
3963 type
= TYPE_MAIN_VARIANT (type
);
3968 /* Return nonzero if the given type node represents a tagged type. */
3971 is_tagged_type (const_tree type
)
3973 enum tree_code code
= TREE_CODE (type
);
3975 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
3976 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
3979 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3982 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
3984 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
3987 /* Return die_offset of a DIE reference to a base type. */
3989 static unsigned long int
3990 get_base_type_offset (dw_die_ref ref
)
3992 if (ref
->die_offset
)
3993 return ref
->die_offset
;
3994 if (comp_unit_die ()->die_abbrev
)
3996 calc_base_type_die_sizes ();
3997 gcc_assert (ref
->die_offset
);
3999 return ref
->die_offset
;
4002 /* Return die_offset of a DIE reference other than base type. */
4004 static unsigned long int
4005 get_ref_die_offset (dw_die_ref ref
)
4007 gcc_assert (ref
->die_offset
);
4008 return ref
->die_offset
;
4011 /* Convert a DIE tag into its string name. */
4014 dwarf_tag_name (unsigned int tag
)
4016 const char *name
= get_DW_TAG_name (tag
);
4021 return "DW_TAG_<unknown>";
4024 /* Convert a DWARF attribute code into its string name. */
4027 dwarf_attr_name (unsigned int attr
)
4033 #if VMS_DEBUGGING_INFO
4034 case DW_AT_HP_prologue
:
4035 return "DW_AT_HP_prologue";
4037 case DW_AT_MIPS_loop_unroll_factor
:
4038 return "DW_AT_MIPS_loop_unroll_factor";
4041 #if VMS_DEBUGGING_INFO
4042 case DW_AT_HP_epilogue
:
4043 return "DW_AT_HP_epilogue";
4045 case DW_AT_MIPS_stride
:
4046 return "DW_AT_MIPS_stride";
4050 name
= get_DW_AT_name (attr
);
4055 return "DW_AT_<unknown>";
4058 /* Convert a DWARF value form code into its string name. */
4061 dwarf_form_name (unsigned int form
)
4063 const char *name
= get_DW_FORM_name (form
);
4068 return "DW_FORM_<unknown>";
4071 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4072 instance of an inlined instance of a decl which is local to an inline
4073 function, so we have to trace all of the way back through the origin chain
4074 to find out what sort of node actually served as the original seed for the
4078 decl_ultimate_origin (const_tree decl
)
4080 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4083 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4084 we're trying to output the abstract instance of this function. */
4085 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4088 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4089 most distant ancestor, this should never happen. */
4090 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4092 return DECL_ABSTRACT_ORIGIN (decl
);
4095 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4096 of a virtual function may refer to a base class, so we check the 'this'
4100 decl_class_context (tree decl
)
4102 tree context
= NULL_TREE
;
4104 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4105 context
= DECL_CONTEXT (decl
);
4107 context
= TYPE_MAIN_VARIANT
4108 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4110 if (context
&& !TYPE_P (context
))
4111 context
= NULL_TREE
;
4116 /* Add an attribute/value pair to a DIE. */
4119 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
4121 /* Maybe this should be an assert? */
4127 /* Check we do not add duplicate attrs. Can't use get_AT here
4128 because that recurses to the specification/abstract origin DIE. */
4131 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4132 gcc_assert (a
->dw_attr
!= attr
->dw_attr
);
4135 vec_safe_reserve (die
->die_attr
, 1);
4136 vec_safe_push (die
->die_attr
, *attr
);
4139 static inline enum dw_val_class
4140 AT_class (dw_attr_node
*a
)
4142 return a
->dw_attr_val
.val_class
;
4145 /* Return the index for any attribute that will be referenced with a
4146 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
4147 are stored in dw_attr_val.v.val_str for reference counting
4150 static inline unsigned int
4151 AT_index (dw_attr_node
*a
)
4153 if (AT_class (a
) == dw_val_class_str
)
4154 return a
->dw_attr_val
.v
.val_str
->index
;
4155 else if (a
->dw_attr_val
.val_entry
!= NULL
)
4156 return a
->dw_attr_val
.val_entry
->index
;
4160 /* Add a flag value attribute to a DIE. */
4163 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4167 attr
.dw_attr
= attr_kind
;
4168 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4169 attr
.dw_attr_val
.val_entry
= NULL
;
4170 attr
.dw_attr_val
.v
.val_flag
= flag
;
4171 add_dwarf_attr (die
, &attr
);
4174 static inline unsigned
4175 AT_flag (dw_attr_node
*a
)
4177 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4178 return a
->dw_attr_val
.v
.val_flag
;
4181 /* Add a signed integer attribute value to a DIE. */
4184 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4188 attr
.dw_attr
= attr_kind
;
4189 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4190 attr
.dw_attr_val
.val_entry
= NULL
;
4191 attr
.dw_attr_val
.v
.val_int
= int_val
;
4192 add_dwarf_attr (die
, &attr
);
4195 static inline HOST_WIDE_INT
4196 AT_int (dw_attr_node
*a
)
4198 gcc_assert (a
&& (AT_class (a
) == dw_val_class_const
4199 || AT_class (a
) == dw_val_class_const_implicit
));
4200 return a
->dw_attr_val
.v
.val_int
;
4203 /* Add an unsigned integer attribute value to a DIE. */
4206 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4207 unsigned HOST_WIDE_INT unsigned_val
)
4211 attr
.dw_attr
= attr_kind
;
4212 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4213 attr
.dw_attr_val
.val_entry
= NULL
;
4214 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4215 add_dwarf_attr (die
, &attr
);
4218 static inline unsigned HOST_WIDE_INT
4219 AT_unsigned (dw_attr_node
*a
)
4221 gcc_assert (a
&& (AT_class (a
) == dw_val_class_unsigned_const
4222 || AT_class (a
) == dw_val_class_unsigned_const_implicit
));
4223 return a
->dw_attr_val
.v
.val_unsigned
;
4226 /* Add an unsigned wide integer attribute value to a DIE. */
4229 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4234 attr
.dw_attr
= attr_kind
;
4235 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
4236 attr
.dw_attr_val
.val_entry
= NULL
;
4237 attr
.dw_attr_val
.v
.val_wide
= ggc_alloc
<wide_int
> ();
4238 *attr
.dw_attr_val
.v
.val_wide
= w
;
4239 add_dwarf_attr (die
, &attr
);
4242 /* Add an unsigned double integer attribute value to a DIE. */
4245 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4246 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4250 attr
.dw_attr
= attr_kind
;
4251 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4252 attr
.dw_attr_val
.val_entry
= NULL
;
4253 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4254 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4255 add_dwarf_attr (die
, &attr
);
4258 /* Add a floating point attribute value to a DIE and return it. */
4261 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4262 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4266 attr
.dw_attr
= attr_kind
;
4267 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4268 attr
.dw_attr_val
.val_entry
= NULL
;
4269 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4270 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4271 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4272 add_dwarf_attr (die
, &attr
);
4275 /* Add an 8-byte data attribute value to a DIE. */
4278 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4279 unsigned char data8
[8])
4283 attr
.dw_attr
= attr_kind
;
4284 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4285 attr
.dw_attr_val
.val_entry
= NULL
;
4286 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4287 add_dwarf_attr (die
, &attr
);
4290 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4291 dwarf_split_debug_info, address attributes in dies destined for the
4292 final executable have force_direct set to avoid using indexed
4296 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4302 lbl_id
= xstrdup (lbl_low
);
4303 attr
.dw_attr
= DW_AT_low_pc
;
4304 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4305 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4306 if (dwarf_split_debug_info
&& !force_direct
)
4307 attr
.dw_attr_val
.val_entry
4308 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4310 attr
.dw_attr_val
.val_entry
= NULL
;
4311 add_dwarf_attr (die
, &attr
);
4313 attr
.dw_attr
= DW_AT_high_pc
;
4314 if (dwarf_version
< 4)
4315 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4317 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4318 lbl_id
= xstrdup (lbl_high
);
4319 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4320 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4321 && dwarf_split_debug_info
&& !force_direct
)
4322 attr
.dw_attr_val
.val_entry
4323 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4325 attr
.dw_attr_val
.val_entry
= NULL
;
4326 add_dwarf_attr (die
, &attr
);
4329 /* Hash and equality functions for debug_str_hash. */
4332 indirect_string_hasher::hash (indirect_string_node
*x
)
4334 return htab_hash_string (x
->str
);
4338 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4340 return strcmp (x1
->str
, x2
) == 0;
4343 /* Add STR to the given string hash table. */
4345 static struct indirect_string_node
*
4346 find_AT_string_in_table (const char *str
,
4347 hash_table
<indirect_string_hasher
> *table
)
4349 struct indirect_string_node
*node
;
4351 indirect_string_node
**slot
4352 = table
->find_slot_with_hash (str
, htab_hash_string (str
), INSERT
);
4355 node
= ggc_cleared_alloc
<indirect_string_node
> ();
4356 node
->str
= ggc_strdup (str
);
4366 /* Add STR to the indirect string hash table. */
4368 static struct indirect_string_node
*
4369 find_AT_string (const char *str
)
4371 if (! debug_str_hash
)
4372 debug_str_hash
= hash_table
<indirect_string_hasher
>::create_ggc (10);
4374 return find_AT_string_in_table (str
, debug_str_hash
);
4377 /* Add a string attribute value to a DIE. */
4380 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4383 struct indirect_string_node
*node
;
4385 node
= find_AT_string (str
);
4387 attr
.dw_attr
= attr_kind
;
4388 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4389 attr
.dw_attr_val
.val_entry
= NULL
;
4390 attr
.dw_attr_val
.v
.val_str
= node
;
4391 add_dwarf_attr (die
, &attr
);
4394 static inline const char *
4395 AT_string (dw_attr_node
*a
)
4397 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4398 return a
->dw_attr_val
.v
.val_str
->str
;
4401 /* Call this function directly to bypass AT_string_form's logic to put
4402 the string inline in the die. */
4405 set_indirect_string (struct indirect_string_node
*node
)
4407 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4408 /* Already indirect is a no op. */
4409 if (node
->form
== DW_FORM_strp
4410 || node
->form
== DW_FORM_line_strp
4411 || node
->form
== DW_FORM_GNU_str_index
)
4413 gcc_assert (node
->label
);
4416 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4417 ++dw2_string_counter
;
4418 node
->label
= xstrdup (label
);
4420 if (!dwarf_split_debug_info
)
4422 node
->form
= DW_FORM_strp
;
4423 node
->index
= NOT_INDEXED
;
4427 node
->form
= DW_FORM_GNU_str_index
;
4428 node
->index
= NO_INDEX_ASSIGNED
;
4432 /* A helper function for dwarf2out_finish, called to reset indirect
4433 string decisions done for early LTO dwarf output before fat object
4437 reset_indirect_string (indirect_string_node
**h
, void *)
4439 struct indirect_string_node
*node
= *h
;
4440 if (node
->form
== DW_FORM_strp
|| node
->form
== DW_FORM_GNU_str_index
)
4444 node
->form
= (dwarf_form
) 0;
4450 /* Find out whether a string should be output inline in DIE
4451 or out-of-line in .debug_str section. */
4453 static enum dwarf_form
4454 find_string_form (struct indirect_string_node
*node
)
4461 len
= strlen (node
->str
) + 1;
4463 /* If the string is shorter or equal to the size of the reference, it is
4464 always better to put it inline. */
4465 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4466 return node
->form
= DW_FORM_string
;
4468 /* If we cannot expect the linker to merge strings in .debug_str
4469 section, only put it into .debug_str if it is worth even in this
4471 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4472 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4473 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4474 return node
->form
= DW_FORM_string
;
4476 set_indirect_string (node
);
4481 /* Find out whether the string referenced from the attribute should be
4482 output inline in DIE or out-of-line in .debug_str section. */
4484 static enum dwarf_form
4485 AT_string_form (dw_attr_node
*a
)
4487 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4488 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4491 /* Add a DIE reference attribute value to a DIE. */
4494 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4497 gcc_checking_assert (targ_die
!= NULL
);
4499 /* With LTO we can end up trying to reference something we didn't create
4500 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4501 if (targ_die
== NULL
)
4504 attr
.dw_attr
= attr_kind
;
4505 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4506 attr
.dw_attr_val
.val_entry
= NULL
;
4507 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4508 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4509 add_dwarf_attr (die
, &attr
);
4512 /* Change DIE reference REF to point to NEW_DIE instead. */
4515 change_AT_die_ref (dw_attr_node
*ref
, dw_die_ref new_die
)
4517 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4518 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4519 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4522 /* Add an AT_specification attribute to a DIE, and also make the back
4523 pointer from the specification to the definition. */
4526 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4528 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4529 gcc_assert (!targ_die
->die_definition
);
4530 targ_die
->die_definition
= die
;
4533 static inline dw_die_ref
4534 AT_ref (dw_attr_node
*a
)
4536 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4537 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4541 AT_ref_external (dw_attr_node
*a
)
4543 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4544 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4550 set_AT_ref_external (dw_attr_node
*a
, int i
)
4552 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4553 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4556 /* Add an FDE reference attribute value to a DIE. */
4559 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4563 attr
.dw_attr
= attr_kind
;
4564 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4565 attr
.dw_attr_val
.val_entry
= NULL
;
4566 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4567 add_dwarf_attr (die
, &attr
);
4570 /* Add a location description attribute value to a DIE. */
4573 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4577 attr
.dw_attr
= attr_kind
;
4578 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4579 attr
.dw_attr_val
.val_entry
= NULL
;
4580 attr
.dw_attr_val
.v
.val_loc
= loc
;
4581 add_dwarf_attr (die
, &attr
);
4584 static inline dw_loc_descr_ref
4585 AT_loc (dw_attr_node
*a
)
4587 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4588 return a
->dw_attr_val
.v
.val_loc
;
4592 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4596 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4599 attr
.dw_attr
= attr_kind
;
4600 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4601 attr
.dw_attr_val
.val_entry
= NULL
;
4602 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4603 add_dwarf_attr (die
, &attr
);
4604 have_location_lists
= true;
4607 static inline dw_loc_list_ref
4608 AT_loc_list (dw_attr_node
*a
)
4610 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4611 return a
->dw_attr_val
.v
.val_loc_list
;
4614 static inline dw_loc_list_ref
*
4615 AT_loc_list_ptr (dw_attr_node
*a
)
4617 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4618 return &a
->dw_attr_val
.v
.val_loc_list
;
4621 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
4623 static hashval_t
hash (addr_table_entry
*);
4624 static bool equal (addr_table_entry
*, addr_table_entry
*);
4627 /* Table of entries into the .debug_addr section. */
4629 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
4631 /* Hash an address_table_entry. */
4634 addr_hasher::hash (addr_table_entry
*a
)
4636 inchash::hash hstate
;
4642 case ate_kind_rtx_dtprel
:
4645 case ate_kind_label
:
4646 return htab_hash_string (a
->addr
.label
);
4650 inchash::add_rtx (a
->addr
.rtl
, hstate
);
4651 return hstate
.end ();
4654 /* Determine equality for two address_table_entries. */
4657 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
4659 if (a1
->kind
!= a2
->kind
)
4664 case ate_kind_rtx_dtprel
:
4665 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4666 case ate_kind_label
:
4667 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
4673 /* Initialize an addr_table_entry. */
4676 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
4682 case ate_kind_rtx_dtprel
:
4683 e
->addr
.rtl
= (rtx
) addr
;
4685 case ate_kind_label
:
4686 e
->addr
.label
= (char *) addr
;
4690 e
->index
= NO_INDEX_ASSIGNED
;
4693 /* Add attr to the address table entry to the table. Defer setting an
4694 index until output time. */
4696 static addr_table_entry
*
4697 add_addr_table_entry (void *addr
, enum ate_kind kind
)
4699 addr_table_entry
*node
;
4700 addr_table_entry finder
;
4702 gcc_assert (dwarf_split_debug_info
);
4703 if (! addr_index_table
)
4704 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
4705 init_addr_table_entry (&finder
, kind
, addr
);
4706 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
4708 if (*slot
== HTAB_EMPTY_ENTRY
)
4710 node
= ggc_cleared_alloc
<addr_table_entry
> ();
4711 init_addr_table_entry (node
, kind
, addr
);
4721 /* Remove an entry from the addr table by decrementing its refcount.
4722 Strictly, decrementing the refcount would be enough, but the
4723 assertion that the entry is actually in the table has found
4727 remove_addr_table_entry (addr_table_entry
*entry
)
4729 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
4730 /* After an index is assigned, the table is frozen. */
4731 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
4735 /* Given a location list, remove all addresses it refers to from the
4739 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
4741 for (; descr
; descr
= descr
->dw_loc_next
)
4742 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
4744 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
4745 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
4749 /* A helper function for dwarf2out_finish called through
4750 htab_traverse. Assign an addr_table_entry its index. All entries
4751 must be collected into the table when this function is called,
4752 because the indexing code relies on htab_traverse to traverse nodes
4753 in the same order for each run. */
4756 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
4758 addr_table_entry
*node
= *h
;
4760 /* Don't index unreferenced nodes. */
4761 if (node
->refcount
== 0)
4764 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
4765 node
->index
= *index
;
4771 /* Add an address constant attribute value to a DIE. When using
4772 dwarf_split_debug_info, address attributes in dies destined for the
4773 final executable should be direct references--setting the parameter
4774 force_direct ensures this behavior. */
4777 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
4782 attr
.dw_attr
= attr_kind
;
4783 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
4784 attr
.dw_attr_val
.v
.val_addr
= addr
;
4785 if (dwarf_split_debug_info
&& !force_direct
)
4786 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
4788 attr
.dw_attr_val
.val_entry
= NULL
;
4789 add_dwarf_attr (die
, &attr
);
4792 /* Get the RTX from to an address DIE attribute. */
4795 AT_addr (dw_attr_node
*a
)
4797 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
4798 return a
->dw_attr_val
.v
.val_addr
;
4801 /* Add a file attribute value to a DIE. */
4804 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4805 struct dwarf_file_data
*fd
)
4809 attr
.dw_attr
= attr_kind
;
4810 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
4811 attr
.dw_attr_val
.val_entry
= NULL
;
4812 attr
.dw_attr_val
.v
.val_file
= fd
;
4813 add_dwarf_attr (die
, &attr
);
4816 /* Get the dwarf_file_data from a file DIE attribute. */
4818 static inline struct dwarf_file_data
*
4819 AT_file (dw_attr_node
*a
)
4821 gcc_assert (a
&& (AT_class (a
) == dw_val_class_file
4822 || AT_class (a
) == dw_val_class_file_implicit
));
4823 return a
->dw_attr_val
.v
.val_file
;
4826 /* Add a vms delta attribute value to a DIE. */
4829 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4830 const char *lbl1
, const char *lbl2
)
4834 attr
.dw_attr
= attr_kind
;
4835 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
4836 attr
.dw_attr_val
.val_entry
= NULL
;
4837 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
4838 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
4839 add_dwarf_attr (die
, &attr
);
4842 /* Add a label identifier attribute value to a DIE. */
4845 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4850 attr
.dw_attr
= attr_kind
;
4851 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4852 attr
.dw_attr_val
.val_entry
= NULL
;
4853 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4854 if (dwarf_split_debug_info
)
4855 attr
.dw_attr_val
.val_entry
4856 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
4858 add_dwarf_attr (die
, &attr
);
4861 /* Add a section offset attribute value to a DIE, an offset into the
4862 debug_line section. */
4865 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4870 attr
.dw_attr
= attr_kind
;
4871 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
4872 attr
.dw_attr_val
.val_entry
= NULL
;
4873 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4874 add_dwarf_attr (die
, &attr
);
4877 /* Add a section offset attribute value to a DIE, an offset into the
4878 debug_loclists section. */
4881 add_AT_loclistsptr (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_loclistsptr
;
4888 attr
.dw_attr_val
.val_entry
= NULL
;
4889 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4890 add_dwarf_attr (die
, &attr
);
4893 /* Add a section offset attribute value to a DIE, an offset into the
4894 debug_macinfo section. */
4897 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4902 attr
.dw_attr
= attr_kind
;
4903 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
4904 attr
.dw_attr_val
.val_entry
= NULL
;
4905 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4906 add_dwarf_attr (die
, &attr
);
4909 /* Add an offset attribute value to a DIE. */
4912 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4913 unsigned HOST_WIDE_INT offset
)
4917 attr
.dw_attr
= attr_kind
;
4918 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
4919 attr
.dw_attr_val
.val_entry
= NULL
;
4920 attr
.dw_attr_val
.v
.val_offset
= offset
;
4921 add_dwarf_attr (die
, &attr
);
4924 /* Add a range_list attribute value to a DIE. When using
4925 dwarf_split_debug_info, address attributes in dies destined for the
4926 final executable should be direct references--setting the parameter
4927 force_direct ensures this behavior. */
4929 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4930 #define RELOCATED_OFFSET (NULL)
4933 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4934 long unsigned int offset
, bool force_direct
)
4938 attr
.dw_attr
= attr_kind
;
4939 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
4940 /* For the range_list attribute, use val_entry to store whether the
4941 offset should follow split-debug-info or normal semantics. This
4942 value is read in output_range_list_offset. */
4943 if (dwarf_split_debug_info
&& !force_direct
)
4944 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
4946 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
4947 attr
.dw_attr_val
.v
.val_offset
= offset
;
4948 add_dwarf_attr (die
, &attr
);
4951 /* Return the start label of a delta attribute. */
4953 static inline const char *
4954 AT_vms_delta1 (dw_attr_node
*a
)
4956 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4957 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
4960 /* Return the end label of a delta attribute. */
4962 static inline const char *
4963 AT_vms_delta2 (dw_attr_node
*a
)
4965 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4966 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
4969 static inline const char *
4970 AT_lbl (dw_attr_node
*a
)
4972 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
4973 || AT_class (a
) == dw_val_class_lineptr
4974 || AT_class (a
) == dw_val_class_macptr
4975 || AT_class (a
) == dw_val_class_loclistsptr
4976 || AT_class (a
) == dw_val_class_high_pc
));
4977 return a
->dw_attr_val
.v
.val_lbl_id
;
4980 /* Get the attribute of type attr_kind. */
4982 static dw_attr_node
*
4983 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4987 dw_die_ref spec
= NULL
;
4992 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4993 if (a
->dw_attr
== attr_kind
)
4995 else if (a
->dw_attr
== DW_AT_specification
4996 || a
->dw_attr
== DW_AT_abstract_origin
)
5000 return get_AT (spec
, attr_kind
);
5005 /* Returns the parent of the declaration of DIE. */
5008 get_die_parent (dw_die_ref die
)
5015 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
5016 || (t
= get_AT_ref (die
, DW_AT_specification
)))
5019 return die
->die_parent
;
5022 /* Return the "low pc" attribute value, typically associated with a subprogram
5023 DIE. Return null if the "low pc" attribute is either not present, or if it
5024 cannot be represented as an assembler label identifier. */
5026 static inline const char *
5027 get_AT_low_pc (dw_die_ref die
)
5029 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
5031 return a
? AT_lbl (a
) : NULL
;
5034 /* Return the "high pc" attribute value, typically associated with a subprogram
5035 DIE. Return null if the "high pc" attribute is either not present, or if it
5036 cannot be represented as an assembler label identifier. */
5038 static inline const char *
5039 get_AT_hi_pc (dw_die_ref die
)
5041 dw_attr_node
*a
= get_AT (die
, DW_AT_high_pc
);
5043 return a
? AT_lbl (a
) : NULL
;
5046 /* Return the value of the string attribute designated by ATTR_KIND, or
5047 NULL if it is not present. */
5049 static inline const char *
5050 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5052 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5054 return a
? AT_string (a
) : NULL
;
5057 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5058 if it is not present. */
5061 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5063 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5065 return a
? AT_flag (a
) : 0;
5068 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5069 if it is not present. */
5071 static inline unsigned
5072 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5074 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5076 return a
? AT_unsigned (a
) : 0;
5079 static inline dw_die_ref
5080 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5082 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5084 return a
? AT_ref (a
) : NULL
;
5087 static inline struct dwarf_file_data
*
5088 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5090 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5092 return a
? AT_file (a
) : NULL
;
5095 /* Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL. */
5098 get_ultimate_context (const_tree decl
)
5100 while (decl
&& TREE_CODE (decl
) != TRANSLATION_UNIT_DECL
)
5102 if (TREE_CODE (decl
) == BLOCK
)
5103 decl
= BLOCK_SUPERCONTEXT (decl
);
5105 decl
= get_containing_scope (decl
);
5110 /* Return TRUE if the language is C++. */
5115 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5117 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
5118 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
5121 /* Return TRUE if DECL was created by the C++ frontend. */
5124 is_cxx (const_tree decl
)
5128 const_tree context
= get_ultimate_context (decl
);
5129 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5130 return strncmp (TRANSLATION_UNIT_LANGUAGE (context
), "GNU C++", 7) == 0;
5135 /* Return TRUE if the language is Fortran. */
5140 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5142 return (lang
== DW_LANG_Fortran77
5143 || lang
== DW_LANG_Fortran90
5144 || lang
== DW_LANG_Fortran95
5145 || lang
== DW_LANG_Fortran03
5146 || lang
== DW_LANG_Fortran08
);
5150 is_fortran (const_tree decl
)
5154 const_tree context
= get_ultimate_context (decl
);
5155 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5156 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context
),
5157 "GNU Fortran", 11) == 0
5158 || strcmp (TRANSLATION_UNIT_LANGUAGE (context
),
5161 return is_fortran ();
5164 /* Return TRUE if the language is Ada. */
5169 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5171 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5174 /* Remove the specified attribute if present. Return TRUE if removal
5178 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5186 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5187 if (a
->dw_attr
== attr_kind
)
5189 if (AT_class (a
) == dw_val_class_str
)
5190 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5191 a
->dw_attr_val
.v
.val_str
->refcount
--;
5193 /* vec::ordered_remove should help reduce the number of abbrevs
5195 die
->die_attr
->ordered_remove (ix
);
5201 /* Remove CHILD from its parent. PREV must have the property that
5202 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5205 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
5207 gcc_assert (child
->die_parent
== prev
->die_parent
);
5208 gcc_assert (prev
->die_sib
== child
);
5211 gcc_assert (child
->die_parent
->die_child
== child
);
5215 prev
->die_sib
= child
->die_sib
;
5216 if (child
->die_parent
->die_child
== child
)
5217 child
->die_parent
->die_child
= prev
;
5218 child
->die_sib
= NULL
;
5221 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5222 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5225 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
5227 dw_die_ref parent
= old_child
->die_parent
;
5229 gcc_assert (parent
== prev
->die_parent
);
5230 gcc_assert (prev
->die_sib
== old_child
);
5232 new_child
->die_parent
= parent
;
5233 if (prev
== old_child
)
5235 gcc_assert (parent
->die_child
== old_child
);
5236 new_child
->die_sib
= new_child
;
5240 prev
->die_sib
= new_child
;
5241 new_child
->die_sib
= old_child
->die_sib
;
5243 if (old_child
->die_parent
->die_child
== old_child
)
5244 old_child
->die_parent
->die_child
= new_child
;
5245 old_child
->die_sib
= NULL
;
5248 /* Move all children from OLD_PARENT to NEW_PARENT. */
5251 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
5254 new_parent
->die_child
= old_parent
->die_child
;
5255 old_parent
->die_child
= NULL
;
5256 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
5259 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5263 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5269 dw_die_ref prev
= c
;
5271 while (c
->die_tag
== tag
)
5273 remove_child_with_prev (c
, prev
);
5274 c
->die_parent
= NULL
;
5275 /* Might have removed every child. */
5276 if (die
->die_child
== NULL
)
5280 } while (c
!= die
->die_child
);
5283 /* Add a CHILD_DIE as the last child of DIE. */
5286 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5288 /* FIXME this should probably be an assert. */
5289 if (! die
|| ! child_die
)
5291 gcc_assert (die
!= child_die
);
5293 child_die
->die_parent
= die
;
5296 child_die
->die_sib
= die
->die_child
->die_sib
;
5297 die
->die_child
->die_sib
= child_die
;
5300 child_die
->die_sib
= child_die
;
5301 die
->die_child
= child_die
;
5304 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5307 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
5308 dw_die_ref after_die
)
5314 && die
!= child_die
);
5316 child_die
->die_parent
= die
;
5317 child_die
->die_sib
= after_die
->die_sib
;
5318 after_die
->die_sib
= child_die
;
5319 if (die
->die_child
== after_die
)
5320 die
->die_child
= child_die
;
5323 /* Unassociate CHILD from its parent, and make its parent be
5327 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
5329 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5330 if (p
->die_sib
== child
)
5332 remove_child_with_prev (child
, p
);
5335 add_child_die (new_parent
, child
);
5338 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5339 is the specification, to the end of PARENT's list of children.
5340 This is done by removing and re-adding it. */
5343 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5345 /* We want the declaration DIE from inside the class, not the
5346 specification DIE at toplevel. */
5347 if (child
->die_parent
!= parent
)
5349 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5355 gcc_assert (child
->die_parent
== parent
5356 || (child
->die_parent
5357 == get_AT_ref (parent
, DW_AT_specification
)));
5359 reparent_child (child
, parent
);
5362 /* Create and return a new die with a parent of PARENT_DIE. If
5363 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5364 associated tree T must be supplied to determine parenthood
5367 static inline dw_die_ref
5368 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5370 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5372 die
->die_tag
= tag_value
;
5374 if (parent_die
!= NULL
)
5375 add_child_die (parent_die
, die
);
5378 limbo_die_node
*limbo_node
;
5380 /* No DIEs created after early dwarf should end up in limbo,
5381 because the limbo list should not persist past LTO
5383 if (tag_value
!= DW_TAG_compile_unit
5384 /* These are allowed because they're generated while
5385 breaking out COMDAT units late. */
5386 && tag_value
!= DW_TAG_type_unit
5387 && tag_value
!= DW_TAG_skeleton_unit
5389 /* Allow nested functions to live in limbo because they will
5390 only temporarily live there, as decls_for_scope will fix
5392 && (TREE_CODE (t
) != FUNCTION_DECL
5393 || !decl_function_context (t
))
5394 /* Same as nested functions above but for types. Types that
5395 are local to a function will be fixed in
5397 && (!RECORD_OR_UNION_TYPE_P (t
)
5398 || !TYPE_CONTEXT (t
)
5399 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5400 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5401 especially in the ltrans stage, but once we implement LTO
5402 dwarf streaming, we should remove this exception. */
5405 fprintf (stderr
, "symbol ended up in limbo too late:");
5406 debug_generic_stmt (t
);
5410 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5411 limbo_node
->die
= die
;
5412 limbo_node
->created_for
= t
;
5413 limbo_node
->next
= limbo_die_list
;
5414 limbo_die_list
= limbo_node
;
5420 /* Return the DIE associated with the given type specifier. */
5422 static inline dw_die_ref
5423 lookup_type_die (tree type
)
5425 dw_die_ref die
= TYPE_SYMTAB_DIE (type
);
5426 if (die
&& die
->removed
)
5428 TYPE_SYMTAB_DIE (type
) = NULL
;
5434 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5435 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5436 anonymous type instead the one of the naming typedef. */
5438 static inline dw_die_ref
5439 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5442 && TREE_CODE (type
) == RECORD_TYPE
5444 && type_die
->die_tag
== DW_TAG_typedef
5445 && is_naming_typedef_decl (TYPE_NAME (type
)))
5446 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5450 /* Like lookup_type_die, but if type is an anonymous type named by a
5451 typedef[1], return the DIE of the anonymous type instead the one of
5452 the naming typedef. This is because in gen_typedef_die, we did
5453 equate the anonymous struct named by the typedef with the DIE of
5454 the naming typedef. So by default, lookup_type_die on an anonymous
5455 struct yields the DIE of the naming typedef.
5457 [1]: Read the comment of is_naming_typedef_decl to learn about what
5458 a naming typedef is. */
5460 static inline dw_die_ref
5461 lookup_type_die_strip_naming_typedef (tree type
)
5463 dw_die_ref die
= lookup_type_die (type
);
5464 return strip_naming_typedef (type
, die
);
5467 /* Equate a DIE to a given type specifier. */
5470 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5472 TYPE_SYMTAB_DIE (type
) = type_die
;
5475 /* Returns a hash value for X (which really is a die_struct). */
5478 decl_die_hasher::hash (die_node
*x
)
5480 return (hashval_t
) x
->decl_id
;
5483 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5486 decl_die_hasher::equal (die_node
*x
, tree y
)
5488 return (x
->decl_id
== DECL_UID (y
));
5491 /* Return the DIE associated with a given declaration. */
5493 static inline dw_die_ref
5494 lookup_decl_die (tree decl
)
5496 dw_die_ref
*die
= decl_die_table
->find_slot_with_hash (decl
, DECL_UID (decl
),
5500 if ((*die
)->removed
)
5502 decl_die_table
->clear_slot (die
);
5509 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
5510 style reference. Return true if we found one refering to a DIE for
5511 DECL, otherwise return false. */
5514 dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
5515 unsigned HOST_WIDE_INT
*off
)
5519 if (flag_wpa
&& !decl_die_table
)
5522 if (TREE_CODE (decl
) == BLOCK
)
5523 die
= BLOCK_DIE (decl
);
5525 die
= lookup_decl_die (decl
);
5529 /* During WPA stage we currently use DIEs to store the
5530 decl <-> label + offset map. That's quite inefficient but it
5534 dw_die_ref ref
= get_AT_ref (die
, DW_AT_abstract_origin
);
5537 gcc_assert (die
== comp_unit_die ());
5540 *off
= ref
->die_offset
;
5541 *sym
= ref
->die_id
.die_symbol
;
5545 /* Similar to get_ref_die_offset_label, but using the "correct"
5547 *off
= die
->die_offset
;
5548 while (die
->die_parent
)
5549 die
= die
->die_parent
;
5550 /* For the containing CU DIE we compute a die_symbol in
5551 compute_comp_unit_symbol. */
5552 gcc_assert (die
->die_tag
== DW_TAG_compile_unit
5553 && die
->die_id
.die_symbol
!= NULL
);
5554 *sym
= die
->die_id
.die_symbol
;
5558 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
5561 add_AT_external_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5562 const char *symbol
, HOST_WIDE_INT offset
)
5564 /* Create a fake DIE that contains the reference. Don't use
5565 new_die because we don't want to end up in the limbo list. */
5566 dw_die_ref ref
= ggc_cleared_alloc
<die_node
> ();
5567 ref
->die_tag
= die
->die_tag
;
5568 ref
->die_id
.die_symbol
= IDENTIFIER_POINTER (get_identifier (symbol
));
5569 ref
->die_offset
= offset
;
5570 ref
->with_offset
= 1;
5571 add_AT_die_ref (die
, attr_kind
, ref
);
5574 /* Create a DIE for DECL if required and add a reference to a DIE
5575 at SYMBOL + OFFSET which contains attributes dumped early. */
5578 dwarf2out_register_external_die (tree decl
, const char *sym
,
5579 unsigned HOST_WIDE_INT off
)
5581 if (debug_info_level
== DINFO_LEVEL_NONE
)
5584 if (flag_wpa
&& !decl_die_table
)
5585 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (1000);
5588 = TREE_CODE (decl
) == BLOCK
? BLOCK_DIE (decl
) : lookup_decl_die (decl
);
5592 dw_die_ref parent
= NULL
;
5593 /* Need to lookup a DIE for the decls context - the containing
5594 function or translation unit. */
5595 if (TREE_CODE (decl
) == BLOCK
)
5597 ctx
= BLOCK_SUPERCONTEXT (decl
);
5598 /* ??? We do not output DIEs for all scopes thus skip as
5599 many DIEs as needed. */
5600 while (TREE_CODE (ctx
) == BLOCK
5601 && !BLOCK_DIE (ctx
))
5602 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5605 ctx
= DECL_CONTEXT (decl
);
5606 while (ctx
&& TYPE_P (ctx
))
5607 ctx
= TYPE_CONTEXT (ctx
);
5610 if (TREE_CODE (ctx
) == BLOCK
)
5611 parent
= BLOCK_DIE (ctx
);
5612 else if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
5613 /* Keep the 1:1 association during WPA. */
5615 /* Otherwise all late annotations go to the main CU which
5616 imports the original CUs. */
5617 parent
= comp_unit_die ();
5618 else if (TREE_CODE (ctx
) == FUNCTION_DECL
5619 && TREE_CODE (decl
) != PARM_DECL
5620 && TREE_CODE (decl
) != BLOCK
)
5621 /* Leave function local entities parent determination to when
5622 we process scope vars. */
5625 parent
= lookup_decl_die (ctx
);
5628 /* In some cases the FEs fail to set DECL_CONTEXT properly.
5629 Handle this case gracefully by globalizing stuff. */
5630 parent
= comp_unit_die ();
5631 /* Create a DIE "stub". */
5632 switch (TREE_CODE (decl
))
5634 case TRANSLATION_UNIT_DECL
:
5637 die
= comp_unit_die ();
5638 dw_die_ref import
= new_die (DW_TAG_imported_unit
, die
, NULL_TREE
);
5639 add_AT_external_die_ref (import
, DW_AT_import
, sym
, off
);
5640 /* We re-target all CU decls to the LTRANS CU DIE, so no need
5641 to create a DIE for the original CUs. */
5644 /* Keep the 1:1 association during WPA. */
5645 die
= new_die (DW_TAG_compile_unit
, NULL
, decl
);
5647 case NAMESPACE_DECL
:
5648 if (is_fortran (decl
))
5649 die
= new_die (DW_TAG_module
, parent
, decl
);
5651 die
= new_die (DW_TAG_namespace
, parent
, decl
);
5654 die
= new_die (DW_TAG_subprogram
, parent
, decl
);
5657 die
= new_die (DW_TAG_variable
, parent
, decl
);
5660 die
= new_die (DW_TAG_variable
, parent
, decl
);
5663 die
= new_die (DW_TAG_formal_parameter
, parent
, decl
);
5666 die
= new_die (DW_TAG_constant
, parent
, decl
);
5669 die
= new_die (DW_TAG_label
, parent
, decl
);
5672 die
= new_die (DW_TAG_lexical_block
, parent
, decl
);
5677 if (TREE_CODE (decl
) == BLOCK
)
5678 BLOCK_DIE (decl
) = die
;
5680 equate_decl_number_to_die (decl
, die
);
5682 /* Add a reference to the DIE providing early debug at $sym + off. */
5683 add_AT_external_die_ref (die
, DW_AT_abstract_origin
, sym
, off
);
5686 /* Returns a hash value for X (which really is a var_loc_list). */
5689 decl_loc_hasher::hash (var_loc_list
*x
)
5691 return (hashval_t
) x
->decl_id
;
5694 /* Return nonzero if decl_id of var_loc_list X is the same as
5698 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
5700 return (x
->decl_id
== DECL_UID (y
));
5703 /* Return the var_loc list associated with a given declaration. */
5705 static inline var_loc_list
*
5706 lookup_decl_loc (const_tree decl
)
5708 if (!decl_loc_table
)
5710 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
5713 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
5716 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
5718 return (hashval_t
) x
->decl_id
;
5721 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
5725 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
5727 return (x
->decl_id
== DECL_UID (y
));
5730 /* Equate a DIE to a particular declaration. */
5733 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
5735 unsigned int decl_id
= DECL_UID (decl
);
5737 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
5738 decl_die
->decl_id
= decl_id
;
5741 /* Return how many bits covers PIECE EXPR_LIST. */
5743 static HOST_WIDE_INT
5744 decl_piece_bitsize (rtx piece
)
5746 int ret
= (int) GET_MODE (piece
);
5749 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
5750 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
5751 return INTVAL (XEXP (XEXP (piece
, 0), 0));
5754 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5757 decl_piece_varloc_ptr (rtx piece
)
5759 if ((int) GET_MODE (piece
))
5760 return &XEXP (piece
, 0);
5762 return &XEXP (XEXP (piece
, 0), 1);
5765 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5766 Next is the chain of following piece nodes. */
5768 static rtx_expr_list
*
5769 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
5771 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
5772 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
5774 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
5779 /* Return rtx that should be stored into loc field for
5780 LOC_NOTE and BITPOS/BITSIZE. */
5783 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
5784 HOST_WIDE_INT bitsize
)
5788 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
5790 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
5795 /* This function either modifies location piece list *DEST in
5796 place (if SRC and INNER is NULL), or copies location piece list
5797 *SRC to *DEST while modifying it. Location BITPOS is modified
5798 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5799 not copied and if needed some padding around it is added.
5800 When modifying in place, DEST should point to EXPR_LIST where
5801 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5802 to the start of the whole list and INNER points to the EXPR_LIST
5803 where earlier pieces cover PIECE_BITPOS bits. */
5806 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
5807 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
5808 HOST_WIDE_INT bitsize
, rtx loc_note
)
5811 bool copy
= inner
!= NULL
;
5815 /* First copy all nodes preceding the current bitpos. */
5816 while (src
!= inner
)
5818 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5819 decl_piece_bitsize (*src
), NULL_RTX
);
5820 dest
= &XEXP (*dest
, 1);
5821 src
= &XEXP (*src
, 1);
5824 /* Add padding if needed. */
5825 if (bitpos
!= piece_bitpos
)
5827 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
5828 copy
? NULL_RTX
: *dest
);
5829 dest
= &XEXP (*dest
, 1);
5831 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
5834 /* A piece with correct bitpos and bitsize already exist,
5835 just update the location for it and return. */
5836 *decl_piece_varloc_ptr (*dest
) = loc_note
;
5839 /* Add the piece that changed. */
5840 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
5841 dest
= &XEXP (*dest
, 1);
5842 /* Skip over pieces that overlap it. */
5843 diff
= bitpos
- piece_bitpos
+ bitsize
;
5846 while (diff
> 0 && *src
)
5849 diff
-= decl_piece_bitsize (piece
);
5851 src
= &XEXP (piece
, 1);
5854 *src
= XEXP (piece
, 1);
5855 free_EXPR_LIST_node (piece
);
5858 /* Add padding if needed. */
5859 if (diff
< 0 && *src
)
5863 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
5864 dest
= &XEXP (*dest
, 1);
5868 /* Finally copy all nodes following it. */
5871 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5872 decl_piece_bitsize (*src
), NULL_RTX
);
5873 dest
= &XEXP (*dest
, 1);
5874 src
= &XEXP (*src
, 1);
5878 /* Add a variable location node to the linked list for DECL. */
5880 static struct var_loc_node
*
5881 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
)
5883 unsigned int decl_id
;
5885 struct var_loc_node
*loc
= NULL
;
5886 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
5888 if (VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
5890 tree realdecl
= DECL_DEBUG_EXPR (decl
);
5891 if (handled_component_p (realdecl
)
5892 || (TREE_CODE (realdecl
) == MEM_REF
5893 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5895 HOST_WIDE_INT maxsize
;
5898 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
, &maxsize
,
5900 if (!DECL_P (innerdecl
)
5901 || DECL_IGNORED_P (innerdecl
)
5902 || TREE_STATIC (innerdecl
)
5904 || bitpos
+ bitsize
> 256
5905 || bitsize
!= maxsize
)
5911 decl_id
= DECL_UID (decl
);
5913 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
5916 temp
= ggc_cleared_alloc
<var_loc_list
> ();
5917 temp
->decl_id
= decl_id
;
5923 /* For PARM_DECLs try to keep around the original incoming value,
5924 even if that means we'll emit a zero-range .debug_loc entry. */
5926 && temp
->first
== temp
->last
5927 && TREE_CODE (decl
) == PARM_DECL
5928 && NOTE_P (temp
->first
->loc
)
5929 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
5930 && DECL_INCOMING_RTL (decl
)
5931 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
5932 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
5933 == GET_CODE (DECL_INCOMING_RTL (decl
))
5934 && prev_real_insn (as_a
<rtx_insn
*> (temp
->first
->loc
)) == NULL_RTX
5936 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
5937 NOTE_VAR_LOCATION_LOC (loc_note
))
5938 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
5939 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
5941 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5942 temp
->first
->next
= loc
;
5944 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5946 else if (temp
->last
)
5948 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
5949 rtx
*piece_loc
= NULL
, last_loc_note
;
5950 HOST_WIDE_INT piece_bitpos
= 0;
5954 gcc_assert (last
->next
== NULL
);
5956 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
5958 piece_loc
= &last
->loc
;
5961 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
5962 if (piece_bitpos
+ cur_bitsize
> bitpos
)
5964 piece_bitpos
+= cur_bitsize
;
5965 piece_loc
= &XEXP (*piece_loc
, 1);
5969 /* TEMP->LAST here is either pointer to the last but one or
5970 last element in the chained list, LAST is pointer to the
5972 if (label
&& strcmp (last
->label
, label
) == 0)
5974 /* For SRA optimized variables if there weren't any real
5975 insns since last note, just modify the last node. */
5976 if (piece_loc
!= NULL
)
5978 adjust_piece_list (piece_loc
, NULL
, NULL
,
5979 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5982 /* If the last note doesn't cover any instructions, remove it. */
5983 if (temp
->last
!= last
)
5985 temp
->last
->next
= NULL
;
5988 gcc_assert (strcmp (last
->label
, label
) != 0);
5992 gcc_assert (temp
->first
== temp
->last
5993 || (temp
->first
->next
== temp
->last
5994 && TREE_CODE (decl
) == PARM_DECL
));
5995 memset (temp
->last
, '\0', sizeof (*temp
->last
));
5996 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6000 if (bitsize
== -1 && NOTE_P (last
->loc
))
6001 last_loc_note
= last
->loc
;
6002 else if (piece_loc
!= NULL
6003 && *piece_loc
!= NULL_RTX
6004 && piece_bitpos
== bitpos
6005 && decl_piece_bitsize (*piece_loc
) == bitsize
)
6006 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
6008 last_loc_note
= NULL_RTX
;
6009 /* If the current location is the same as the end of the list,
6010 and either both or neither of the locations is uninitialized,
6011 we have nothing to do. */
6012 if (last_loc_note
== NULL_RTX
6013 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
6014 NOTE_VAR_LOCATION_LOC (loc_note
)))
6015 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6016 != NOTE_VAR_LOCATION_STATUS (loc_note
))
6017 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6018 == VAR_INIT_STATUS_UNINITIALIZED
)
6019 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
6020 == VAR_INIT_STATUS_UNINITIALIZED
))))
6022 /* Add LOC to the end of list and update LAST. If the last
6023 element of the list has been removed above, reuse its
6024 memory for the new node, otherwise allocate a new one. */
6028 memset (loc
, '\0', sizeof (*loc
));
6031 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6032 if (bitsize
== -1 || piece_loc
== NULL
)
6033 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6035 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
6036 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6038 /* Ensure TEMP->LAST will point either to the new last but one
6039 element of the chain, or to the last element in it. */
6040 if (last
!= temp
->last
)
6048 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6051 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6056 /* Keep track of the number of spaces used to indent the
6057 output of the debugging routines that print the structure of
6058 the DIE internal representation. */
6059 static int print_indent
;
6061 /* Indent the line the number of spaces given by print_indent. */
6064 print_spaces (FILE *outfile
)
6066 fprintf (outfile
, "%*s", print_indent
, "");
6069 /* Print a type signature in hex. */
6072 print_signature (FILE *outfile
, char *sig
)
6076 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
6077 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
6081 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
6083 if (discr_value
->pos
)
6084 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
6086 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
6089 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
6091 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6092 RECURSE, output location descriptor operations. */
6095 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
6097 switch (val
->val_class
)
6099 case dw_val_class_addr
:
6100 fprintf (outfile
, "address");
6102 case dw_val_class_offset
:
6103 fprintf (outfile
, "offset");
6105 case dw_val_class_loc
:
6106 fprintf (outfile
, "location descriptor");
6107 if (val
->v
.val_loc
== NULL
)
6108 fprintf (outfile
, " -> <null>\n");
6111 fprintf (outfile
, ":\n");
6113 print_loc_descr (val
->v
.val_loc
, outfile
);
6117 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
6119 case dw_val_class_loc_list
:
6120 fprintf (outfile
, "location list -> label:%s",
6121 val
->v
.val_loc_list
->ll_symbol
);
6123 case dw_val_class_range_list
:
6124 fprintf (outfile
, "range list");
6126 case dw_val_class_const
:
6127 case dw_val_class_const_implicit
:
6128 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
6130 case dw_val_class_unsigned_const
:
6131 case dw_val_class_unsigned_const_implicit
:
6132 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
6134 case dw_val_class_const_double
:
6135 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
6136 HOST_WIDE_INT_PRINT_UNSIGNED
")",
6137 val
->v
.val_double
.high
,
6138 val
->v
.val_double
.low
);
6140 case dw_val_class_wide_int
:
6142 int i
= val
->v
.val_wide
->get_len ();
6143 fprintf (outfile
, "constant (");
6145 if (val
->v
.val_wide
->elt (i
- 1) == 0)
6146 fprintf (outfile
, "0x");
6147 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
6148 val
->v
.val_wide
->elt (--i
));
6150 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
6151 val
->v
.val_wide
->elt (i
));
6152 fprintf (outfile
, ")");
6155 case dw_val_class_vec
:
6156 fprintf (outfile
, "floating-point or vector constant");
6158 case dw_val_class_flag
:
6159 fprintf (outfile
, "%u", val
->v
.val_flag
);
6161 case dw_val_class_die_ref
:
6162 if (val
->v
.val_die_ref
.die
!= NULL
)
6164 dw_die_ref die
= val
->v
.val_die_ref
.die
;
6166 if (die
->comdat_type_p
)
6168 fprintf (outfile
, "die -> signature: ");
6169 print_signature (outfile
,
6170 die
->die_id
.die_type_node
->signature
);
6172 else if (die
->die_id
.die_symbol
)
6174 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
6175 if (die
->with_offset
)
6176 fprintf (outfile
, " + %ld", die
->die_offset
);
6179 fprintf (outfile
, "die -> %ld", die
->die_offset
);
6180 fprintf (outfile
, " (%p)", (void *) die
);
6183 fprintf (outfile
, "die -> <null>");
6185 case dw_val_class_vms_delta
:
6186 fprintf (outfile
, "delta: @slotcount(%s-%s)",
6187 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
6189 case dw_val_class_lbl_id
:
6190 case dw_val_class_lineptr
:
6191 case dw_val_class_macptr
:
6192 case dw_val_class_loclistsptr
:
6193 case dw_val_class_high_pc
:
6194 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
6196 case dw_val_class_str
:
6197 if (val
->v
.val_str
->str
!= NULL
)
6198 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
6200 fprintf (outfile
, "<null>");
6202 case dw_val_class_file
:
6203 case dw_val_class_file_implicit
:
6204 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
6205 val
->v
.val_file
->emitted_number
);
6207 case dw_val_class_data8
:
6211 for (i
= 0; i
< 8; i
++)
6212 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
6215 case dw_val_class_discr_value
:
6216 print_discr_value (outfile
, &val
->v
.val_discr_value
);
6218 case dw_val_class_discr_list
:
6219 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
6221 node
= node
->dw_discr_next
)
6223 if (node
->dw_discr_range
)
6225 fprintf (outfile
, " .. ");
6226 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6227 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
6230 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6232 if (node
->dw_discr_next
!= NULL
)
6233 fprintf (outfile
, " | ");
6240 /* Likewise, for a DIE attribute. */
6243 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
6245 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
6249 /* Print the list of operands in the LOC location description to OUTFILE. This
6250 routine is a debugging aid only. */
6253 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
6255 dw_loc_descr_ref l
= loc
;
6259 print_spaces (outfile
);
6260 fprintf (outfile
, "<null>\n");
6264 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
6266 print_spaces (outfile
);
6267 fprintf (outfile
, "(%p) %s",
6269 dwarf_stack_op_name (l
->dw_loc_opc
));
6270 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
6272 fprintf (outfile
, " ");
6273 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
6275 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
6277 fprintf (outfile
, ", ");
6278 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
6280 fprintf (outfile
, "\n");
6284 /* Print the information associated with a given DIE, and its children.
6285 This routine is a debugging aid only. */
6288 print_die (dw_die_ref die
, FILE *outfile
)
6294 print_spaces (outfile
);
6295 fprintf (outfile
, "DIE %4ld: %s (%p)\n",
6296 die
->die_offset
, dwarf_tag_name (die
->die_tag
),
6298 print_spaces (outfile
);
6299 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6300 fprintf (outfile
, " offset: %ld", die
->die_offset
);
6301 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
6303 if (die
->comdat_type_p
)
6305 print_spaces (outfile
);
6306 fprintf (outfile
, " signature: ");
6307 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
6308 fprintf (outfile
, "\n");
6311 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6313 print_spaces (outfile
);
6314 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6316 print_attribute (a
, true, outfile
);
6317 fprintf (outfile
, "\n");
6320 if (die
->die_child
!= NULL
)
6323 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6326 if (print_indent
== 0)
6327 fprintf (outfile
, "\n");
6330 /* Print the list of operations in the LOC location description. */
6333 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
6335 print_loc_descr (loc
, stderr
);
6338 /* Print the information collected for a given DIE. */
6341 debug_dwarf_die (dw_die_ref die
)
6343 print_die (die
, stderr
);
6347 debug (die_struct
&ref
)
6349 print_die (&ref
, stderr
);
6353 debug (die_struct
*ptr
)
6358 fprintf (stderr
, "<nil>\n");
6362 /* Print all DWARF information collected for the compilation unit.
6363 This routine is a debugging aid only. */
6369 print_die (comp_unit_die (), stderr
);
6372 /* Verify the DIE tree structure. */
6375 verify_die (dw_die_ref die
)
6377 gcc_assert (!die
->die_mark
);
6378 if (die
->die_parent
== NULL
6379 && die
->die_sib
== NULL
)
6381 /* Verify the die_sib list is cyclic. */
6388 while (x
&& !x
->die_mark
);
6389 gcc_assert (x
== die
);
6393 /* Verify all dies have the same parent. */
6394 gcc_assert (x
->die_parent
== die
->die_parent
);
6397 /* Verify the child has the proper parent and recurse. */
6398 gcc_assert (x
->die_child
->die_parent
== x
);
6399 verify_die (x
->die_child
);
6404 while (x
&& x
->die_mark
);
6407 /* Sanity checks on DIEs. */
6410 check_die (dw_die_ref die
)
6414 bool inline_found
= false;
6415 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
6416 int n_decl_line
= 0, n_decl_column
= 0, n_decl_file
= 0;
6417 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6422 if (a
->dw_attr_val
.v
.val_unsigned
)
6423 inline_found
= true;
6425 case DW_AT_location
:
6434 case DW_AT_artificial
:
6437 case DW_AT_decl_column
:
6440 case DW_AT_decl_line
:
6443 case DW_AT_decl_file
:
6450 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
6451 || n_decl_column
> 1 || n_decl_line
> 1 || n_decl_file
> 1)
6453 fprintf (stderr
, "Duplicate attributes in DIE:\n");
6454 debug_dwarf_die (die
);
6459 /* A debugging information entry that is a member of an abstract
6460 instance tree [that has DW_AT_inline] should not contain any
6461 attributes which describe aspects of the subroutine which vary
6462 between distinct inlined expansions or distinct out-of-line
6464 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6465 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
6466 && a
->dw_attr
!= DW_AT_high_pc
6467 && a
->dw_attr
!= DW_AT_location
6468 && a
->dw_attr
!= DW_AT_frame_base
6469 && a
->dw_attr
!= DW_AT_call_all_calls
6470 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
6474 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6475 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6476 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6478 /* Calculate the checksum of a location expression. */
6481 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6484 inchash::hash hstate
;
6487 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
6489 hash_loc_operands (loc
, hstate
);
6490 hash
= hstate
.end();
6494 /* Calculate the checksum of an attribute. */
6497 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
6499 dw_loc_descr_ref loc
;
6502 CHECKSUM (at
->dw_attr
);
6504 /* We don't care that this was compiled with a different compiler
6505 snapshot; if the output is the same, that's what matters. */
6506 if (at
->dw_attr
== DW_AT_producer
)
6509 switch (AT_class (at
))
6511 case dw_val_class_const
:
6512 case dw_val_class_const_implicit
:
6513 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
6515 case dw_val_class_unsigned_const
:
6516 case dw_val_class_unsigned_const_implicit
:
6517 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
6519 case dw_val_class_const_double
:
6520 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6522 case dw_val_class_wide_int
:
6523 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6524 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6525 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6527 case dw_val_class_vec
:
6528 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6529 (at
->dw_attr_val
.v
.val_vec
.length
6530 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6532 case dw_val_class_flag
:
6533 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
6535 case dw_val_class_str
:
6536 CHECKSUM_STRING (AT_string (at
));
6539 case dw_val_class_addr
:
6541 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6542 CHECKSUM_STRING (XSTR (r
, 0));
6545 case dw_val_class_offset
:
6546 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
6549 case dw_val_class_loc
:
6550 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6551 loc_checksum (loc
, ctx
);
6554 case dw_val_class_die_ref
:
6555 die_checksum (AT_ref (at
), ctx
, mark
);
6558 case dw_val_class_fde_ref
:
6559 case dw_val_class_vms_delta
:
6560 case dw_val_class_lbl_id
:
6561 case dw_val_class_lineptr
:
6562 case dw_val_class_macptr
:
6563 case dw_val_class_loclistsptr
:
6564 case dw_val_class_high_pc
:
6567 case dw_val_class_file
:
6568 case dw_val_class_file_implicit
:
6569 CHECKSUM_STRING (AT_file (at
)->filename
);
6572 case dw_val_class_data8
:
6573 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6581 /* Calculate the checksum of a DIE. */
6584 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6590 /* To avoid infinite recursion. */
6593 CHECKSUM (die
->die_mark
);
6596 die
->die_mark
= ++(*mark
);
6598 CHECKSUM (die
->die_tag
);
6600 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6601 attr_checksum (a
, ctx
, mark
);
6603 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
6607 #undef CHECKSUM_BLOCK
6608 #undef CHECKSUM_STRING
6610 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
6611 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6612 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6613 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
6614 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
6615 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
6616 #define CHECKSUM_ATTR(FOO) \
6617 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
6619 /* Calculate the checksum of a number in signed LEB128 format. */
6622 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6629 byte
= (value
& 0x7f);
6631 more
= !((value
== 0 && (byte
& 0x40) == 0)
6632 || (value
== -1 && (byte
& 0x40) != 0));
6641 /* Calculate the checksum of a number in unsigned LEB128 format. */
6644 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6648 unsigned char byte
= (value
& 0x7f);
6651 /* More bytes to follow. */
6659 /* Checksum the context of the DIE. This adds the names of any
6660 surrounding namespaces or structures to the checksum. */
6663 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
6667 int tag
= die
->die_tag
;
6669 if (tag
!= DW_TAG_namespace
6670 && tag
!= DW_TAG_structure_type
6671 && tag
!= DW_TAG_class_type
)
6674 name
= get_AT_string (die
, DW_AT_name
);
6676 spec
= get_AT_ref (die
, DW_AT_specification
);
6680 if (die
->die_parent
!= NULL
)
6681 checksum_die_context (die
->die_parent
, ctx
);
6683 CHECKSUM_ULEB128 ('C');
6684 CHECKSUM_ULEB128 (tag
);
6686 CHECKSUM_STRING (name
);
6689 /* Calculate the checksum of a location expression. */
6692 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6694 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
6695 were emitted as a DW_FORM_sdata instead of a location expression. */
6696 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
6698 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6699 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
6703 /* Otherwise, just checksum the raw location expression. */
6706 inchash::hash hstate
;
6709 CHECKSUM_ULEB128 (loc
->dtprel
);
6710 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
6711 hash_loc_operands (loc
, hstate
);
6712 hash
= hstate
.end ();
6714 loc
= loc
->dw_loc_next
;
6718 /* Calculate the checksum of an attribute. */
6721 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
6722 struct md5_ctx
*ctx
, int *mark
)
6724 dw_loc_descr_ref loc
;
6727 if (AT_class (at
) == dw_val_class_die_ref
)
6729 dw_die_ref target_die
= AT_ref (at
);
6731 /* For pointer and reference types, we checksum only the (qualified)
6732 name of the target type (if there is a name). For friend entries,
6733 we checksum only the (qualified) name of the target type or function.
6734 This allows the checksum to remain the same whether the target type
6735 is complete or not. */
6736 if ((at
->dw_attr
== DW_AT_type
6737 && (tag
== DW_TAG_pointer_type
6738 || tag
== DW_TAG_reference_type
6739 || tag
== DW_TAG_rvalue_reference_type
6740 || tag
== DW_TAG_ptr_to_member_type
))
6741 || (at
->dw_attr
== DW_AT_friend
6742 && tag
== DW_TAG_friend
))
6744 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
6746 if (name_attr
!= NULL
)
6748 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
6752 CHECKSUM_ULEB128 ('N');
6753 CHECKSUM_ULEB128 (at
->dw_attr
);
6754 if (decl
->die_parent
!= NULL
)
6755 checksum_die_context (decl
->die_parent
, ctx
);
6756 CHECKSUM_ULEB128 ('E');
6757 CHECKSUM_STRING (AT_string (name_attr
));
6762 /* For all other references to another DIE, we check to see if the
6763 target DIE has already been visited. If it has, we emit a
6764 backward reference; if not, we descend recursively. */
6765 if (target_die
->die_mark
> 0)
6767 CHECKSUM_ULEB128 ('R');
6768 CHECKSUM_ULEB128 (at
->dw_attr
);
6769 CHECKSUM_ULEB128 (target_die
->die_mark
);
6773 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
6777 target_die
->die_mark
= ++(*mark
);
6778 CHECKSUM_ULEB128 ('T');
6779 CHECKSUM_ULEB128 (at
->dw_attr
);
6780 if (decl
->die_parent
!= NULL
)
6781 checksum_die_context (decl
->die_parent
, ctx
);
6782 die_checksum_ordered (target_die
, ctx
, mark
);
6787 CHECKSUM_ULEB128 ('A');
6788 CHECKSUM_ULEB128 (at
->dw_attr
);
6790 switch (AT_class (at
))
6792 case dw_val_class_const
:
6793 case dw_val_class_const_implicit
:
6794 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6795 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
6798 case dw_val_class_unsigned_const
:
6799 case dw_val_class_unsigned_const_implicit
:
6800 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6801 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
6804 case dw_val_class_const_double
:
6805 CHECKSUM_ULEB128 (DW_FORM_block
);
6806 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
6807 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6810 case dw_val_class_wide_int
:
6811 CHECKSUM_ULEB128 (DW_FORM_block
);
6812 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6813 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
6814 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6815 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6816 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6819 case dw_val_class_vec
:
6820 CHECKSUM_ULEB128 (DW_FORM_block
);
6821 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
6822 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
6823 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6824 (at
->dw_attr_val
.v
.val_vec
.length
6825 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6828 case dw_val_class_flag
:
6829 CHECKSUM_ULEB128 (DW_FORM_flag
);
6830 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
6833 case dw_val_class_str
:
6834 CHECKSUM_ULEB128 (DW_FORM_string
);
6835 CHECKSUM_STRING (AT_string (at
));
6838 case dw_val_class_addr
:
6840 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6841 CHECKSUM_ULEB128 (DW_FORM_string
);
6842 CHECKSUM_STRING (XSTR (r
, 0));
6845 case dw_val_class_offset
:
6846 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6847 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
6850 case dw_val_class_loc
:
6851 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6852 loc_checksum_ordered (loc
, ctx
);
6855 case dw_val_class_fde_ref
:
6856 case dw_val_class_lbl_id
:
6857 case dw_val_class_lineptr
:
6858 case dw_val_class_macptr
:
6859 case dw_val_class_loclistsptr
:
6860 case dw_val_class_high_pc
:
6863 case dw_val_class_file
:
6864 case dw_val_class_file_implicit
:
6865 CHECKSUM_ULEB128 (DW_FORM_string
);
6866 CHECKSUM_STRING (AT_file (at
)->filename
);
6869 case dw_val_class_data8
:
6870 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6878 struct checksum_attributes
6880 dw_attr_node
*at_name
;
6881 dw_attr_node
*at_type
;
6882 dw_attr_node
*at_friend
;
6883 dw_attr_node
*at_accessibility
;
6884 dw_attr_node
*at_address_class
;
6885 dw_attr_node
*at_alignment
;
6886 dw_attr_node
*at_allocated
;
6887 dw_attr_node
*at_artificial
;
6888 dw_attr_node
*at_associated
;
6889 dw_attr_node
*at_binary_scale
;
6890 dw_attr_node
*at_bit_offset
;
6891 dw_attr_node
*at_bit_size
;
6892 dw_attr_node
*at_bit_stride
;
6893 dw_attr_node
*at_byte_size
;
6894 dw_attr_node
*at_byte_stride
;
6895 dw_attr_node
*at_const_value
;
6896 dw_attr_node
*at_containing_type
;
6897 dw_attr_node
*at_count
;
6898 dw_attr_node
*at_data_location
;
6899 dw_attr_node
*at_data_member_location
;
6900 dw_attr_node
*at_decimal_scale
;
6901 dw_attr_node
*at_decimal_sign
;
6902 dw_attr_node
*at_default_value
;
6903 dw_attr_node
*at_digit_count
;
6904 dw_attr_node
*at_discr
;
6905 dw_attr_node
*at_discr_list
;
6906 dw_attr_node
*at_discr_value
;
6907 dw_attr_node
*at_encoding
;
6908 dw_attr_node
*at_endianity
;
6909 dw_attr_node
*at_explicit
;
6910 dw_attr_node
*at_is_optional
;
6911 dw_attr_node
*at_location
;
6912 dw_attr_node
*at_lower_bound
;
6913 dw_attr_node
*at_mutable
;
6914 dw_attr_node
*at_ordering
;
6915 dw_attr_node
*at_picture_string
;
6916 dw_attr_node
*at_prototyped
;
6917 dw_attr_node
*at_small
;
6918 dw_attr_node
*at_segment
;
6919 dw_attr_node
*at_string_length
;
6920 dw_attr_node
*at_string_length_bit_size
;
6921 dw_attr_node
*at_string_length_byte_size
;
6922 dw_attr_node
*at_threads_scaled
;
6923 dw_attr_node
*at_upper_bound
;
6924 dw_attr_node
*at_use_location
;
6925 dw_attr_node
*at_use_UTF8
;
6926 dw_attr_node
*at_variable_parameter
;
6927 dw_attr_node
*at_virtuality
;
6928 dw_attr_node
*at_visibility
;
6929 dw_attr_node
*at_vtable_elem_location
;
6932 /* Collect the attributes that we will want to use for the checksum. */
6935 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
6940 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6951 attrs
->at_friend
= a
;
6953 case DW_AT_accessibility
:
6954 attrs
->at_accessibility
= a
;
6956 case DW_AT_address_class
:
6957 attrs
->at_address_class
= a
;
6959 case DW_AT_alignment
:
6960 attrs
->at_alignment
= a
;
6962 case DW_AT_allocated
:
6963 attrs
->at_allocated
= a
;
6965 case DW_AT_artificial
:
6966 attrs
->at_artificial
= a
;
6968 case DW_AT_associated
:
6969 attrs
->at_associated
= a
;
6971 case DW_AT_binary_scale
:
6972 attrs
->at_binary_scale
= a
;
6974 case DW_AT_bit_offset
:
6975 attrs
->at_bit_offset
= a
;
6977 case DW_AT_bit_size
:
6978 attrs
->at_bit_size
= a
;
6980 case DW_AT_bit_stride
:
6981 attrs
->at_bit_stride
= a
;
6983 case DW_AT_byte_size
:
6984 attrs
->at_byte_size
= a
;
6986 case DW_AT_byte_stride
:
6987 attrs
->at_byte_stride
= a
;
6989 case DW_AT_const_value
:
6990 attrs
->at_const_value
= a
;
6992 case DW_AT_containing_type
:
6993 attrs
->at_containing_type
= a
;
6996 attrs
->at_count
= a
;
6998 case DW_AT_data_location
:
6999 attrs
->at_data_location
= a
;
7001 case DW_AT_data_member_location
:
7002 attrs
->at_data_member_location
= a
;
7004 case DW_AT_decimal_scale
:
7005 attrs
->at_decimal_scale
= a
;
7007 case DW_AT_decimal_sign
:
7008 attrs
->at_decimal_sign
= a
;
7010 case DW_AT_default_value
:
7011 attrs
->at_default_value
= a
;
7013 case DW_AT_digit_count
:
7014 attrs
->at_digit_count
= a
;
7017 attrs
->at_discr
= a
;
7019 case DW_AT_discr_list
:
7020 attrs
->at_discr_list
= a
;
7022 case DW_AT_discr_value
:
7023 attrs
->at_discr_value
= a
;
7025 case DW_AT_encoding
:
7026 attrs
->at_encoding
= a
;
7028 case DW_AT_endianity
:
7029 attrs
->at_endianity
= a
;
7031 case DW_AT_explicit
:
7032 attrs
->at_explicit
= a
;
7034 case DW_AT_is_optional
:
7035 attrs
->at_is_optional
= a
;
7037 case DW_AT_location
:
7038 attrs
->at_location
= a
;
7040 case DW_AT_lower_bound
:
7041 attrs
->at_lower_bound
= a
;
7044 attrs
->at_mutable
= a
;
7046 case DW_AT_ordering
:
7047 attrs
->at_ordering
= a
;
7049 case DW_AT_picture_string
:
7050 attrs
->at_picture_string
= a
;
7052 case DW_AT_prototyped
:
7053 attrs
->at_prototyped
= a
;
7056 attrs
->at_small
= a
;
7059 attrs
->at_segment
= a
;
7061 case DW_AT_string_length
:
7062 attrs
->at_string_length
= a
;
7064 case DW_AT_string_length_bit_size
:
7065 attrs
->at_string_length_bit_size
= a
;
7067 case DW_AT_string_length_byte_size
:
7068 attrs
->at_string_length_byte_size
= a
;
7070 case DW_AT_threads_scaled
:
7071 attrs
->at_threads_scaled
= a
;
7073 case DW_AT_upper_bound
:
7074 attrs
->at_upper_bound
= a
;
7076 case DW_AT_use_location
:
7077 attrs
->at_use_location
= a
;
7079 case DW_AT_use_UTF8
:
7080 attrs
->at_use_UTF8
= a
;
7082 case DW_AT_variable_parameter
:
7083 attrs
->at_variable_parameter
= a
;
7085 case DW_AT_virtuality
:
7086 attrs
->at_virtuality
= a
;
7088 case DW_AT_visibility
:
7089 attrs
->at_visibility
= a
;
7091 case DW_AT_vtable_elem_location
:
7092 attrs
->at_vtable_elem_location
= a
;
7100 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7103 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7107 struct checksum_attributes attrs
;
7109 CHECKSUM_ULEB128 ('D');
7110 CHECKSUM_ULEB128 (die
->die_tag
);
7112 memset (&attrs
, 0, sizeof (attrs
));
7114 decl
= get_AT_ref (die
, DW_AT_specification
);
7116 collect_checksum_attributes (&attrs
, decl
);
7117 collect_checksum_attributes (&attrs
, die
);
7119 CHECKSUM_ATTR (attrs
.at_name
);
7120 CHECKSUM_ATTR (attrs
.at_accessibility
);
7121 CHECKSUM_ATTR (attrs
.at_address_class
);
7122 CHECKSUM_ATTR (attrs
.at_allocated
);
7123 CHECKSUM_ATTR (attrs
.at_artificial
);
7124 CHECKSUM_ATTR (attrs
.at_associated
);
7125 CHECKSUM_ATTR (attrs
.at_binary_scale
);
7126 CHECKSUM_ATTR (attrs
.at_bit_offset
);
7127 CHECKSUM_ATTR (attrs
.at_bit_size
);
7128 CHECKSUM_ATTR (attrs
.at_bit_stride
);
7129 CHECKSUM_ATTR (attrs
.at_byte_size
);
7130 CHECKSUM_ATTR (attrs
.at_byte_stride
);
7131 CHECKSUM_ATTR (attrs
.at_const_value
);
7132 CHECKSUM_ATTR (attrs
.at_containing_type
);
7133 CHECKSUM_ATTR (attrs
.at_count
);
7134 CHECKSUM_ATTR (attrs
.at_data_location
);
7135 CHECKSUM_ATTR (attrs
.at_data_member_location
);
7136 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
7137 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
7138 CHECKSUM_ATTR (attrs
.at_default_value
);
7139 CHECKSUM_ATTR (attrs
.at_digit_count
);
7140 CHECKSUM_ATTR (attrs
.at_discr
);
7141 CHECKSUM_ATTR (attrs
.at_discr_list
);
7142 CHECKSUM_ATTR (attrs
.at_discr_value
);
7143 CHECKSUM_ATTR (attrs
.at_encoding
);
7144 CHECKSUM_ATTR (attrs
.at_endianity
);
7145 CHECKSUM_ATTR (attrs
.at_explicit
);
7146 CHECKSUM_ATTR (attrs
.at_is_optional
);
7147 CHECKSUM_ATTR (attrs
.at_location
);
7148 CHECKSUM_ATTR (attrs
.at_lower_bound
);
7149 CHECKSUM_ATTR (attrs
.at_mutable
);
7150 CHECKSUM_ATTR (attrs
.at_ordering
);
7151 CHECKSUM_ATTR (attrs
.at_picture_string
);
7152 CHECKSUM_ATTR (attrs
.at_prototyped
);
7153 CHECKSUM_ATTR (attrs
.at_small
);
7154 CHECKSUM_ATTR (attrs
.at_segment
);
7155 CHECKSUM_ATTR (attrs
.at_string_length
);
7156 CHECKSUM_ATTR (attrs
.at_string_length_bit_size
);
7157 CHECKSUM_ATTR (attrs
.at_string_length_byte_size
);
7158 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
7159 CHECKSUM_ATTR (attrs
.at_upper_bound
);
7160 CHECKSUM_ATTR (attrs
.at_use_location
);
7161 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
7162 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
7163 CHECKSUM_ATTR (attrs
.at_virtuality
);
7164 CHECKSUM_ATTR (attrs
.at_visibility
);
7165 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
7166 CHECKSUM_ATTR (attrs
.at_type
);
7167 CHECKSUM_ATTR (attrs
.at_friend
);
7168 CHECKSUM_ATTR (attrs
.at_alignment
);
7170 /* Checksum the child DIEs. */
7173 dw_attr_node
*name_attr
;
7176 name_attr
= get_AT (c
, DW_AT_name
);
7177 if (is_template_instantiation (c
))
7179 /* Ignore instantiations of member type and function templates. */
7181 else if (name_attr
!= NULL
7182 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
7184 /* Use a shallow checksum for named nested types and member
7186 CHECKSUM_ULEB128 ('S');
7187 CHECKSUM_ULEB128 (c
->die_tag
);
7188 CHECKSUM_STRING (AT_string (name_attr
));
7192 /* Use a deep checksum for other children. */
7193 /* Mark this DIE so it gets processed when unmarking. */
7194 if (c
->die_mark
== 0)
7196 die_checksum_ordered (c
, ctx
, mark
);
7198 } while (c
!= die
->die_child
);
7200 CHECKSUM_ULEB128 (0);
7203 /* Add a type name and tag to a hash. */
7205 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
7207 CHECKSUM_ULEB128 (tag
);
7208 CHECKSUM_STRING (name
);
7212 #undef CHECKSUM_STRING
7213 #undef CHECKSUM_ATTR
7214 #undef CHECKSUM_LEB128
7215 #undef CHECKSUM_ULEB128
7217 /* Generate the type signature for DIE. This is computed by generating an
7218 MD5 checksum over the DIE's tag, its relevant attributes, and its
7219 children. Attributes that are references to other DIEs are processed
7220 by recursion, using the MARK field to prevent infinite recursion.
7221 If the DIE is nested inside a namespace or another type, we also
7222 need to include that context in the signature. The lower 64 bits
7223 of the resulting MD5 checksum comprise the signature. */
7226 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
7230 unsigned char checksum
[16];
7235 name
= get_AT_string (die
, DW_AT_name
);
7236 decl
= get_AT_ref (die
, DW_AT_specification
);
7237 parent
= get_die_parent (die
);
7239 /* First, compute a signature for just the type name (and its surrounding
7240 context, if any. This is stored in the type unit DIE for link-time
7241 ODR (one-definition rule) checking. */
7243 if (is_cxx () && name
!= NULL
)
7245 md5_init_ctx (&ctx
);
7247 /* Checksum the names of surrounding namespaces and structures. */
7249 checksum_die_context (parent
, &ctx
);
7251 /* Checksum the current DIE. */
7252 die_odr_checksum (die
->die_tag
, name
, &ctx
);
7253 md5_finish_ctx (&ctx
, checksum
);
7255 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
7258 /* Next, compute the complete type signature. */
7260 md5_init_ctx (&ctx
);
7262 die
->die_mark
= mark
;
7264 /* Checksum the names of surrounding namespaces and structures. */
7266 checksum_die_context (parent
, &ctx
);
7268 /* Checksum the DIE and its children. */
7269 die_checksum_ordered (die
, &ctx
, &mark
);
7270 unmark_all_dies (die
);
7271 md5_finish_ctx (&ctx
, checksum
);
7273 /* Store the signature in the type node and link the type DIE and the
7274 type node together. */
7275 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
7276 DWARF_TYPE_SIGNATURE_SIZE
);
7277 die
->comdat_type_p
= true;
7278 die
->die_id
.die_type_node
= type_node
;
7279 type_node
->type_die
= die
;
7281 /* If the DIE is a specification, link its declaration to the type node
7285 decl
->comdat_type_p
= true;
7286 decl
->die_id
.die_type_node
= type_node
;
7290 /* Do the location expressions look same? */
7292 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
7294 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
7295 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
7296 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
7299 /* Do the values look the same? */
7301 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
7303 dw_loc_descr_ref loc1
, loc2
;
7306 if (v1
->val_class
!= v2
->val_class
)
7309 switch (v1
->val_class
)
7311 case dw_val_class_const
:
7312 case dw_val_class_const_implicit
:
7313 return v1
->v
.val_int
== v2
->v
.val_int
;
7314 case dw_val_class_unsigned_const
:
7315 case dw_val_class_unsigned_const_implicit
:
7316 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7317 case dw_val_class_const_double
:
7318 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
7319 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
7320 case dw_val_class_wide_int
:
7321 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
7322 case dw_val_class_vec
:
7323 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7324 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7326 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7327 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7330 case dw_val_class_flag
:
7331 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7332 case dw_val_class_str
:
7333 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7335 case dw_val_class_addr
:
7336 r1
= v1
->v
.val_addr
;
7337 r2
= v2
->v
.val_addr
;
7338 if (GET_CODE (r1
) != GET_CODE (r2
))
7340 return !rtx_equal_p (r1
, r2
);
7342 case dw_val_class_offset
:
7343 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7345 case dw_val_class_loc
:
7346 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7348 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7349 if (!same_loc_p (loc1
, loc2
, mark
))
7351 return !loc1
&& !loc2
;
7353 case dw_val_class_die_ref
:
7354 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7356 case dw_val_class_fde_ref
:
7357 case dw_val_class_vms_delta
:
7358 case dw_val_class_lbl_id
:
7359 case dw_val_class_lineptr
:
7360 case dw_val_class_macptr
:
7361 case dw_val_class_loclistsptr
:
7362 case dw_val_class_high_pc
:
7365 case dw_val_class_file
:
7366 case dw_val_class_file_implicit
:
7367 return v1
->v
.val_file
== v2
->v
.val_file
;
7369 case dw_val_class_data8
:
7370 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
7377 /* Do the attributes look the same? */
7380 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
7382 if (at1
->dw_attr
!= at2
->dw_attr
)
7385 /* We don't care that this was compiled with a different compiler
7386 snapshot; if the output is the same, that's what matters. */
7387 if (at1
->dw_attr
== DW_AT_producer
)
7390 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7393 /* Do the dies look the same? */
7396 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7402 /* To avoid infinite recursion. */
7404 return die1
->die_mark
== die2
->die_mark
;
7405 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7407 if (die1
->die_tag
!= die2
->die_tag
)
7410 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
7413 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
7414 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
7417 c1
= die1
->die_child
;
7418 c2
= die2
->die_child
;
7427 if (!same_die_p (c1
, c2
, mark
))
7431 if (c1
== die1
->die_child
)
7433 if (c2
== die2
->die_child
)
7443 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7444 children, and set die_symbol. */
7447 compute_comp_unit_symbol (dw_die_ref unit_die
)
7449 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
7450 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
7451 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
7454 unsigned char checksum
[16];
7457 /* Compute the checksum of the DIE, then append part of it as hex digits to
7458 the name filename of the unit. */
7460 md5_init_ctx (&ctx
);
7462 die_checksum (unit_die
, &ctx
, &mark
);
7463 unmark_all_dies (unit_die
);
7464 md5_finish_ctx (&ctx
, checksum
);
7466 /* When we this for comp_unit_die () we have a DW_AT_name that might
7467 not start with a letter but with anything valid for filenames and
7468 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
7469 character is not a letter. */
7470 sprintf (name
, "%s%s.", ISALPHA (*base
) ? "" : "g", base
);
7471 clean_symbol_name (name
);
7473 p
= name
+ strlen (name
);
7474 for (i
= 0; i
< 4; i
++)
7476 sprintf (p
, "%.2x", checksum
[i
]);
7480 unit_die
->die_id
.die_symbol
= xstrdup (name
);
7483 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7486 is_type_die (dw_die_ref die
)
7488 switch (die
->die_tag
)
7490 case DW_TAG_array_type
:
7491 case DW_TAG_class_type
:
7492 case DW_TAG_interface_type
:
7493 case DW_TAG_enumeration_type
:
7494 case DW_TAG_pointer_type
:
7495 case DW_TAG_reference_type
:
7496 case DW_TAG_rvalue_reference_type
:
7497 case DW_TAG_string_type
:
7498 case DW_TAG_structure_type
:
7499 case DW_TAG_subroutine_type
:
7500 case DW_TAG_union_type
:
7501 case DW_TAG_ptr_to_member_type
:
7502 case DW_TAG_set_type
:
7503 case DW_TAG_subrange_type
:
7504 case DW_TAG_base_type
:
7505 case DW_TAG_const_type
:
7506 case DW_TAG_file_type
:
7507 case DW_TAG_packed_type
:
7508 case DW_TAG_volatile_type
:
7509 case DW_TAG_typedef
:
7516 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7517 Basically, we want to choose the bits that are likely to be shared between
7518 compilations (types) and leave out the bits that are specific to individual
7519 compilations (functions). */
7522 is_comdat_die (dw_die_ref c
)
7524 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7525 we do for stabs. The advantage is a greater likelihood of sharing between
7526 objects that don't include headers in the same order (and therefore would
7527 put the base types in a different comdat). jason 8/28/00 */
7529 if (c
->die_tag
== DW_TAG_base_type
)
7532 if (c
->die_tag
== DW_TAG_pointer_type
7533 || c
->die_tag
== DW_TAG_reference_type
7534 || c
->die_tag
== DW_TAG_rvalue_reference_type
7535 || c
->die_tag
== DW_TAG_const_type
7536 || c
->die_tag
== DW_TAG_volatile_type
)
7538 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
7540 return t
? is_comdat_die (t
) : 0;
7543 return is_type_die (c
);
7546 /* Returns true iff C is a compile-unit DIE. */
7549 is_cu_die (dw_die_ref c
)
7551 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7552 || c
->die_tag
== DW_TAG_skeleton_unit
);
7555 /* Returns true iff C is a unit DIE of some sort. */
7558 is_unit_die (dw_die_ref c
)
7560 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7561 || c
->die_tag
== DW_TAG_partial_unit
7562 || c
->die_tag
== DW_TAG_type_unit
7563 || c
->die_tag
== DW_TAG_skeleton_unit
);
7566 /* Returns true iff C is a namespace DIE. */
7569 is_namespace_die (dw_die_ref c
)
7571 return c
&& c
->die_tag
== DW_TAG_namespace
;
7574 /* Returns true iff C is a class or structure DIE. */
7577 is_class_die (dw_die_ref c
)
7579 return c
&& (c
->die_tag
== DW_TAG_class_type
7580 || c
->die_tag
== DW_TAG_structure_type
);
7583 /* Return non-zero if this DIE is a template parameter. */
7586 is_template_parameter (dw_die_ref die
)
7588 switch (die
->die_tag
)
7590 case DW_TAG_template_type_param
:
7591 case DW_TAG_template_value_param
:
7592 case DW_TAG_GNU_template_template_param
:
7593 case DW_TAG_GNU_template_parameter_pack
:
7600 /* Return non-zero if this DIE represents a template instantiation. */
7603 is_template_instantiation (dw_die_ref die
)
7607 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
7609 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
7614 gen_internal_sym (const char *prefix
)
7616 char buf
[MAX_ARTIFICIAL_LABEL_BYTES
];
7618 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
7619 return xstrdup (buf
);
7622 /* Return non-zero if this DIE is a declaration. */
7625 is_declaration_die (dw_die_ref die
)
7630 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7631 if (a
->dw_attr
== DW_AT_declaration
)
7637 /* Return non-zero if this DIE is nested inside a subprogram. */
7640 is_nested_in_subprogram (dw_die_ref die
)
7642 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
7646 return local_scope_p (decl
);
7649 /* Return non-zero if this DIE contains a defining declaration of a
7653 contains_subprogram_definition (dw_die_ref die
)
7657 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
7659 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
7663 /* Return non-zero if this is a type DIE that should be moved to a
7664 COMDAT .debug_types section or .debug_info section with DW_UT_*type
7668 should_move_die_to_comdat (dw_die_ref die
)
7670 switch (die
->die_tag
)
7672 case DW_TAG_class_type
:
7673 case DW_TAG_structure_type
:
7674 case DW_TAG_enumeration_type
:
7675 case DW_TAG_union_type
:
7676 /* Don't move declarations, inlined instances, types nested in a
7677 subprogram, or types that contain subprogram definitions. */
7678 if (is_declaration_die (die
)
7679 || get_AT (die
, DW_AT_abstract_origin
)
7680 || is_nested_in_subprogram (die
)
7681 || contains_subprogram_definition (die
))
7684 case DW_TAG_array_type
:
7685 case DW_TAG_interface_type
:
7686 case DW_TAG_pointer_type
:
7687 case DW_TAG_reference_type
:
7688 case DW_TAG_rvalue_reference_type
:
7689 case DW_TAG_string_type
:
7690 case DW_TAG_subroutine_type
:
7691 case DW_TAG_ptr_to_member_type
:
7692 case DW_TAG_set_type
:
7693 case DW_TAG_subrange_type
:
7694 case DW_TAG_base_type
:
7695 case DW_TAG_const_type
:
7696 case DW_TAG_file_type
:
7697 case DW_TAG_packed_type
:
7698 case DW_TAG_volatile_type
:
7699 case DW_TAG_typedef
:
7705 /* Make a clone of DIE. */
7708 clone_die (dw_die_ref die
)
7714 clone
= ggc_cleared_alloc
<die_node
> ();
7715 clone
->die_tag
= die
->die_tag
;
7717 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7718 add_dwarf_attr (clone
, a
);
7723 /* Make a clone of the tree rooted at DIE. */
7726 clone_tree (dw_die_ref die
)
7729 dw_die_ref clone
= clone_die (die
);
7731 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
7736 /* Make a clone of DIE as a declaration. */
7739 clone_as_declaration (dw_die_ref die
)
7746 /* If the DIE is already a declaration, just clone it. */
7747 if (is_declaration_die (die
))
7748 return clone_die (die
);
7750 /* If the DIE is a specification, just clone its declaration DIE. */
7751 decl
= get_AT_ref (die
, DW_AT_specification
);
7754 clone
= clone_die (decl
);
7755 if (die
->comdat_type_p
)
7756 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7760 clone
= ggc_cleared_alloc
<die_node
> ();
7761 clone
->die_tag
= die
->die_tag
;
7763 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7765 /* We don't want to copy over all attributes.
7766 For example we don't want DW_AT_byte_size because otherwise we will no
7767 longer have a declaration and GDB will treat it as a definition. */
7771 case DW_AT_abstract_origin
:
7772 case DW_AT_artificial
:
7773 case DW_AT_containing_type
:
7774 case DW_AT_external
:
7777 case DW_AT_virtuality
:
7778 case DW_AT_linkage_name
:
7779 case DW_AT_MIPS_linkage_name
:
7780 add_dwarf_attr (clone
, a
);
7782 case DW_AT_byte_size
:
7783 case DW_AT_alignment
:
7789 if (die
->comdat_type_p
)
7790 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7792 add_AT_flag (clone
, DW_AT_declaration
, 1);
7797 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7799 struct decl_table_entry
7805 /* Helpers to manipulate hash table of copied declarations. */
7807 /* Hashtable helpers. */
7809 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
7811 typedef die_struct
*compare_type
;
7812 static inline hashval_t
hash (const decl_table_entry
*);
7813 static inline bool equal (const decl_table_entry
*, const die_struct
*);
7817 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
7819 return htab_hash_pointer (entry
->orig
);
7823 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
7824 const die_struct
*entry2
)
7826 return entry1
->orig
== entry2
;
7829 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
7831 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7832 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7833 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7834 to check if the ancestor has already been copied into UNIT. */
7837 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
7838 decl_hash_type
*decl_table
)
7840 dw_die_ref parent
= die
->die_parent
;
7841 dw_die_ref new_parent
= unit
;
7843 decl_table_entry
**slot
= NULL
;
7844 struct decl_table_entry
*entry
= NULL
;
7848 /* Check if the entry has already been copied to UNIT. */
7849 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
7851 if (*slot
!= HTAB_EMPTY_ENTRY
)
7857 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7858 entry
= XCNEW (struct decl_table_entry
);
7866 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
7869 if (!is_unit_die (parent
))
7870 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
7873 copy
= clone_as_declaration (die
);
7874 add_child_die (new_parent
, copy
);
7878 /* Record the pointer to the copy. */
7884 /* Copy the declaration context to the new type unit DIE. This includes
7885 any surrounding namespace or type declarations. If the DIE has an
7886 AT_specification attribute, it also includes attributes and children
7887 attached to the specification, and returns a pointer to the original
7888 parent of the declaration DIE. Returns NULL otherwise. */
7891 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
7894 dw_die_ref new_decl
;
7895 dw_die_ref orig_parent
= NULL
;
7897 decl
= get_AT_ref (die
, DW_AT_specification
);
7906 /* The original DIE will be changed to a declaration, and must
7907 be moved to be a child of the original declaration DIE. */
7908 orig_parent
= decl
->die_parent
;
7910 /* Copy the type node pointer from the new DIE to the original
7911 declaration DIE so we can forward references later. */
7912 decl
->comdat_type_p
= true;
7913 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
7915 remove_AT (die
, DW_AT_specification
);
7917 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
7919 if (a
->dw_attr
!= DW_AT_name
7920 && a
->dw_attr
!= DW_AT_declaration
7921 && a
->dw_attr
!= DW_AT_external
)
7922 add_dwarf_attr (die
, a
);
7925 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
7928 if (decl
->die_parent
!= NULL
7929 && !is_unit_die (decl
->die_parent
))
7931 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
7932 if (new_decl
!= NULL
)
7934 remove_AT (new_decl
, DW_AT_signature
);
7935 add_AT_specification (die
, new_decl
);
7942 /* Generate the skeleton ancestor tree for the given NODE, then clone
7943 the DIE and add the clone into the tree. */
7946 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
7948 if (node
->new_die
!= NULL
)
7951 node
->new_die
= clone_as_declaration (node
->old_die
);
7953 if (node
->parent
!= NULL
)
7955 generate_skeleton_ancestor_tree (node
->parent
);
7956 add_child_die (node
->parent
->new_die
, node
->new_die
);
7960 /* Generate a skeleton tree of DIEs containing any declarations that are
7961 found in the original tree. We traverse the tree looking for declaration
7962 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7965 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
7967 skeleton_chain_node node
;
7970 dw_die_ref prev
= NULL
;
7971 dw_die_ref next
= NULL
;
7973 node
.parent
= parent
;
7975 first
= c
= parent
->old_die
->die_child
;
7979 if (prev
== NULL
|| prev
->die_sib
== c
)
7982 next
= (c
== first
? NULL
: c
->die_sib
);
7984 node
.new_die
= NULL
;
7985 if (is_declaration_die (c
))
7987 if (is_template_instantiation (c
))
7989 /* Instantiated templates do not need to be cloned into the
7990 type unit. Just move the DIE and its children back to
7991 the skeleton tree (in the main CU). */
7992 remove_child_with_prev (c
, prev
);
7993 add_child_die (parent
->new_die
, c
);
7996 else if (c
->comdat_type_p
)
7998 /* This is the skeleton of earlier break_out_comdat_types
7999 type. Clone the existing DIE, but keep the children
8000 under the original (which is in the main CU). */
8001 dw_die_ref clone
= clone_die (c
);
8003 replace_child (c
, clone
, prev
);
8004 generate_skeleton_ancestor_tree (parent
);
8005 add_child_die (parent
->new_die
, c
);
8011 /* Clone the existing DIE, move the original to the skeleton
8012 tree (which is in the main CU), and put the clone, with
8013 all the original's children, where the original came from
8014 (which is about to be moved to the type unit). */
8015 dw_die_ref clone
= clone_die (c
);
8016 move_all_children (c
, clone
);
8018 /* If the original has a DW_AT_object_pointer attribute,
8019 it would now point to a child DIE just moved to the
8020 cloned tree, so we need to remove that attribute from
8022 remove_AT (c
, DW_AT_object_pointer
);
8024 replace_child (c
, clone
, prev
);
8025 generate_skeleton_ancestor_tree (parent
);
8026 add_child_die (parent
->new_die
, c
);
8027 node
.old_die
= clone
;
8032 generate_skeleton_bottom_up (&node
);
8033 } while (next
!= NULL
);
8036 /* Wrapper function for generate_skeleton_bottom_up. */
8039 generate_skeleton (dw_die_ref die
)
8041 skeleton_chain_node node
;
8044 node
.new_die
= NULL
;
8047 /* If this type definition is nested inside another type,
8048 and is not an instantiation of a template, always leave
8049 at least a declaration in its place. */
8050 if (die
->die_parent
!= NULL
8051 && is_type_die (die
->die_parent
)
8052 && !is_template_instantiation (die
))
8053 node
.new_die
= clone_as_declaration (die
);
8055 generate_skeleton_bottom_up (&node
);
8056 return node
.new_die
;
8059 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8060 declaration. The original DIE is moved to a new compile unit so that
8061 existing references to it follow it to the new location. If any of the
8062 original DIE's descendants is a declaration, we need to replace the
8063 original DIE with a skeleton tree and move the declarations back into the
8067 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
8070 dw_die_ref skeleton
, orig_parent
;
8072 /* Copy the declaration context to the type unit DIE. If the returned
8073 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8075 orig_parent
= copy_declaration_context (unit
, child
);
8077 skeleton
= generate_skeleton (child
);
8078 if (skeleton
== NULL
)
8079 remove_child_with_prev (child
, prev
);
8082 skeleton
->comdat_type_p
= true;
8083 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
8085 /* If the original DIE was a specification, we need to put
8086 the skeleton under the parent DIE of the declaration.
8087 This leaves the original declaration in the tree, but
8088 it will be pruned later since there are no longer any
8089 references to it. */
8090 if (orig_parent
!= NULL
)
8092 remove_child_with_prev (child
, prev
);
8093 add_child_die (orig_parent
, skeleton
);
8096 replace_child (child
, skeleton
, prev
);
8103 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8104 comdat_type_node
*type_node
,
8105 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
8107 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8108 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8109 DWARF procedure references in the DW_AT_location attribute. */
8112 copy_dwarf_procedure (dw_die_ref die
,
8113 comdat_type_node
*type_node
,
8114 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8116 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
8118 /* DWARF procedures are not supposed to have children... */
8119 gcc_assert (die
->die_child
== NULL
);
8121 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8122 gcc_assert (vec_safe_length (die
->die_attr
) == 1
8123 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
8125 /* Do not copy more than once DWARF procedures. */
8127 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
8131 die_copy
= clone_die (die
);
8132 add_child_die (type_node
->root_die
, die_copy
);
8133 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
8137 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8138 procedures in DIE's attributes. */
8141 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8142 comdat_type_node
*type_node
,
8143 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8148 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
8150 dw_loc_descr_ref loc
;
8152 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
8155 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
8157 switch (loc
->dw_loc_opc
)
8161 case DW_OP_call_ref
:
8162 gcc_assert (loc
->dw_loc_oprnd1
.val_class
8163 == dw_val_class_die_ref
);
8164 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
8165 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
8167 copied_dwarf_procs
);
8176 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8177 rewrite references to point to the copies.
8179 References are looked for in DIE's attributes and recursively in all its
8180 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8181 mapping from old DWARF procedures to their copy. It is used not to copy
8182 twice the same DWARF procedure under TYPE_NODE. */
8185 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
8186 comdat_type_node
*type_node
,
8187 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8191 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
8192 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
8194 copied_dwarf_procs
));
8197 /* Traverse the DIE and set up additional .debug_types or .debug_info
8198 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8202 break_out_comdat_types (dw_die_ref die
)
8206 dw_die_ref prev
= NULL
;
8207 dw_die_ref next
= NULL
;
8208 dw_die_ref unit
= NULL
;
8210 first
= c
= die
->die_child
;
8214 if (prev
== NULL
|| prev
->die_sib
== c
)
8217 next
= (c
== first
? NULL
: c
->die_sib
);
8218 if (should_move_die_to_comdat (c
))
8220 dw_die_ref replacement
;
8221 comdat_type_node
*type_node
;
8223 /* Break out nested types into their own type units. */
8224 break_out_comdat_types (c
);
8226 /* Create a new type unit DIE as the root for the new tree, and
8227 add it to the list of comdat types. */
8228 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8229 add_AT_unsigned (unit
, DW_AT_language
,
8230 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
8231 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
8232 type_node
->root_die
= unit
;
8233 type_node
->next
= comdat_type_list
;
8234 comdat_type_list
= type_node
;
8236 /* Generate the type signature. */
8237 generate_type_signature (c
, type_node
);
8239 /* Copy the declaration context, attributes, and children of the
8240 declaration into the new type unit DIE, then remove this DIE
8241 from the main CU (or replace it with a skeleton if necessary). */
8242 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
8243 type_node
->skeleton_die
= replacement
;
8245 /* Add the DIE to the new compunit. */
8246 add_child_die (unit
, c
);
8248 /* Types can reference DWARF procedures for type size or data location
8249 expressions. Calls in DWARF expressions cannot target procedures
8250 that are not in the same section. So we must copy DWARF procedures
8251 along with this type and then rewrite references to them. */
8252 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
8253 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
8255 if (replacement
!= NULL
)
8258 else if (c
->die_tag
== DW_TAG_namespace
8259 || c
->die_tag
== DW_TAG_class_type
8260 || c
->die_tag
== DW_TAG_structure_type
8261 || c
->die_tag
== DW_TAG_union_type
)
8263 /* Look for nested types that can be broken out. */
8264 break_out_comdat_types (c
);
8266 } while (next
!= NULL
);
8269 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8270 Enter all the cloned children into the hash table decl_table. */
8273 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
8277 struct decl_table_entry
*entry
;
8278 decl_table_entry
**slot
;
8280 if (die
->die_tag
== DW_TAG_subprogram
)
8281 clone
= clone_as_declaration (die
);
8283 clone
= clone_die (die
);
8285 slot
= decl_table
->find_slot_with_hash (die
,
8286 htab_hash_pointer (die
), INSERT
);
8288 /* Assert that DIE isn't in the hash table yet. If it would be there
8289 before, the ancestors would be necessarily there as well, therefore
8290 clone_tree_partial wouldn't be called. */
8291 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8293 entry
= XCNEW (struct decl_table_entry
);
8295 entry
->copy
= clone
;
8298 if (die
->die_tag
!= DW_TAG_subprogram
)
8299 FOR_EACH_CHILD (die
, c
,
8300 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
8305 /* Walk the DIE and its children, looking for references to incomplete
8306 or trivial types that are unmarked (i.e., that are not in the current
8310 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
8316 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8318 if (AT_class (a
) == dw_val_class_die_ref
)
8320 dw_die_ref targ
= AT_ref (a
);
8321 decl_table_entry
**slot
;
8322 struct decl_table_entry
*entry
;
8324 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
8327 slot
= decl_table
->find_slot_with_hash (targ
,
8328 htab_hash_pointer (targ
),
8331 if (*slot
!= HTAB_EMPTY_ENTRY
)
8333 /* TARG has already been copied, so we just need to
8334 modify the reference to point to the copy. */
8336 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
8340 dw_die_ref parent
= unit
;
8341 dw_die_ref copy
= clone_die (targ
);
8343 /* Record in DECL_TABLE that TARG has been copied.
8344 Need to do this now, before the recursive call,
8345 because DECL_TABLE may be expanded and SLOT
8346 would no longer be a valid pointer. */
8347 entry
= XCNEW (struct decl_table_entry
);
8352 /* If TARG is not a declaration DIE, we need to copy its
8354 if (!is_declaration_die (targ
))
8358 add_child_die (copy
,
8359 clone_tree_partial (c
, decl_table
)));
8362 /* Make sure the cloned tree is marked as part of the
8366 /* If TARG has surrounding context, copy its ancestor tree
8367 into the new type unit. */
8368 if (targ
->die_parent
!= NULL
8369 && !is_unit_die (targ
->die_parent
))
8370 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
8373 add_child_die (parent
, copy
);
8374 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
8376 /* Make sure the newly-copied DIE is walked. If it was
8377 installed in a previously-added context, it won't
8378 get visited otherwise. */
8381 /* Find the highest point of the newly-added tree,
8382 mark each node along the way, and walk from there. */
8383 parent
->die_mark
= 1;
8384 while (parent
->die_parent
8385 && parent
->die_parent
->die_mark
== 0)
8387 parent
= parent
->die_parent
;
8388 parent
->die_mark
= 1;
8390 copy_decls_walk (unit
, parent
, decl_table
);
8396 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8399 /* Copy declarations for "unworthy" types into the new comdat section.
8400 Incomplete types, modified types, and certain other types aren't broken
8401 out into comdat sections of their own, so they don't have a signature,
8402 and we need to copy the declaration into the same section so that we
8403 don't have an external reference. */
8406 copy_decls_for_unworthy_types (dw_die_ref unit
)
8409 decl_hash_type
decl_table (10);
8410 copy_decls_walk (unit
, unit
, &decl_table
);
8414 /* Traverse the DIE and add a sibling attribute if it may have the
8415 effect of speeding up access to siblings. To save some space,
8416 avoid generating sibling attributes for DIE's without children. */
8419 add_sibling_attributes (dw_die_ref die
)
8423 if (! die
->die_child
)
8426 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8427 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8429 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8432 /* Output all location lists for the DIE and its children. */
8435 output_location_lists (dw_die_ref die
)
8441 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8442 if (AT_class (a
) == dw_val_class_loc_list
)
8443 output_loc_list (AT_loc_list (a
));
8445 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
8448 /* During assign_location_list_indexes and output_loclists_offset the
8449 current index, after it the number of assigned indexes (i.e. how
8450 large the .debug_loclists* offset table should be). */
8451 static unsigned int loc_list_idx
;
8453 /* Output all location list offsets for the DIE and its children. */
8456 output_loclists_offsets (dw_die_ref die
)
8462 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8463 if (AT_class (a
) == dw_val_class_loc_list
)
8465 dw_loc_list_ref l
= AT_loc_list (a
);
8466 if (l
->offset_emitted
)
8468 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l
->ll_symbol
,
8469 loc_section_label
, NULL
);
8470 gcc_assert (l
->hash
== loc_list_idx
);
8472 l
->offset_emitted
= true;
8475 FOR_EACH_CHILD (die
, c
, output_loclists_offsets (c
));
8478 /* Recursively set indexes of location lists. */
8481 assign_location_list_indexes (dw_die_ref die
)
8487 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8488 if (AT_class (a
) == dw_val_class_loc_list
)
8490 dw_loc_list_ref list
= AT_loc_list (a
);
8491 if (!list
->num_assigned
)
8493 list
->num_assigned
= true;
8494 list
->hash
= loc_list_idx
++;
8498 FOR_EACH_CHILD (die
, c
, assign_location_list_indexes (c
));
8501 /* We want to limit the number of external references, because they are
8502 larger than local references: a relocation takes multiple words, and
8503 even a sig8 reference is always eight bytes, whereas a local reference
8504 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
8505 So if we encounter multiple external references to the same type DIE, we
8506 make a local typedef stub for it and redirect all references there.
8508 This is the element of the hash table for keeping track of these
8518 /* Hashtable helpers. */
8520 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
8522 static inline hashval_t
hash (const external_ref
*);
8523 static inline bool equal (const external_ref
*, const external_ref
*);
8527 external_ref_hasher::hash (const external_ref
*r
)
8529 dw_die_ref die
= r
->type
;
8532 /* We can't use the address of the DIE for hashing, because
8533 that will make the order of the stub DIEs non-deterministic. */
8534 if (! die
->comdat_type_p
)
8535 /* We have a symbol; use it to compute a hash. */
8536 h
= htab_hash_string (die
->die_id
.die_symbol
);
8539 /* We have a type signature; use a subset of the bits as the hash.
8540 The 8-byte signature is at least as large as hashval_t. */
8541 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
8542 memcpy (&h
, type_node
->signature
, sizeof (h
));
8548 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
8550 return r1
->type
== r2
->type
;
8553 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
8555 /* Return a pointer to the external_ref for references to DIE. */
8557 static struct external_ref
*
8558 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
8560 struct external_ref ref
, *ref_p
;
8561 external_ref
**slot
;
8564 slot
= map
->find_slot (&ref
, INSERT
);
8565 if (*slot
!= HTAB_EMPTY_ENTRY
)
8568 ref_p
= XCNEW (struct external_ref
);
8574 /* Subroutine of optimize_external_refs, below.
8576 If we see a type skeleton, record it as our stub. If we see external
8577 references, remember how many we've seen. */
8580 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
8585 struct external_ref
*ref_p
;
8587 if (is_type_die (die
)
8588 && (c
= get_AT_ref (die
, DW_AT_signature
)))
8590 /* This is a local skeleton; use it for local references. */
8591 ref_p
= lookup_external_ref (map
, c
);
8595 /* Scan the DIE references, and remember any that refer to DIEs from
8596 other CUs (i.e. those which are not marked). */
8597 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8598 if (AT_class (a
) == dw_val_class_die_ref
8599 && (c
= AT_ref (a
))->die_mark
== 0
8602 ref_p
= lookup_external_ref (map
, c
);
8606 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
8609 /* htab_traverse callback function for optimize_external_refs, below. SLOT
8610 points to an external_ref, DATA is the CU we're processing. If we don't
8611 already have a local stub, and we have multiple refs, build a stub. */
8614 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
8616 struct external_ref
*ref_p
= *slot
;
8618 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
8620 /* We have multiple references to this type, so build a small stub.
8621 Both of these forms are a bit dodgy from the perspective of the
8622 DWARF standard, since technically they should have names. */
8623 dw_die_ref cu
= data
;
8624 dw_die_ref type
= ref_p
->type
;
8625 dw_die_ref stub
= NULL
;
8627 if (type
->comdat_type_p
)
8629 /* If we refer to this type via sig8, use AT_signature. */
8630 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
8631 add_AT_die_ref (stub
, DW_AT_signature
, type
);
8635 /* Otherwise, use a typedef with no name. */
8636 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
8637 add_AT_die_ref (stub
, DW_AT_type
, type
);
8646 /* DIE is a unit; look through all the DIE references to see if there are
8647 any external references to types, and if so, create local stubs for
8648 them which will be applied in build_abbrev_table. This is useful because
8649 references to local DIEs are smaller. */
8651 static external_ref_hash_type
*
8652 optimize_external_refs (dw_die_ref die
)
8654 external_ref_hash_type
*map
= new external_ref_hash_type (10);
8655 optimize_external_refs_1 (die
, map
);
8656 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
8660 /* The following 3 variables are temporaries that are computed only during the
8661 build_abbrev_table call and used and released during the following
8662 optimize_abbrev_table call. */
8664 /* First abbrev_id that can be optimized based on usage. */
8665 static unsigned int abbrev_opt_start
;
8667 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
8668 abbrev_id smaller than this, because they must be already sized
8669 during build_abbrev_table). */
8670 static unsigned int abbrev_opt_base_type_end
;
8672 /* Vector of usage counts during build_abbrev_table. Indexed by
8673 abbrev_id - abbrev_opt_start. */
8674 static vec
<unsigned int> abbrev_usage_count
;
8676 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
8677 static vec
<dw_die_ref
> sorted_abbrev_dies
;
8679 /* The format of each DIE (and its attribute value pairs) is encoded in an
8680 abbreviation table. This routine builds the abbreviation table and assigns
8681 a unique abbreviation id for each abbreviation entry. The children of each
8682 die are visited recursively. */
8685 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
8687 unsigned int abbrev_id
= 0;
8693 /* Scan the DIE references, and replace any that refer to
8694 DIEs from other CUs (i.e. those which are not marked) with
8695 the local stubs we built in optimize_external_refs. */
8696 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8697 if (AT_class (a
) == dw_val_class_die_ref
8698 && (c
= AT_ref (a
))->die_mark
== 0)
8700 struct external_ref
*ref_p
;
8701 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
8703 ref_p
= lookup_external_ref (extern_map
, c
);
8704 if (ref_p
->stub
&& ref_p
->stub
!= die
)
8705 change_AT_die_ref (a
, ref_p
->stub
);
8707 /* We aren't changing this reference, so mark it external. */
8708 set_AT_ref_external (a
, 1);
8711 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
8713 dw_attr_node
*die_a
, *abbrev_a
;
8719 if (abbrev
->die_tag
!= die
->die_tag
)
8721 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
8724 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
8727 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
8729 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
8730 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
8731 || (value_format (abbrev_a
) != value_format (die_a
)))
8741 if (abbrev_id
>= vec_safe_length (abbrev_die_table
))
8743 vec_safe_push (abbrev_die_table
, die
);
8744 if (abbrev_opt_start
)
8745 abbrev_usage_count
.safe_push (0);
8747 if (abbrev_opt_start
&& abbrev_id
>= abbrev_opt_start
)
8749 abbrev_usage_count
[abbrev_id
- abbrev_opt_start
]++;
8750 sorted_abbrev_dies
.safe_push (die
);
8753 die
->die_abbrev
= abbrev_id
;
8754 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
8757 /* Callback function for sorted_abbrev_dies vector sorting. We sort
8758 by die_abbrev's usage count, from the most commonly used
8759 abbreviation to the least. */
8762 die_abbrev_cmp (const void *p1
, const void *p2
)
8764 dw_die_ref die1
= *(const dw_die_ref
*) p1
;
8765 dw_die_ref die2
= *(const dw_die_ref
*) p2
;
8767 gcc_checking_assert (die1
->die_abbrev
>= abbrev_opt_start
);
8768 gcc_checking_assert (die2
->die_abbrev
>= abbrev_opt_start
);
8770 if (die1
->die_abbrev
>= abbrev_opt_base_type_end
8771 && die2
->die_abbrev
>= abbrev_opt_base_type_end
)
8773 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
8774 > abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
8776 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
8777 < abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
8781 /* Stabilize the sort. */
8782 if (die1
->die_abbrev
< die2
->die_abbrev
)
8784 if (die1
->die_abbrev
> die2
->die_abbrev
)
8790 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
8791 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
8792 into dw_val_class_const_implicit or
8793 dw_val_class_unsigned_const_implicit. */
8796 optimize_implicit_const (unsigned int first_id
, unsigned int end
,
8797 vec
<bool> &implicit_consts
)
8799 /* It never makes sense if there is just one DIE using the abbreviation. */
8800 if (end
< first_id
+ 2)
8805 dw_die_ref die
= sorted_abbrev_dies
[first_id
];
8806 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8807 if (implicit_consts
[ix
])
8809 enum dw_val_class new_class
= dw_val_class_none
;
8810 switch (AT_class (a
))
8812 case dw_val_class_unsigned_const
:
8813 if ((HOST_WIDE_INT
) AT_unsigned (a
) < 0)
8816 /* The .debug_abbrev section will grow by
8817 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
8818 in all the DIEs using that abbreviation. */
8819 if (constant_size (AT_unsigned (a
)) * (end
- first_id
)
8820 <= (unsigned) size_of_sleb128 (AT_unsigned (a
)))
8823 new_class
= dw_val_class_unsigned_const_implicit
;
8826 case dw_val_class_const
:
8827 new_class
= dw_val_class_const_implicit
;
8830 case dw_val_class_file
:
8831 new_class
= dw_val_class_file_implicit
;
8837 for (i
= first_id
; i
< end
; i
++)
8838 (*sorted_abbrev_dies
[i
]->die_attr
)[ix
].dw_attr_val
.val_class
8843 /* Attempt to optimize abbreviation table from abbrev_opt_start
8844 abbreviation above. */
8847 optimize_abbrev_table (void)
8849 if (abbrev_opt_start
8850 && vec_safe_length (abbrev_die_table
) > abbrev_opt_start
8851 && (dwarf_version
>= 5 || vec_safe_length (abbrev_die_table
) > 127))
8853 auto_vec
<bool, 32> implicit_consts
;
8854 sorted_abbrev_dies
.qsort (die_abbrev_cmp
);
8856 unsigned int abbrev_id
= abbrev_opt_start
- 1;
8857 unsigned int first_id
= ~0U;
8858 unsigned int last_abbrev_id
= 0;
8861 if (abbrev_opt_base_type_end
> abbrev_opt_start
)
8862 abbrev_id
= abbrev_opt_base_type_end
- 1;
8863 /* Reassign abbreviation ids from abbrev_opt_start above, so that
8864 most commonly used abbreviations come first. */
8865 FOR_EACH_VEC_ELT (sorted_abbrev_dies
, i
, die
)
8870 /* If calc_base_type_die_sizes has been called, the CU and
8871 base types after it can't be optimized, because we've already
8872 calculated their DIE offsets. We've sorted them first. */
8873 if (die
->die_abbrev
< abbrev_opt_base_type_end
)
8875 if (die
->die_abbrev
!= last_abbrev_id
)
8877 last_abbrev_id
= die
->die_abbrev
;
8878 if (dwarf_version
>= 5 && first_id
!= ~0U)
8879 optimize_implicit_const (first_id
, i
, implicit_consts
);
8881 (*abbrev_die_table
)[abbrev_id
] = die
;
8882 if (dwarf_version
>= 5)
8885 implicit_consts
.truncate (0);
8887 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8888 switch (AT_class (a
))
8890 case dw_val_class_const
:
8891 case dw_val_class_unsigned_const
:
8892 case dw_val_class_file
:
8893 implicit_consts
.safe_push (true);
8896 implicit_consts
.safe_push (false);
8901 else if (dwarf_version
>= 5)
8903 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8904 if (!implicit_consts
[ix
])
8908 dw_attr_node
*other_a
8909 = &(*(*abbrev_die_table
)[abbrev_id
]->die_attr
)[ix
];
8910 if (!dw_val_equal_p (&a
->dw_attr_val
,
8911 &other_a
->dw_attr_val
))
8912 implicit_consts
[ix
] = false;
8915 die
->die_abbrev
= abbrev_id
;
8917 gcc_assert (abbrev_id
== vec_safe_length (abbrev_die_table
) - 1);
8918 if (dwarf_version
>= 5 && first_id
!= ~0U)
8919 optimize_implicit_const (first_id
, i
, implicit_consts
);
8922 abbrev_opt_start
= 0;
8923 abbrev_opt_base_type_end
= 0;
8924 abbrev_usage_count
.release ();
8925 sorted_abbrev_dies
.release ();
8928 /* Return the power-of-two number of bytes necessary to represent VALUE. */
8931 constant_size (unsigned HOST_WIDE_INT value
)
8938 log
= floor_log2 (value
);
8941 log
= 1 << (floor_log2 (log
) + 1);
8946 /* Return the size of a DIE as it is represented in the
8947 .debug_info section. */
8949 static unsigned long
8950 size_of_die (dw_die_ref die
)
8952 unsigned long size
= 0;
8955 enum dwarf_form form
;
8957 size
+= size_of_uleb128 (die
->die_abbrev
);
8958 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8960 switch (AT_class (a
))
8962 case dw_val_class_addr
:
8963 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8965 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
8966 size
+= size_of_uleb128 (AT_index (a
));
8969 size
+= DWARF2_ADDR_SIZE
;
8971 case dw_val_class_offset
:
8972 size
+= DWARF_OFFSET_SIZE
;
8974 case dw_val_class_loc
:
8976 unsigned long lsize
= size_of_locs (AT_loc (a
));
8979 if (dwarf_version
>= 4)
8980 size
+= size_of_uleb128 (lsize
);
8982 size
+= constant_size (lsize
);
8986 case dw_val_class_loc_list
:
8987 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
8989 gcc_assert (AT_loc_list (a
)->num_assigned
);
8990 size
+= size_of_uleb128 (AT_loc_list (a
)->hash
);
8993 size
+= DWARF_OFFSET_SIZE
;
8995 case dw_val_class_range_list
:
8996 if (value_format (a
) == DW_FORM_rnglistx
)
8998 gcc_assert (rnglist_idx
);
8999 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9000 size
+= size_of_uleb128 (r
->idx
);
9003 size
+= DWARF_OFFSET_SIZE
;
9005 case dw_val_class_const
:
9006 size
+= size_of_sleb128 (AT_int (a
));
9008 case dw_val_class_unsigned_const
:
9010 int csize
= constant_size (AT_unsigned (a
));
9011 if (dwarf_version
== 3
9012 && a
->dw_attr
== DW_AT_data_member_location
9014 size
+= size_of_uleb128 (AT_unsigned (a
));
9019 case dw_val_class_const_implicit
:
9020 case dw_val_class_unsigned_const_implicit
:
9021 case dw_val_class_file_implicit
:
9022 /* These occupy no size in the DIE, just an extra sleb128 in
9025 case dw_val_class_const_double
:
9026 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
9027 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
9030 case dw_val_class_wide_int
:
9031 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9032 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
9033 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9034 * HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
9037 case dw_val_class_vec
:
9038 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
9039 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
9040 + a
->dw_attr_val
.v
.val_vec
.length
9041 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
9043 case dw_val_class_flag
:
9044 if (dwarf_version
>= 4)
9045 /* Currently all add_AT_flag calls pass in 1 as last argument,
9046 so DW_FORM_flag_present can be used. If that ever changes,
9047 we'll need to use DW_FORM_flag and have some optimization
9048 in build_abbrev_table that will change those to
9049 DW_FORM_flag_present if it is set to 1 in all DIEs using
9050 the same abbrev entry. */
9051 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9055 case dw_val_class_die_ref
:
9056 if (AT_ref_external (a
))
9058 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9059 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9060 is sized by target address length, whereas in DWARF3
9061 it's always sized as an offset. */
9062 if (use_debug_types
)
9063 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
9064 else if (dwarf_version
== 2)
9065 size
+= DWARF2_ADDR_SIZE
;
9067 size
+= DWARF_OFFSET_SIZE
;
9070 size
+= DWARF_OFFSET_SIZE
;
9072 case dw_val_class_fde_ref
:
9073 size
+= DWARF_OFFSET_SIZE
;
9075 case dw_val_class_lbl_id
:
9076 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9078 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9079 size
+= size_of_uleb128 (AT_index (a
));
9082 size
+= DWARF2_ADDR_SIZE
;
9084 case dw_val_class_lineptr
:
9085 case dw_val_class_macptr
:
9086 case dw_val_class_loclistsptr
:
9087 size
+= DWARF_OFFSET_SIZE
;
9089 case dw_val_class_str
:
9090 form
= AT_string_form (a
);
9091 if (form
== DW_FORM_strp
|| form
== DW_FORM_line_strp
)
9092 size
+= DWARF_OFFSET_SIZE
;
9093 else if (form
== DW_FORM_GNU_str_index
)
9094 size
+= size_of_uleb128 (AT_index (a
));
9096 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
9098 case dw_val_class_file
:
9099 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
9101 case dw_val_class_data8
:
9104 case dw_val_class_vms_delta
:
9105 size
+= DWARF_OFFSET_SIZE
;
9107 case dw_val_class_high_pc
:
9108 size
+= DWARF2_ADDR_SIZE
;
9110 case dw_val_class_discr_value
:
9111 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
9113 case dw_val_class_discr_list
:
9115 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
9117 /* This is a block, so we have the block length and then its
9119 size
+= constant_size (block_size
) + block_size
;
9130 /* Size the debugging information associated with a given DIE. Visits the
9131 DIE's children recursively. Updates the global variable next_die_offset, on
9132 each time through. Uses the current value of next_die_offset to update the
9133 die_offset field in each DIE. */
9136 calc_die_sizes (dw_die_ref die
)
9140 gcc_assert (die
->die_offset
== 0
9141 || (unsigned long int) die
->die_offset
== next_die_offset
);
9142 die
->die_offset
= next_die_offset
;
9143 next_die_offset
+= size_of_die (die
);
9145 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
9147 if (die
->die_child
!= NULL
)
9148 /* Count the null byte used to terminate sibling lists. */
9149 next_die_offset
+= 1;
9152 /* Size just the base type children at the start of the CU.
9153 This is needed because build_abbrev needs to size locs
9154 and sizing of type based stack ops needs to know die_offset
9155 values for the base types. */
9158 calc_base_type_die_sizes (void)
9160 unsigned long die_offset
= (dwarf_split_debug_info
9161 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9162 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
9164 dw_die_ref base_type
;
9165 #if ENABLE_ASSERT_CHECKING
9166 dw_die_ref prev
= comp_unit_die ()->die_child
;
9169 die_offset
+= size_of_die (comp_unit_die ());
9170 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
9172 #if ENABLE_ASSERT_CHECKING
9173 gcc_assert (base_type
->die_offset
== 0
9174 && prev
->die_sib
== base_type
9175 && base_type
->die_child
== NULL
9176 && base_type
->die_abbrev
);
9179 if (abbrev_opt_start
9180 && base_type
->die_abbrev
>= abbrev_opt_base_type_end
)
9181 abbrev_opt_base_type_end
= base_type
->die_abbrev
+ 1;
9182 base_type
->die_offset
= die_offset
;
9183 die_offset
+= size_of_die (base_type
);
9187 /* Set the marks for a die and its children. We do this so
9188 that we know whether or not a reference needs to use FORM_ref_addr; only
9189 DIEs in the same CU will be marked. We used to clear out the offset
9190 and use that as the flag, but ran into ordering problems. */
9193 mark_dies (dw_die_ref die
)
9197 gcc_assert (!die
->die_mark
);
9200 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
9203 /* Clear the marks for a die and its children. */
9206 unmark_dies (dw_die_ref die
)
9210 if (! use_debug_types
)
9211 gcc_assert (die
->die_mark
);
9214 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
9217 /* Clear the marks for a die, its children and referred dies. */
9220 unmark_all_dies (dw_die_ref die
)
9230 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
9232 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9233 if (AT_class (a
) == dw_val_class_die_ref
)
9234 unmark_all_dies (AT_ref (a
));
9237 /* Calculate if the entry should appear in the final output file. It may be
9238 from a pruned a type. */
9241 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
9243 /* By limiting gnu pubnames to definitions only, gold can generate a
9244 gdb index without entries for declarations, which don't include
9245 enough information to be useful. */
9246 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
9249 if (table
== pubname_table
)
9251 /* Enumerator names are part of the pubname table, but the
9252 parent DW_TAG_enumeration_type die may have been pruned.
9253 Don't output them if that is the case. */
9254 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
9255 (p
->die
->die_parent
== NULL
9256 || !p
->die
->die_parent
->die_perennial_p
))
9259 /* Everything else in the pubname table is included. */
9263 /* The pubtypes table shouldn't include types that have been
9265 return (p
->die
->die_offset
!= 0
9266 || !flag_eliminate_unused_debug_types
);
9269 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9270 generated for the compilation unit. */
9272 static unsigned long
9273 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9278 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
9280 size
= DWARF_PUBNAMES_HEADER_SIZE
;
9281 FOR_EACH_VEC_ELT (*names
, i
, p
)
9282 if (include_pubname_in_output (names
, p
))
9283 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
9285 size
+= DWARF_OFFSET_SIZE
;
9289 /* Return the size of the information in the .debug_aranges section. */
9291 static unsigned long
9292 size_of_aranges (void)
9296 size
= DWARF_ARANGES_HEADER_SIZE
;
9298 /* Count the address/length pair for this compilation unit. */
9299 if (text_section_used
)
9300 size
+= 2 * DWARF2_ADDR_SIZE
;
9301 if (cold_text_section_used
)
9302 size
+= 2 * DWARF2_ADDR_SIZE
;
9303 if (have_multiple_function_sections
)
9308 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9310 if (DECL_IGNORED_P (fde
->decl
))
9312 if (!fde
->in_std_section
)
9313 size
+= 2 * DWARF2_ADDR_SIZE
;
9314 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9315 size
+= 2 * DWARF2_ADDR_SIZE
;
9319 /* Count the two zero words used to terminated the address range table. */
9320 size
+= 2 * DWARF2_ADDR_SIZE
;
9324 /* Select the encoding of an attribute value. */
9326 static enum dwarf_form
9327 value_format (dw_attr_node
*a
)
9329 switch (AT_class (a
))
9331 case dw_val_class_addr
:
9332 /* Only very few attributes allow DW_FORM_addr. */
9337 case DW_AT_entry_pc
:
9338 case DW_AT_trampoline
:
9339 return (AT_index (a
) == NOT_INDEXED
9340 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
9344 switch (DWARF2_ADDR_SIZE
)
9347 return DW_FORM_data1
;
9349 return DW_FORM_data2
;
9351 return DW_FORM_data4
;
9353 return DW_FORM_data8
;
9357 case dw_val_class_loc_list
:
9358 if (dwarf_split_debug_info
9359 && dwarf_version
>= 5
9360 && AT_loc_list (a
)->num_assigned
)
9361 return DW_FORM_loclistx
;
9363 case dw_val_class_range_list
:
9364 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9365 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9366 care about sizes of .debug* sections in shared libraries and
9367 executables and don't take into account relocations that affect just
9368 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9369 table in the .debug_rnglists section. */
9370 if (dwarf_split_debug_info
9371 && dwarf_version
>= 5
9372 && AT_class (a
) == dw_val_class_range_list
9374 && a
->dw_attr_val
.val_entry
!= RELOCATED_OFFSET
)
9375 return DW_FORM_rnglistx
;
9376 if (dwarf_version
>= 4)
9377 return DW_FORM_sec_offset
;
9379 case dw_val_class_vms_delta
:
9380 case dw_val_class_offset
:
9381 switch (DWARF_OFFSET_SIZE
)
9384 return DW_FORM_data4
;
9386 return DW_FORM_data8
;
9390 case dw_val_class_loc
:
9391 if (dwarf_version
>= 4)
9392 return DW_FORM_exprloc
;
9393 switch (constant_size (size_of_locs (AT_loc (a
))))
9396 return DW_FORM_block1
;
9398 return DW_FORM_block2
;
9400 return DW_FORM_block4
;
9404 case dw_val_class_const
:
9405 return DW_FORM_sdata
;
9406 case dw_val_class_unsigned_const
:
9407 switch (constant_size (AT_unsigned (a
)))
9410 return DW_FORM_data1
;
9412 return DW_FORM_data2
;
9414 /* In DWARF3 DW_AT_data_member_location with
9415 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9416 constant, so we need to use DW_FORM_udata if we need
9417 a large constant. */
9418 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9419 return DW_FORM_udata
;
9420 return DW_FORM_data4
;
9422 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9423 return DW_FORM_udata
;
9424 return DW_FORM_data8
;
9428 case dw_val_class_const_implicit
:
9429 case dw_val_class_unsigned_const_implicit
:
9430 case dw_val_class_file_implicit
:
9431 return DW_FORM_implicit_const
;
9432 case dw_val_class_const_double
:
9433 switch (HOST_BITS_PER_WIDE_INT
)
9436 return DW_FORM_data2
;
9438 return DW_FORM_data4
;
9440 return DW_FORM_data8
;
9442 if (dwarf_version
>= 5)
9443 return DW_FORM_data16
;
9446 return DW_FORM_block1
;
9448 case dw_val_class_wide_int
:
9449 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
9452 return DW_FORM_data1
;
9454 return DW_FORM_data2
;
9456 return DW_FORM_data4
;
9458 return DW_FORM_data8
;
9460 if (dwarf_version
>= 5)
9461 return DW_FORM_data16
;
9464 return DW_FORM_block1
;
9466 case dw_val_class_vec
:
9467 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
9468 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
9471 return DW_FORM_block1
;
9473 return DW_FORM_block2
;
9475 return DW_FORM_block4
;
9479 case dw_val_class_flag
:
9480 if (dwarf_version
>= 4)
9482 /* Currently all add_AT_flag calls pass in 1 as last argument,
9483 so DW_FORM_flag_present can be used. If that ever changes,
9484 we'll need to use DW_FORM_flag and have some optimization
9485 in build_abbrev_table that will change those to
9486 DW_FORM_flag_present if it is set to 1 in all DIEs using
9487 the same abbrev entry. */
9488 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9489 return DW_FORM_flag_present
;
9491 return DW_FORM_flag
;
9492 case dw_val_class_die_ref
:
9493 if (AT_ref_external (a
))
9494 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
9497 case dw_val_class_fde_ref
:
9498 return DW_FORM_data
;
9499 case dw_val_class_lbl_id
:
9500 return (AT_index (a
) == NOT_INDEXED
9501 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
9502 case dw_val_class_lineptr
:
9503 case dw_val_class_macptr
:
9504 case dw_val_class_loclistsptr
:
9505 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
9506 case dw_val_class_str
:
9507 return AT_string_form (a
);
9508 case dw_val_class_file
:
9509 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
9512 return DW_FORM_data1
;
9514 return DW_FORM_data2
;
9516 return DW_FORM_data4
;
9521 case dw_val_class_data8
:
9522 return DW_FORM_data8
;
9524 case dw_val_class_high_pc
:
9525 switch (DWARF2_ADDR_SIZE
)
9528 return DW_FORM_data1
;
9530 return DW_FORM_data2
;
9532 return DW_FORM_data4
;
9534 return DW_FORM_data8
;
9539 case dw_val_class_discr_value
:
9540 return (a
->dw_attr_val
.v
.val_discr_value
.pos
9543 case dw_val_class_discr_list
:
9544 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
9547 return DW_FORM_block1
;
9549 return DW_FORM_block2
;
9551 return DW_FORM_block4
;
9561 /* Output the encoding of an attribute value. */
9564 output_value_format (dw_attr_node
*a
)
9566 enum dwarf_form form
= value_format (a
);
9568 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
9571 /* Given a die and id, produce the appropriate abbreviations. */
9574 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
9577 dw_attr_node
*a_attr
;
9579 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
9580 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
9581 dwarf_tag_name (abbrev
->die_tag
));
9583 if (abbrev
->die_child
!= NULL
)
9584 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
9586 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
9588 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
9590 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
9591 dwarf_attr_name (a_attr
->dw_attr
));
9592 output_value_format (a_attr
);
9593 if (value_format (a_attr
) == DW_FORM_implicit_const
)
9595 if (AT_class (a_attr
) == dw_val_class_file_implicit
)
9597 int f
= maybe_emit_file (a_attr
->dw_attr_val
.v
.val_file
);
9598 const char *filename
= a_attr
->dw_attr_val
.v
.val_file
->filename
;
9599 dw2_asm_output_data_sleb128 (f
, "(%s)", filename
);
9602 dw2_asm_output_data_sleb128 (a_attr
->dw_attr_val
.v
.val_int
, NULL
);
9606 dw2_asm_output_data (1, 0, NULL
);
9607 dw2_asm_output_data (1, 0, NULL
);
9611 /* Output the .debug_abbrev section which defines the DIE abbreviation
9615 output_abbrev_section (void)
9617 unsigned int abbrev_id
;
9620 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9622 output_die_abbrevs (abbrev_id
, abbrev
);
9624 /* Terminate the table. */
9625 dw2_asm_output_data (1, 0, NULL
);
9628 /* Output a symbol we can use to refer to this DIE from another CU. */
9631 output_die_symbol (dw_die_ref die
)
9633 const char *sym
= die
->die_id
.die_symbol
;
9635 gcc_assert (!die
->comdat_type_p
);
9640 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
9641 /* We make these global, not weak; if the target doesn't support
9642 .linkonce, it doesn't support combining the sections, so debugging
9644 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
9646 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
9649 /* Return a new location list, given the begin and end range, and the
9652 static inline dw_loc_list_ref
9653 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
9654 const char *section
)
9656 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
9658 retlist
->begin
= begin
;
9659 retlist
->begin_entry
= NULL
;
9661 retlist
->expr
= expr
;
9662 retlist
->section
= section
;
9667 /* Generate a new internal symbol for this location list node, if it
9668 hasn't got one yet. */
9671 gen_llsym (dw_loc_list_ref list
)
9673 gcc_assert (!list
->ll_symbol
);
9674 list
->ll_symbol
= gen_internal_sym ("LLST");
9677 /* Output the location list given to us. */
9680 output_loc_list (dw_loc_list_ref list_head
)
9682 if (list_head
->emitted
)
9684 list_head
->emitted
= true;
9686 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
9688 dw_loc_list_ref curr
= list_head
;
9689 const char *last_section
= NULL
;
9690 const char *base_label
= NULL
;
9692 /* Walk the location list, and output each range + expression. */
9693 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
9696 /* Don't output an entry that starts and ends at the same address. */
9697 if (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
)
9699 size
= size_of_locs (curr
->expr
);
9700 /* If the expression is too large, drop it on the floor. We could
9701 perhaps put it into DW_TAG_dwarf_procedure and refer to that
9702 in the expression, but >= 64KB expressions for a single value
9703 in a single range are unlikely very useful. */
9704 if (dwarf_version
< 5 && size
> 0xffff)
9706 if (dwarf_version
>= 5)
9708 if (dwarf_split_debug_info
)
9710 /* For -gsplit-dwarf, emit DW_LLE_starx_length, which has
9711 uleb128 index into .debug_addr and uleb128 length. */
9712 dw2_asm_output_data (1, DW_LLE_startx_length
,
9713 "DW_LLE_startx_length (%s)",
9714 list_head
->ll_symbol
);
9715 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
9716 "Location list range start index "
9717 "(%s)", curr
->begin
);
9718 /* FIXME: This will ICE ifndef HAVE_AS_LEB128.
9719 For that case we probably need to emit DW_LLE_startx_endx,
9720 but we'd need 2 .debug_addr entries rather than just one. */
9721 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
9722 "Location list length (%s)",
9723 list_head
->ll_symbol
);
9725 else if (!have_multiple_function_sections
&& HAVE_AS_LEB128
)
9727 /* If all code is in .text section, the base address is
9728 already provided by the CU attributes. Use
9729 DW_LLE_offset_pair where both addresses are uleb128 encoded
9730 offsets against that base. */
9731 dw2_asm_output_data (1, DW_LLE_offset_pair
,
9732 "DW_LLE_offset_pair (%s)",
9733 list_head
->ll_symbol
);
9734 dw2_asm_output_delta_uleb128 (curr
->begin
, curr
->section
,
9735 "Location list begin address (%s)",
9736 list_head
->ll_symbol
);
9737 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->section
,
9738 "Location list end address (%s)",
9739 list_head
->ll_symbol
);
9741 else if (HAVE_AS_LEB128
)
9743 /* Otherwise, find out how many consecutive entries could share
9744 the same base entry. If just one, emit DW_LLE_start_length,
9745 otherwise emit DW_LLE_base_address for the base address
9746 followed by a series of DW_LLE_offset_pair. */
9747 if (last_section
== NULL
|| curr
->section
!= last_section
)
9749 dw_loc_list_ref curr2
;
9750 for (curr2
= curr
->dw_loc_next
; curr2
!= NULL
;
9751 curr2
= curr2
->dw_loc_next
)
9753 if (strcmp (curr2
->begin
, curr2
->end
) == 0
9758 if (curr2
== NULL
|| curr
->section
!= curr2
->section
)
9759 last_section
= NULL
;
9762 last_section
= curr
->section
;
9763 base_label
= curr
->begin
;
9764 dw2_asm_output_data (1, DW_LLE_base_address
,
9765 "DW_LLE_base_address (%s)",
9766 list_head
->ll_symbol
);
9767 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, base_label
,
9768 "Base address (%s)",
9769 list_head
->ll_symbol
);
9772 /* Only one entry with the same base address. Use
9773 DW_LLE_start_length with absolute address and uleb128
9775 if (last_section
== NULL
)
9777 dw2_asm_output_data (1, DW_LLE_start_length
,
9778 "DW_LLE_start_length (%s)",
9779 list_head
->ll_symbol
);
9780 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
9781 "Location list begin address (%s)",
9782 list_head
->ll_symbol
);
9783 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
9784 "Location list length "
9785 "(%s)", list_head
->ll_symbol
);
9787 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
9788 DW_LLE_base_address. */
9791 dw2_asm_output_data (1, DW_LLE_offset_pair
,
9792 "DW_LLE_offset_pair (%s)",
9793 list_head
->ll_symbol
);
9794 dw2_asm_output_delta_uleb128 (curr
->begin
, base_label
,
9795 "Location list begin address "
9796 "(%s)", list_head
->ll_symbol
);
9797 dw2_asm_output_delta_uleb128 (curr
->end
, base_label
,
9798 "Location list end address "
9799 "(%s)", list_head
->ll_symbol
);
9802 /* The assembler does not support .uleb128 directive. Emit
9803 DW_LLE_start_end with a pair of absolute addresses. */
9806 dw2_asm_output_data (1, DW_LLE_start_end
,
9807 "DW_LLE_start_end (%s)",
9808 list_head
->ll_symbol
);
9809 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
9810 "Location list begin address (%s)",
9811 list_head
->ll_symbol
);
9812 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
9813 "Location list end address (%s)",
9814 list_head
->ll_symbol
);
9817 else if (dwarf_split_debug_info
)
9819 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
9820 and 4 byte length. */
9821 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
9822 "Location list start/length entry (%s)",
9823 list_head
->ll_symbol
);
9824 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
9825 "Location list range start index (%s)",
9827 /* The length field is 4 bytes. If we ever need to support
9828 an 8-byte length, we can add a new DW_LLE code or fall back
9829 to DW_LLE_GNU_start_end_entry. */
9830 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
9831 "Location list range length (%s)",
9832 list_head
->ll_symbol
);
9834 else if (!have_multiple_function_sections
)
9836 /* Pair of relative addresses against start of text section. */
9837 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
9838 "Location list begin address (%s)",
9839 list_head
->ll_symbol
);
9840 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
9841 "Location list end address (%s)",
9842 list_head
->ll_symbol
);
9846 /* Pair of absolute addresses. */
9847 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
9848 "Location list begin address (%s)",
9849 list_head
->ll_symbol
);
9850 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
9851 "Location list end address (%s)",
9852 list_head
->ll_symbol
);
9855 /* Output the block length for this list of location operations. */
9856 if (dwarf_version
>= 5)
9857 dw2_asm_output_data_uleb128 (size
, "Location expression size");
9860 gcc_assert (size
<= 0xffff);
9861 dw2_asm_output_data (2, size
, "Location expression size");
9864 output_loc_sequence (curr
->expr
, -1);
9867 /* And finally list termination. */
9868 if (dwarf_version
>= 5)
9869 dw2_asm_output_data (1, DW_LLE_end_of_list
,
9870 "DW_LLE_end_of_list (%s)", list_head
->ll_symbol
);
9871 else if (dwarf_split_debug_info
)
9872 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
9873 "Location list terminator (%s)",
9874 list_head
->ll_symbol
);
9877 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
9878 "Location list terminator begin (%s)",
9879 list_head
->ll_symbol
);
9880 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
9881 "Location list terminator end (%s)",
9882 list_head
->ll_symbol
);
9886 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
9887 section. Emit a relocated reference if val_entry is NULL, otherwise,
9888 emit an indirect reference. */
9891 output_range_list_offset (dw_attr_node
*a
)
9893 const char *name
= dwarf_attr_name (a
->dw_attr
);
9895 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
9897 if (dwarf_version
>= 5)
9899 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9900 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, r
->label
,
9901 debug_ranges_section
, "%s", name
);
9905 char *p
= strchr (ranges_section_label
, '\0');
9906 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
9907 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
);
9908 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
9909 debug_ranges_section
, "%s", name
);
9913 else if (dwarf_version
>= 5)
9915 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9916 gcc_assert (rnglist_idx
);
9917 dw2_asm_output_data_uleb128 (r
->idx
, "%s", name
);
9920 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9921 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
,
9922 "%s (offset from %s)", name
, ranges_section_label
);
9925 /* Output the offset into the debug_loc section. */
9928 output_loc_list_offset (dw_attr_node
*a
)
9930 char *sym
= AT_loc_list (a
)->ll_symbol
;
9933 if (!dwarf_split_debug_info
)
9934 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
9935 "%s", dwarf_attr_name (a
->dw_attr
));
9936 else if (dwarf_version
>= 5)
9938 gcc_assert (AT_loc_list (a
)->num_assigned
);
9939 dw2_asm_output_data_uleb128 (AT_loc_list (a
)->hash
, "%s (%s)",
9940 dwarf_attr_name (a
->dw_attr
),
9944 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
9945 "%s", dwarf_attr_name (a
->dw_attr
));
9948 /* Output an attribute's index or value appropriately. */
9951 output_attr_index_or_value (dw_attr_node
*a
)
9953 const char *name
= dwarf_attr_name (a
->dw_attr
);
9955 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9957 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
9960 switch (AT_class (a
))
9962 case dw_val_class_addr
:
9963 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
9965 case dw_val_class_high_pc
:
9966 case dw_val_class_lbl_id
:
9967 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
9974 /* Output a type signature. */
9977 output_signature (const char *sig
, const char *name
)
9981 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9982 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
9985 /* Output a discriminant value. */
9988 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
9990 if (discr_value
->pos
)
9991 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
9993 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
9996 /* Output the DIE and its attributes. Called recursively to generate
9997 the definitions of each child DIE. */
10000 output_die (dw_die_ref die
)
10004 unsigned long size
;
10007 /* If someone in another CU might refer to us, set up a symbol for
10008 them to point to. */
10009 if (! die
->comdat_type_p
&& die
->die_id
.die_symbol
10010 /* Don't output the symbol twice. For LTO we want the label
10011 on the section beginning, not on the actual DIE. */
10012 && ((!flag_generate_lto
&& !flag_generate_offload
)
10013 || die
->die_tag
!= DW_TAG_compile_unit
))
10014 output_die_symbol (die
);
10016 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10017 (unsigned long)die
->die_offset
,
10018 dwarf_tag_name (die
->die_tag
));
10020 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
10022 const char *name
= dwarf_attr_name (a
->dw_attr
);
10024 switch (AT_class (a
))
10026 case dw_val_class_addr
:
10027 output_attr_index_or_value (a
);
10030 case dw_val_class_offset
:
10031 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
10035 case dw_val_class_range_list
:
10036 output_range_list_offset (a
);
10039 case dw_val_class_loc
:
10040 size
= size_of_locs (AT_loc (a
));
10042 /* Output the block length for this list of location operations. */
10043 if (dwarf_version
>= 4)
10044 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10046 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10048 output_loc_sequence (AT_loc (a
), -1);
10051 case dw_val_class_const
:
10052 /* ??? It would be slightly more efficient to use a scheme like is
10053 used for unsigned constants below, but gdb 4.x does not sign
10054 extend. Gdb 5.x does sign extend. */
10055 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10058 case dw_val_class_unsigned_const
:
10060 int csize
= constant_size (AT_unsigned (a
));
10061 if (dwarf_version
== 3
10062 && a
->dw_attr
== DW_AT_data_member_location
10064 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
10066 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
10070 case dw_val_class_const_implicit
:
10071 if (flag_debug_asm
)
10072 fprintf (asm_out_file
, "\t\t\t%s %s ("
10073 HOST_WIDE_INT_PRINT_DEC
")\n",
10074 ASM_COMMENT_START
, name
, AT_int (a
));
10077 case dw_val_class_unsigned_const_implicit
:
10078 if (flag_debug_asm
)
10079 fprintf (asm_out_file
, "\t\t\t%s %s ("
10080 HOST_WIDE_INT_PRINT_HEX
")\n",
10081 ASM_COMMENT_START
, name
, AT_unsigned (a
));
10084 case dw_val_class_const_double
:
10086 unsigned HOST_WIDE_INT first
, second
;
10088 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
10089 dw2_asm_output_data (1,
10090 HOST_BITS_PER_DOUBLE_INT
10091 / HOST_BITS_PER_CHAR
,
10094 if (WORDS_BIG_ENDIAN
)
10096 first
= a
->dw_attr_val
.v
.val_double
.high
;
10097 second
= a
->dw_attr_val
.v
.val_double
.low
;
10101 first
= a
->dw_attr_val
.v
.val_double
.low
;
10102 second
= a
->dw_attr_val
.v
.val_double
.high
;
10105 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10106 first
, "%s", name
);
10107 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10112 case dw_val_class_wide_int
:
10115 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
10116 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10117 if (len
* HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
10118 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
)
10121 if (WORDS_BIG_ENDIAN
)
10122 for (i
= len
- 1; i
>= 0; --i
)
10124 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10129 for (i
= 0; i
< len
; ++i
)
10131 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10138 case dw_val_class_vec
:
10140 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10141 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10145 dw2_asm_output_data (constant_size (len
* elt_size
),
10146 len
* elt_size
, "%s", name
);
10147 if (elt_size
> sizeof (HOST_WIDE_INT
))
10152 for (i
= 0, p
= (unsigned char *) a
->dw_attr_val
.v
.val_vec
.array
;
10154 i
++, p
+= elt_size
)
10155 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10156 "fp or vector constant word %u", i
);
10160 case dw_val_class_flag
:
10161 if (dwarf_version
>= 4)
10163 /* Currently all add_AT_flag calls pass in 1 as last argument,
10164 so DW_FORM_flag_present can be used. If that ever changes,
10165 we'll need to use DW_FORM_flag and have some optimization
10166 in build_abbrev_table that will change those to
10167 DW_FORM_flag_present if it is set to 1 in all DIEs using
10168 the same abbrev entry. */
10169 gcc_assert (AT_flag (a
) == 1);
10170 if (flag_debug_asm
)
10171 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10172 ASM_COMMENT_START
, name
);
10175 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10178 case dw_val_class_loc_list
:
10179 output_loc_list_offset (a
);
10182 case dw_val_class_die_ref
:
10183 if (AT_ref_external (a
))
10185 if (AT_ref (a
)->comdat_type_p
)
10187 comdat_type_node
*type_node
10188 = AT_ref (a
)->die_id
.die_type_node
;
10190 gcc_assert (type_node
);
10191 output_signature (type_node
->signature
, name
);
10195 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
10199 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10200 length, whereas in DWARF3 it's always sized as an
10202 if (dwarf_version
== 2)
10203 size
= DWARF2_ADDR_SIZE
;
10205 size
= DWARF_OFFSET_SIZE
;
10206 /* ??? We cannot unconditionally output die_offset if
10207 non-zero - others might create references to those
10209 And we do not clear its DIE offset after outputting it
10210 (and the label refers to the actual DIEs, not the
10211 DWARF CU unit header which is when using label + offset
10212 would be the correct thing to do).
10213 ??? This is the reason for the with_offset flag. */
10214 if (AT_ref (a
)->with_offset
)
10215 dw2_asm_output_offset (size
, sym
, AT_ref (a
)->die_offset
,
10216 debug_info_section
, "%s", name
);
10218 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
10224 gcc_assert (AT_ref (a
)->die_offset
);
10225 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
10230 case dw_val_class_fde_ref
:
10232 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
10234 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
10235 a
->dw_attr_val
.v
.val_fde_index
* 2);
10236 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
10241 case dw_val_class_vms_delta
:
10242 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
10243 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
10244 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10247 dw2_asm_output_delta (DWARF_OFFSET_SIZE
,
10248 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10253 case dw_val_class_lbl_id
:
10254 output_attr_index_or_value (a
);
10257 case dw_val_class_lineptr
:
10258 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10259 debug_line_section
, "%s", name
);
10262 case dw_val_class_macptr
:
10263 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10264 debug_macinfo_section
, "%s", name
);
10267 case dw_val_class_loclistsptr
:
10268 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10269 debug_loc_section
, "%s", name
);
10272 case dw_val_class_str
:
10273 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
10274 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10275 a
->dw_attr_val
.v
.val_str
->label
,
10277 "%s: \"%s\"", name
, AT_string (a
));
10278 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_line_strp
)
10279 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10280 a
->dw_attr_val
.v
.val_str
->label
,
10281 debug_line_str_section
,
10282 "%s: \"%s\"", name
, AT_string (a
));
10283 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_GNU_str_index
)
10284 dw2_asm_output_data_uleb128 (AT_index (a
),
10285 "%s: \"%s\"", name
, AT_string (a
));
10287 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
10290 case dw_val_class_file
:
10292 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
10294 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
10295 a
->dw_attr_val
.v
.val_file
->filename
);
10299 case dw_val_class_file_implicit
:
10300 if (flag_debug_asm
)
10301 fprintf (asm_out_file
, "\t\t\t%s %s (%d, %s)\n",
10302 ASM_COMMENT_START
, name
,
10303 maybe_emit_file (a
->dw_attr_val
.v
.val_file
),
10304 a
->dw_attr_val
.v
.val_file
->filename
);
10307 case dw_val_class_data8
:
10311 for (i
= 0; i
< 8; i
++)
10312 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
10313 i
== 0 ? "%s" : NULL
, name
);
10317 case dw_val_class_high_pc
:
10318 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
10319 get_AT_low_pc (die
), "DW_AT_high_pc");
10322 case dw_val_class_discr_value
:
10323 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
10326 case dw_val_class_discr_list
:
10328 dw_discr_list_ref list
= AT_discr_list (a
);
10329 const int size
= size_of_discr_list (list
);
10331 /* This is a block, so output its length first. */
10332 dw2_asm_output_data (constant_size (size
), size
,
10333 "%s: block size", name
);
10335 for (; list
!= NULL
; list
= list
->dw_discr_next
)
10337 /* One byte for the discriminant value descriptor, and then as
10338 many LEB128 numbers as required. */
10339 if (list
->dw_discr_range
)
10340 dw2_asm_output_data (1, DW_DSC_range
,
10341 "%s: DW_DSC_range", name
);
10343 dw2_asm_output_data (1, DW_DSC_label
,
10344 "%s: DW_DSC_label", name
);
10346 output_discr_value (&list
->dw_discr_lower_bound
, name
);
10347 if (list
->dw_discr_range
)
10348 output_discr_value (&list
->dw_discr_upper_bound
, name
);
10354 gcc_unreachable ();
10358 FOR_EACH_CHILD (die
, c
, output_die (c
));
10360 /* Add null byte to terminate sibling list. */
10361 if (die
->die_child
!= NULL
)
10362 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
10363 (unsigned long) die
->die_offset
);
10366 /* Output the compilation unit that appears at the beginning of the
10367 .debug_info section, and precedes the DIE descriptions. */
10370 output_compilation_unit_header (enum dwarf_unit_type ut
)
10372 if (!XCOFF_DEBUGGING_INFO
)
10374 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10375 dw2_asm_output_data (4, 0xffffffff,
10376 "Initial length escape value indicating 64-bit DWARF extension");
10377 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10378 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
10379 "Length of Compilation Unit Info");
10382 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
10383 if (dwarf_version
>= 5)
10388 case DW_UT_compile
: name
= "DW_UT_compile"; break;
10389 case DW_UT_type
: name
= "DW_UT_type"; break;
10390 case DW_UT_split_compile
: name
= "DW_UT_split_compile"; break;
10391 case DW_UT_split_type
: name
= "DW_UT_split_type"; break;
10392 default: gcc_unreachable ();
10394 dw2_asm_output_data (1, ut
, "%s", name
);
10395 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10397 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
10398 debug_abbrev_section
,
10399 "Offset Into Abbrev. Section");
10400 if (dwarf_version
< 5)
10401 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10404 /* Output the compilation unit DIE and its children. */
10407 output_comp_unit (dw_die_ref die
, int output_if_empty
,
10408 const unsigned char *dwo_id
)
10410 const char *secname
, *oldsym
;
10413 /* Unless we are outputting main CU, we may throw away empty ones. */
10414 if (!output_if_empty
&& die
->die_child
== NULL
)
10417 /* Even if there are no children of this DIE, we must output the information
10418 about the compilation unit. Otherwise, on an empty translation unit, we
10419 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
10420 will then complain when examining the file. First mark all the DIEs in
10421 this CU so we know which get local refs. */
10424 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
10426 /* For now, optimize only the main CU, in order to optimize the rest
10427 we'd need to see all of them earlier. Leave the rest for post-linking
10429 if (die
== comp_unit_die ())
10430 abbrev_opt_start
= vec_safe_length (abbrev_die_table
);
10432 build_abbrev_table (die
, extern_map
);
10434 optimize_abbrev_table ();
10438 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10439 next_die_offset
= (dwo_id
10440 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
10441 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
10442 calc_die_sizes (die
);
10444 oldsym
= die
->die_id
.die_symbol
;
10445 if (oldsym
&& die
->comdat_type_p
)
10447 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
10449 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
10451 die
->die_id
.die_symbol
= NULL
;
10452 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
10456 switch_to_section (debug_info_section
);
10457 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
10458 info_section_emitted
= true;
10461 /* For LTO cross unit DIE refs we want a symbol on the start of the
10462 debuginfo section, not on the CU DIE. */
10463 if ((flag_generate_lto
|| flag_generate_offload
) && oldsym
)
10465 /* ??? No way to get visibility assembled without a decl. */
10466 tree decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
10467 get_identifier (oldsym
), char_type_node
);
10468 TREE_PUBLIC (decl
) = true;
10469 TREE_STATIC (decl
) = true;
10470 DECL_ARTIFICIAL (decl
) = true;
10471 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
10472 DECL_VISIBILITY_SPECIFIED (decl
) = true;
10473 targetm
.asm_out
.assemble_visibility (decl
, VISIBILITY_HIDDEN
);
10474 #ifdef ASM_WEAKEN_LABEL
10475 /* We prefer a .weak because that handles duplicates from duplicate
10476 archive members in a graceful way. */
10477 ASM_WEAKEN_LABEL (asm_out_file
, oldsym
);
10479 targetm
.asm_out
.globalize_label (asm_out_file
, oldsym
);
10481 ASM_OUTPUT_LABEL (asm_out_file
, oldsym
);
10484 /* Output debugging information. */
10485 output_compilation_unit_header (dwo_id
10486 ? DW_UT_split_compile
: DW_UT_compile
);
10487 if (dwarf_version
>= 5)
10489 if (dwo_id
!= NULL
)
10490 for (int i
= 0; i
< 8; i
++)
10491 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
10495 /* Leave the marks on the main CU, so we can check them in
10496 output_pubnames. */
10500 die
->die_id
.die_symbol
= oldsym
;
10504 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
10505 and .debug_pubtypes. This is configured per-target, but can be
10506 overridden by the -gpubnames or -gno-pubnames options. */
10509 want_pubnames (void)
10511 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
10513 if (debug_generate_pub_sections
!= -1)
10514 return debug_generate_pub_sections
;
10515 return targetm
.want_debug_pub_sections
;
10518 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
10521 add_AT_pubnames (dw_die_ref die
)
10523 if (want_pubnames ())
10524 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
10527 /* Add a string attribute value to a skeleton DIE. */
10530 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
10534 struct indirect_string_node
*node
;
10536 if (! skeleton_debug_str_hash
)
10537 skeleton_debug_str_hash
10538 = hash_table
<indirect_string_hasher
>::create_ggc (10);
10540 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
10541 find_string_form (node
);
10542 if (node
->form
== DW_FORM_GNU_str_index
)
10543 node
->form
= DW_FORM_strp
;
10545 attr
.dw_attr
= attr_kind
;
10546 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
10547 attr
.dw_attr_val
.val_entry
= NULL
;
10548 attr
.dw_attr_val
.v
.val_str
= node
;
10549 add_dwarf_attr (die
, &attr
);
10552 /* Helper function to generate top-level dies for skeleton debug_info and
10556 add_top_level_skeleton_die_attrs (dw_die_ref die
)
10558 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
10559 const char *comp_dir
= comp_dir_string ();
10561 add_skeleton_AT_string (die
, dwarf_AT (DW_AT_dwo_name
), dwo_file_name
);
10562 if (comp_dir
!= NULL
)
10563 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
10564 add_AT_pubnames (die
);
10565 add_AT_lineptr (die
, DW_AT_GNU_addr_base
, debug_addr_section_label
);
10568 /* Output skeleton debug sections that point to the dwo file. */
10571 output_skeleton_debug_sections (dw_die_ref comp_unit
,
10572 const unsigned char *dwo_id
)
10574 /* These attributes will be found in the full debug_info section. */
10575 remove_AT (comp_unit
, DW_AT_producer
);
10576 remove_AT (comp_unit
, DW_AT_language
);
10578 switch_to_section (debug_skeleton_info_section
);
10579 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
10581 /* Produce the skeleton compilation-unit header. This one differs enough from
10582 a normal CU header that it's better not to call output_compilation_unit
10584 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10585 dw2_asm_output_data (4, 0xffffffff,
10586 "Initial length escape value indicating 64-bit "
10587 "DWARF extension");
10589 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10590 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
10591 - DWARF_INITIAL_LENGTH_SIZE
10592 + size_of_die (comp_unit
),
10593 "Length of Compilation Unit Info");
10594 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
10595 if (dwarf_version
>= 5)
10597 dw2_asm_output_data (1, DW_UT_skeleton
, "DW_UT_skeleton");
10598 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10600 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
10601 debug_skeleton_abbrev_section
,
10602 "Offset Into Abbrev. Section");
10603 if (dwarf_version
< 5)
10604 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10606 for (int i
= 0; i
< 8; i
++)
10607 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
10609 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
10610 output_die (comp_unit
);
10612 /* Build the skeleton debug_abbrev section. */
10613 switch_to_section (debug_skeleton_abbrev_section
);
10614 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
10616 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
10618 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
10621 /* Output a comdat type unit DIE and its children. */
10624 output_comdat_type_unit (comdat_type_node
*node
)
10626 const char *secname
;
10629 #if defined (OBJECT_FORMAT_ELF)
10633 /* First mark all the DIEs in this CU so we know which get local refs. */
10634 mark_dies (node
->root_die
);
10636 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
10638 build_abbrev_table (node
->root_die
, extern_map
);
10643 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10644 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
10645 calc_die_sizes (node
->root_die
);
10647 #if defined (OBJECT_FORMAT_ELF)
10648 if (dwarf_version
>= 5)
10650 if (!dwarf_split_debug_info
)
10651 secname
= ".debug_info";
10653 secname
= ".debug_info.dwo";
10655 else if (!dwarf_split_debug_info
)
10656 secname
= ".debug_types";
10658 secname
= ".debug_types.dwo";
10660 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
10661 sprintf (tmp
, dwarf_version
>= 5 ? "wi." : "wt.");
10662 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10663 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
10664 comdat_key
= get_identifier (tmp
);
10665 targetm
.asm_out
.named_section (secname
,
10666 SECTION_DEBUG
| SECTION_LINKONCE
,
10669 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
10670 sprintf (tmp
, (dwarf_version
>= 5
10671 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
10672 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10673 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
10675 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
10678 /* Output debugging information. */
10679 output_compilation_unit_header (dwarf_split_debug_info
10680 ? DW_UT_split_type
: DW_UT_type
);
10681 output_signature (node
->signature
, "Type Signature");
10682 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
10683 "Offset to Type DIE");
10684 output_die (node
->root_die
);
10686 unmark_dies (node
->root_die
);
10689 /* Return the DWARF2/3 pubname associated with a decl. */
10691 static const char *
10692 dwarf2_name (tree decl
, int scope
)
10694 if (DECL_NAMELESS (decl
))
10696 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
10699 /* Add a new entry to .debug_pubnames if appropriate. */
10702 add_pubname_string (const char *str
, dw_die_ref die
)
10707 e
.name
= xstrdup (str
);
10708 vec_safe_push (pubname_table
, e
);
10712 add_pubname (tree decl
, dw_die_ref die
)
10714 if (!want_pubnames ())
10717 /* Don't add items to the table when we expect that the consumer will have
10718 just read the enclosing die. For example, if the consumer is looking at a
10719 class_member, it will either be inside the class already, or will have just
10720 looked up the class to find the member. Either way, searching the class is
10721 faster than searching the index. */
10722 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
10723 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
10725 const char *name
= dwarf2_name (decl
, 1);
10728 add_pubname_string (name
, die
);
10732 /* Add an enumerator to the pubnames section. */
10735 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
10739 gcc_assert (scope_name
);
10740 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
10742 vec_safe_push (pubname_table
, e
);
10745 /* Add a new entry to .debug_pubtypes if appropriate. */
10748 add_pubtype (tree decl
, dw_die_ref die
)
10752 if (!want_pubnames ())
10755 if ((TREE_PUBLIC (decl
)
10756 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
10757 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
10760 const char *scope_name
= "";
10761 const char *sep
= is_cxx () ? "::" : ".";
10764 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
10765 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
10767 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
10768 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
10769 scope_name
= concat (scope_name
, sep
, NULL
);
10775 name
= type_tag (decl
);
10777 name
= lang_hooks
.dwarf_name (decl
, 1);
10779 /* If we don't have a name for the type, there's no point in adding
10780 it to the table. */
10781 if (name
!= NULL
&& name
[0] != '\0')
10784 e
.name
= concat (scope_name
, name
, NULL
);
10785 vec_safe_push (pubtype_table
, e
);
10788 /* Although it might be more consistent to add the pubinfo for the
10789 enumerators as their dies are created, they should only be added if the
10790 enum type meets the criteria above. So rather than re-check the parent
10791 enum type whenever an enumerator die is created, just output them all
10792 here. This isn't protected by the name conditional because anonymous
10793 enums don't have names. */
10794 if (die
->die_tag
== DW_TAG_enumeration_type
)
10798 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
10803 /* Output a single entry in the pubnames table. */
10806 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
10808 dw_die_ref die
= entry
->die
;
10809 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
10811 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
10813 if (debug_generate_pub_sections
== 2)
10815 /* This logic follows gdb's method for determining the value of the flag
10817 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
10818 switch (die
->die_tag
)
10820 case DW_TAG_typedef
:
10821 case DW_TAG_base_type
:
10822 case DW_TAG_subrange_type
:
10823 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
10824 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
10826 case DW_TAG_enumerator
:
10827 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
10828 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
10830 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
10832 case DW_TAG_subprogram
:
10833 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
10834 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
10836 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
10838 case DW_TAG_constant
:
10839 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
10840 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
10841 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
10843 case DW_TAG_variable
:
10844 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
10845 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
10846 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
10848 case DW_TAG_namespace
:
10849 case DW_TAG_imported_declaration
:
10850 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
10852 case DW_TAG_class_type
:
10853 case DW_TAG_interface_type
:
10854 case DW_TAG_structure_type
:
10855 case DW_TAG_union_type
:
10856 case DW_TAG_enumeration_type
:
10857 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
10859 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
10862 /* An unusual tag. Leave the flag-byte empty. */
10865 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
10866 "GDB-index flags");
10869 dw2_asm_output_nstring (entry
->name
, -1, "external name");
10873 /* Output the public names table used to speed up access to externally
10874 visible names; or the public types table used to find type definitions. */
10877 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
10880 unsigned long pubnames_length
= size_of_pubnames (names
);
10881 pubname_entry
*pub
;
10883 if (!XCOFF_DEBUGGING_INFO
)
10885 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10886 dw2_asm_output_data (4, 0xffffffff,
10887 "Initial length escape value indicating 64-bit DWARF extension");
10888 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
10889 "Pub Info Length");
10892 /* Version number for pubnames/pubtypes is independent of dwarf version. */
10893 dw2_asm_output_data (2, 2, "DWARF Version");
10895 if (dwarf_split_debug_info
)
10896 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
10897 debug_skeleton_info_section
,
10898 "Offset of Compilation Unit Info");
10900 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
10901 debug_info_section
,
10902 "Offset of Compilation Unit Info");
10903 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
10904 "Compilation Unit Length");
10906 FOR_EACH_VEC_ELT (*names
, i
, pub
)
10908 if (include_pubname_in_output (names
, pub
))
10910 dw_offset die_offset
= pub
->die
->die_offset
;
10912 /* We shouldn't see pubnames for DIEs outside of the main CU. */
10913 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
10914 gcc_assert (pub
->die
->die_mark
);
10916 /* If we're putting types in their own .debug_types sections,
10917 the .debug_pubtypes table will still point to the compile
10918 unit (not the type unit), so we want to use the offset of
10919 the skeleton DIE (if there is one). */
10920 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
10922 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
10924 if (type_node
!= NULL
)
10925 die_offset
= (type_node
->skeleton_die
!= NULL
10926 ? type_node
->skeleton_die
->die_offset
10927 : comp_unit_die ()->die_offset
);
10930 output_pubname (die_offset
, pub
);
10934 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
10937 /* Output public names and types tables if necessary. */
10940 output_pubtables (void)
10942 if (!want_pubnames () || !info_section_emitted
)
10945 switch_to_section (debug_pubnames_section
);
10946 output_pubnames (pubname_table
);
10947 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
10948 It shouldn't hurt to emit it always, since pure DWARF2 consumers
10949 simply won't look for the section. */
10950 switch_to_section (debug_pubtypes_section
);
10951 output_pubnames (pubtype_table
);
10955 /* Output the information that goes into the .debug_aranges table.
10956 Namely, define the beginning and ending address range of the
10957 text section generated for this compilation unit. */
10960 output_aranges (void)
10963 unsigned long aranges_length
= size_of_aranges ();
10965 if (!XCOFF_DEBUGGING_INFO
)
10967 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10968 dw2_asm_output_data (4, 0xffffffff,
10969 "Initial length escape value indicating 64-bit DWARF extension");
10970 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
10971 "Length of Address Ranges Info");
10974 /* Version number for aranges is still 2, even up to DWARF5. */
10975 dw2_asm_output_data (2, 2, "DWARF Version");
10976 if (dwarf_split_debug_info
)
10977 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
10978 debug_skeleton_info_section
,
10979 "Offset of Compilation Unit Info");
10981 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
10982 debug_info_section
,
10983 "Offset of Compilation Unit Info");
10984 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
10985 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
10987 /* We need to align to twice the pointer size here. */
10988 if (DWARF_ARANGES_PAD_SIZE
)
10990 /* Pad using a 2 byte words so that padding is correct for any
10992 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
10993 2 * DWARF2_ADDR_SIZE
);
10994 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
10995 dw2_asm_output_data (2, 0, NULL
);
10998 /* It is necessary not to output these entries if the sections were
10999 not used; if the sections were not used, the length will be 0 and
11000 the address may end up as 0 if the section is discarded by ld
11001 --gc-sections, leaving an invalid (0, 0) entry that can be
11002 confused with the terminator. */
11003 if (text_section_used
)
11005 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
11006 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
11007 text_section_label
, "Length");
11009 if (cold_text_section_used
)
11011 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
11013 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11014 cold_text_section_label
, "Length");
11017 if (have_multiple_function_sections
)
11022 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
11024 if (DECL_IGNORED_P (fde
->decl
))
11026 if (!fde
->in_std_section
)
11028 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
11030 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
11031 fde
->dw_fde_begin
, "Length");
11033 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
11035 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
11037 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
11038 fde
->dw_fde_second_begin
, "Length");
11043 /* Output the terminator words. */
11044 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11045 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11048 /* Add a new entry to .debug_ranges. Return its index into
11049 ranges_table vector. */
11051 static unsigned int
11052 add_ranges_num (int num
, bool maybe_new_sec
)
11054 dw_ranges r
= { NULL
, num
, 0, maybe_new_sec
};
11055 vec_safe_push (ranges_table
, r
);
11056 return vec_safe_length (ranges_table
) - 1;
11059 /* Add a new entry to .debug_ranges corresponding to a block, or a
11060 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11061 this entry might be in a different section from previous range. */
11063 static unsigned int
11064 add_ranges (const_tree block
, bool maybe_new_sec
)
11066 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0, maybe_new_sec
);
11069 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11070 chain, or middle entry of a chain that will be directly referred to. */
11073 note_rnglist_head (unsigned int offset
)
11075 if (dwarf_version
< 5 || (*ranges_table
)[offset
].label
)
11077 (*ranges_table
)[offset
].label
= gen_internal_sym ("LLRL");
11080 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11081 When using dwarf_split_debug_info, address attributes in dies destined
11082 for the final executable should be direct references--setting the
11083 parameter force_direct ensures this behavior. */
11086 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11087 bool *added
, bool force_direct
)
11089 unsigned int in_use
= vec_safe_length (ranges_by_label
);
11090 unsigned int offset
;
11091 dw_ranges_by_label rbl
= { begin
, end
};
11092 vec_safe_push (ranges_by_label
, rbl
);
11093 offset
= add_ranges_num (-(int)in_use
- 1, true);
11096 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
11098 note_rnglist_head (offset
);
11102 /* Emit .debug_ranges section. */
11105 output_ranges (void)
11108 static const char *const start_fmt
= "Offset %#x";
11109 const char *fmt
= start_fmt
;
11112 switch_to_section (debug_ranges_section
);
11113 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11114 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11116 int block_num
= r
->num
;
11120 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11121 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11123 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11124 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11126 /* If all code is in the text section, then the compilation
11127 unit base address defaults to DW_AT_low_pc, which is the
11128 base of the text section. */
11129 if (!have_multiple_function_sections
)
11131 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11132 text_section_label
,
11133 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11134 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11135 text_section_label
, NULL
);
11138 /* Otherwise, the compilation unit base address is zero,
11139 which allows us to use absolute addresses, and not worry
11140 about whether the target supports cross-section
11144 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11145 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11146 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
11152 /* Negative block_num stands for an index into ranges_by_label. */
11153 else if (block_num
< 0)
11155 int lab_idx
= - block_num
- 1;
11157 if (!have_multiple_function_sections
)
11159 gcc_unreachable ();
11161 /* If we ever use add_ranges_by_labels () for a single
11162 function section, all we have to do is to take out
11163 the #if 0 above. */
11164 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11165 (*ranges_by_label
)[lab_idx
].begin
,
11166 text_section_label
,
11167 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11168 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11169 (*ranges_by_label
)[lab_idx
].end
,
11170 text_section_label
, NULL
);
11175 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11176 (*ranges_by_label
)[lab_idx
].begin
,
11177 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11178 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11179 (*ranges_by_label
)[lab_idx
].end
,
11185 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11186 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11192 /* Non-zero if .debug_line_str should be used for .debug_line section
11193 strings or strings that are likely shareable with those. */
11194 #define DWARF5_USE_DEBUG_LINE_STR \
11195 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
11196 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
11197 /* FIXME: there is no .debug_line_str.dwo section, \
11198 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
11199 && !dwarf_split_debug_info)
11201 /* Assign .debug_rnglists indexes. */
11204 index_rnglists (void)
11209 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11211 r
->idx
= rnglist_idx
++;
11214 /* Emit .debug_rnglists section. */
11217 output_rnglists (void)
11221 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
11222 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11223 char basebuf
[MAX_ARTIFICIAL_LABEL_BYTES
];
11225 switch_to_section (debug_ranges_section
);
11226 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11227 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_RANGES_SECTION_LABEL
, 2);
11228 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_RANGES_SECTION_LABEL
, 3);
11229 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11230 dw2_asm_output_data (4, 0xffffffff,
11231 "Initial length escape value indicating "
11232 "64-bit DWARF extension");
11233 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11234 "Length of Range Lists");
11235 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
11236 dw2_asm_output_data (2, dwarf_version
, "DWARF Version");
11237 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
11238 dw2_asm_output_data (1, 0, "Segment Size");
11239 /* Emit the offset table only for -gsplit-dwarf. If we don't care
11240 about relocation sizes and primarily care about the size of .debug*
11241 sections in linked shared libraries and executables, then
11242 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
11243 into it are usually larger than just DW_FORM_sec_offset offsets
11244 into the .debug_rnglists section. */
11245 dw2_asm_output_data (4, dwarf_split_debug_info
? rnglist_idx
: 0,
11246 "Offset Entry Count");
11247 if (dwarf_split_debug_info
)
11249 ASM_OUTPUT_LABEL (asm_out_file
, ranges_base_label
);
11250 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11252 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, r
->label
,
11253 ranges_base_label
, NULL
);
11256 const char *lab
= "";
11257 unsigned int len
= vec_safe_length (ranges_table
);
11258 const char *base
= NULL
;
11259 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11261 int block_num
= r
->num
;
11265 ASM_OUTPUT_LABEL (asm_out_file
, r
->label
);
11268 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
11272 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11273 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11275 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11276 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11278 if (HAVE_AS_LEB128
)
11280 /* If all code is in the text section, then the compilation
11281 unit base address defaults to DW_AT_low_pc, which is the
11282 base of the text section. */
11283 if (!have_multiple_function_sections
)
11285 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11286 "DW_RLE_offset_pair (%s)", lab
);
11287 dw2_asm_output_delta_uleb128 (blabel
, text_section_label
,
11288 "Range begin address (%s)", lab
);
11289 dw2_asm_output_delta_uleb128 (elabel
, text_section_label
,
11290 "Range end address (%s)", lab
);
11295 dw_ranges
*r2
= NULL
;
11297 r2
= &(*ranges_table
)[i
+ 1];
11300 && r2
->label
== NULL
11301 && !r2
->maybe_new_sec
)
11303 dw2_asm_output_data (1, DW_RLE_base_address
,
11304 "DW_RLE_base_address (%s)", lab
);
11305 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11306 "Base address (%s)", lab
);
11307 strcpy (basebuf
, blabel
);
11313 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11314 "DW_RLE_offset_pair (%s)", lab
);
11315 dw2_asm_output_delta_uleb128 (blabel
, base
,
11316 "Range begin address (%s)", lab
);
11317 dw2_asm_output_delta_uleb128 (elabel
, base
,
11318 "Range end address (%s)", lab
);
11321 dw2_asm_output_data (1, DW_RLE_start_length
,
11322 "DW_RLE_start_length (%s)", lab
);
11323 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11324 "Range begin address (%s)", lab
);
11325 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11326 "Range length (%s)", lab
);
11330 dw2_asm_output_data (1, DW_RLE_start_end
,
11331 "DW_RLE_start_end (%s)", lab
);
11332 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11333 "Range begin address (%s)", lab
);
11334 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11335 "Range end address (%s)", lab
);
11339 /* Negative block_num stands for an index into ranges_by_label. */
11340 else if (block_num
< 0)
11342 int lab_idx
= - block_num
- 1;
11343 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
11344 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
11346 if (!have_multiple_function_sections
)
11347 gcc_unreachable ();
11348 if (HAVE_AS_LEB128
)
11350 dw2_asm_output_data (1, DW_RLE_start_length
,
11351 "DW_RLE_start_length (%s)", lab
);
11352 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11353 "Range begin address (%s)", lab
);
11354 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11355 "Range length (%s)", lab
);
11359 dw2_asm_output_data (1, DW_RLE_start_end
,
11360 "DW_RLE_start_end (%s)", lab
);
11361 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11362 "Range begin address (%s)", lab
);
11363 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11364 "Range end address (%s)", lab
);
11368 dw2_asm_output_data (1, DW_RLE_end_of_list
,
11369 "DW_RLE_end_of_list (%s)", lab
);
11371 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
11374 /* Data structure containing information about input files. */
11377 const char *path
; /* Complete file name. */
11378 const char *fname
; /* File name part. */
11379 int length
; /* Length of entire string. */
11380 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
11381 int dir_idx
; /* Index in directory table. */
11384 /* Data structure containing information about directories with source
11388 const char *path
; /* Path including directory name. */
11389 int length
; /* Path length. */
11390 int prefix
; /* Index of directory entry which is a prefix. */
11391 int count
; /* Number of files in this directory. */
11392 int dir_idx
; /* Index of directory used as base. */
11395 /* Callback function for file_info comparison. We sort by looking at
11396 the directories in the path. */
11399 file_info_cmp (const void *p1
, const void *p2
)
11401 const struct file_info
*const s1
= (const struct file_info
*) p1
;
11402 const struct file_info
*const s2
= (const struct file_info
*) p2
;
11403 const unsigned char *cp1
;
11404 const unsigned char *cp2
;
11406 /* Take care of file names without directories. We need to make sure that
11407 we return consistent values to qsort since some will get confused if
11408 we return the same value when identical operands are passed in opposite
11409 orders. So if neither has a directory, return 0 and otherwise return
11410 1 or -1 depending on which one has the directory. */
11411 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
11412 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
11414 cp1
= (const unsigned char *) s1
->path
;
11415 cp2
= (const unsigned char *) s2
->path
;
11421 /* Reached the end of the first path? If so, handle like above. */
11422 if ((cp1
== (const unsigned char *) s1
->fname
)
11423 || (cp2
== (const unsigned char *) s2
->fname
))
11424 return ((cp2
== (const unsigned char *) s2
->fname
)
11425 - (cp1
== (const unsigned char *) s1
->fname
));
11427 /* Character of current path component the same? */
11428 else if (*cp1
!= *cp2
)
11429 return *cp1
- *cp2
;
11433 struct file_name_acquire_data
11435 struct file_info
*files
;
11440 /* Traversal function for the hash table. */
11443 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
11445 struct dwarf_file_data
*d
= *slot
;
11446 struct file_info
*fi
;
11449 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
11451 if (! d
->emitted_number
)
11454 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
11456 fi
= fnad
->files
+ fnad
->used_files
++;
11458 /* Skip all leading "./". */
11460 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
11463 /* Create a new array entry. */
11465 fi
->length
= strlen (f
);
11468 /* Search for the file name part. */
11469 f
= strrchr (f
, DIR_SEPARATOR
);
11470 #if defined (DIR_SEPARATOR_2)
11472 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
11476 if (f
== NULL
|| f
< g
)
11482 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
11486 /* Helper function for output_file_names. Emit a FORM encoded
11487 string STR, with assembly comment start ENTRY_KIND and
11491 output_line_string (enum dwarf_form form
, const char *str
,
11492 const char *entry_kind
, unsigned int idx
)
11496 case DW_FORM_string
:
11497 dw2_asm_output_nstring (str
, -1, "%s: %#x", entry_kind
, idx
);
11499 case DW_FORM_line_strp
:
11500 if (!debug_line_str_hash
)
11501 debug_line_str_hash
11502 = hash_table
<indirect_string_hasher
>::create_ggc (10);
11504 struct indirect_string_node
*node
;
11505 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
11506 set_indirect_string (node
);
11508 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
11509 debug_line_str_section
, "%s: %#x: \"%s\"",
11510 entry_kind
, 0, node
->str
);
11513 gcc_unreachable ();
11517 /* Output the directory table and the file name table. We try to minimize
11518 the total amount of memory needed. A heuristic is used to avoid large
11519 slowdowns with many input files. */
11522 output_file_names (void)
11524 struct file_name_acquire_data fnad
;
11526 struct file_info
*files
;
11527 struct dir_info
*dirs
;
11535 if (!last_emitted_file
)
11537 if (dwarf_version
>= 5)
11539 dw2_asm_output_data (1, 0, "Directory entry format count");
11540 dw2_asm_output_data_uleb128 (0, "Directories count");
11541 dw2_asm_output_data (1, 0, "File name entry format count");
11542 dw2_asm_output_data_uleb128 (0, "File names count");
11546 dw2_asm_output_data (1, 0, "End directory table");
11547 dw2_asm_output_data (1, 0, "End file name table");
11552 numfiles
= last_emitted_file
->emitted_number
;
11554 /* Allocate the various arrays we need. */
11555 files
= XALLOCAVEC (struct file_info
, numfiles
);
11556 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
11558 fnad
.files
= files
;
11559 fnad
.used_files
= 0;
11560 fnad
.max_files
= numfiles
;
11561 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
11562 gcc_assert (fnad
.used_files
== fnad
.max_files
);
11564 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
11566 /* Find all the different directories used. */
11567 dirs
[0].path
= files
[0].path
;
11568 dirs
[0].length
= files
[0].fname
- files
[0].path
;
11569 dirs
[0].prefix
= -1;
11571 dirs
[0].dir_idx
= 0;
11572 files
[0].dir_idx
= 0;
11575 for (i
= 1; i
< numfiles
; i
++)
11576 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
11577 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
11578 dirs
[ndirs
- 1].length
) == 0)
11580 /* Same directory as last entry. */
11581 files
[i
].dir_idx
= ndirs
- 1;
11582 ++dirs
[ndirs
- 1].count
;
11588 /* This is a new directory. */
11589 dirs
[ndirs
].path
= files
[i
].path
;
11590 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
11591 dirs
[ndirs
].count
= 1;
11592 dirs
[ndirs
].dir_idx
= ndirs
;
11593 files
[i
].dir_idx
= ndirs
;
11595 /* Search for a prefix. */
11596 dirs
[ndirs
].prefix
= -1;
11597 for (j
= 0; j
< ndirs
; j
++)
11598 if (dirs
[j
].length
< dirs
[ndirs
].length
11599 && dirs
[j
].length
> 1
11600 && (dirs
[ndirs
].prefix
== -1
11601 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
11602 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
11603 dirs
[ndirs
].prefix
= j
;
11608 /* Now to the actual work. We have to find a subset of the directories which
11609 allow expressing the file name using references to the directory table
11610 with the least amount of characters. We do not do an exhaustive search
11611 where we would have to check out every combination of every single
11612 possible prefix. Instead we use a heuristic which provides nearly optimal
11613 results in most cases and never is much off. */
11614 saved
= XALLOCAVEC (int, ndirs
);
11615 savehere
= XALLOCAVEC (int, ndirs
);
11617 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
11618 for (i
= 0; i
< ndirs
; i
++)
11623 /* We can always save some space for the current directory. But this
11624 does not mean it will be enough to justify adding the directory. */
11625 savehere
[i
] = dirs
[i
].length
;
11626 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
11628 for (j
= i
+ 1; j
< ndirs
; j
++)
11631 if (saved
[j
] < dirs
[i
].length
)
11633 /* Determine whether the dirs[i] path is a prefix of the
11637 k
= dirs
[j
].prefix
;
11638 while (k
!= -1 && k
!= (int) i
)
11639 k
= dirs
[k
].prefix
;
11643 /* Yes it is. We can possibly save some memory by
11644 writing the filenames in dirs[j] relative to
11646 savehere
[j
] = dirs
[i
].length
;
11647 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
11652 /* Check whether we can save enough to justify adding the dirs[i]
11654 if (total
> dirs
[i
].length
+ 1)
11656 /* It's worthwhile adding. */
11657 for (j
= i
; j
< ndirs
; j
++)
11658 if (savehere
[j
] > 0)
11660 /* Remember how much we saved for this directory so far. */
11661 saved
[j
] = savehere
[j
];
11663 /* Remember the prefix directory. */
11664 dirs
[j
].dir_idx
= i
;
11669 /* Emit the directory name table. */
11670 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
11671 enum dwarf_form str_form
= DW_FORM_string
;
11672 enum dwarf_form idx_form
= DW_FORM_udata
;
11673 if (dwarf_version
>= 5)
11675 const char *comp_dir
= comp_dir_string ();
11676 if (comp_dir
== NULL
)
11678 dw2_asm_output_data (1, 1, "Directory entry format count");
11679 if (DWARF5_USE_DEBUG_LINE_STR
)
11680 str_form
= DW_FORM_line_strp
;
11681 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
11682 dw2_asm_output_data_uleb128 (str_form
, "%s",
11683 get_DW_FORM_name (str_form
));
11684 dw2_asm_output_data_uleb128 (ndirs
+ idx_offset
, "Directories count");
11685 if (str_form
== DW_FORM_string
)
11687 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
11688 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
11689 dw2_asm_output_nstring (dirs
[i
].path
,
11691 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
11692 "Directory Entry: %#x", i
+ idx_offset
);
11696 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
11697 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
11700 = ggc_alloc_string (dirs
[i
].path
,
11702 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
);
11703 output_line_string (str_form
, str
, "Directory Entry",
11704 (unsigned) i
+ idx_offset
);
11710 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
11711 dw2_asm_output_nstring (dirs
[i
].path
,
11713 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
11714 "Directory Entry: %#x", i
+ idx_offset
);
11716 dw2_asm_output_data (1, 0, "End directory table");
11719 /* We have to emit them in the order of emitted_number since that's
11720 used in the debug info generation. To do this efficiently we
11721 generate a back-mapping of the indices first. */
11722 backmap
= XALLOCAVEC (int, numfiles
);
11723 for (i
= 0; i
< numfiles
; i
++)
11724 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
11726 if (dwarf_version
>= 5)
11728 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
11729 if (filename0
== NULL
)
11731 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
11732 DW_FORM_data2. Choose one based on the number of directories
11733 and how much space would they occupy in each encoding.
11734 If we have at most 256 directories, all indexes fit into
11735 a single byte, so DW_FORM_data1 is most compact (if there
11736 are at most 128 directories, DW_FORM_udata would be as
11737 compact as that, but not shorter and slower to decode). */
11738 if (ndirs
+ idx_offset
<= 256)
11739 idx_form
= DW_FORM_data1
;
11740 /* If there are more than 65536 directories, we have to use
11741 DW_FORM_udata, DW_FORM_data2 can't refer to them.
11742 Otherwise, compute what space would occupy if all the indexes
11743 used DW_FORM_udata - sum - and compare that to how large would
11744 be DW_FORM_data2 encoding, and pick the more efficient one. */
11745 else if (ndirs
+ idx_offset
<= 65536)
11747 unsigned HOST_WIDE_INT sum
= 1;
11748 for (i
= 0; i
< numfiles
; i
++)
11750 int file_idx
= backmap
[i
];
11751 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
11752 sum
+= size_of_uleb128 (dir_idx
);
11754 if (sum
>= HOST_WIDE_INT_UC (2) * (numfiles
+ 1))
11755 idx_form
= DW_FORM_data2
;
11757 #ifdef VMS_DEBUGGING_INFO
11758 dw2_asm_output_data (1, 4, "File name entry format count");
11760 dw2_asm_output_data (1, 2, "File name entry format count");
11762 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
11763 dw2_asm_output_data_uleb128 (str_form
, "%s",
11764 get_DW_FORM_name (str_form
));
11765 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
11766 "DW_LNCT_directory_index");
11767 dw2_asm_output_data_uleb128 (idx_form
, "%s",
11768 get_DW_FORM_name (idx_form
));
11769 #ifdef VMS_DEBUGGING_INFO
11770 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
11771 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
11772 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
11773 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
11775 dw2_asm_output_data_uleb128 (numfiles
+ 1, "File names count");
11777 output_line_string (str_form
, filename0
, "File Entry", 0);
11779 /* Include directory index. */
11780 if (idx_form
!= DW_FORM_udata
)
11781 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
11784 dw2_asm_output_data_uleb128 (0, NULL
);
11786 #ifdef VMS_DEBUGGING_INFO
11787 dw2_asm_output_data_uleb128 (0, NULL
);
11788 dw2_asm_output_data_uleb128 (0, NULL
);
11792 /* Now write all the file names. */
11793 for (i
= 0; i
< numfiles
; i
++)
11795 int file_idx
= backmap
[i
];
11796 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
11798 #ifdef VMS_DEBUGGING_INFO
11799 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
11801 /* Setting these fields can lead to debugger miscomparisons,
11802 but VMS Debug requires them to be set correctly. */
11807 int maxfilelen
= (strlen (files
[file_idx
].path
)
11808 + dirs
[dir_idx
].length
11809 + MAX_VMS_VERSION_LEN
+ 1);
11810 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
11812 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
11813 snprintf (filebuf
, maxfilelen
, "%s;%d",
11814 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
11816 output_line_string (str_form
, filebuf
, "File Entry", (unsigned) i
+ 1);
11818 /* Include directory index. */
11819 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
11820 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
11821 dir_idx
+ idx_offset
, NULL
);
11823 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
11825 /* Modification time. */
11826 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
11827 &cdt
, 0, 0, 0) == 0)
11830 /* File length in bytes. */
11831 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
11832 0, &siz
, 0, 0) == 0)
11835 output_line_string (str_form
,
11836 files
[file_idx
].path
+ dirs
[dir_idx
].length
,
11837 "File Entry", (unsigned) i
+ 1);
11839 /* Include directory index. */
11840 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
11841 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
11842 dir_idx
+ idx_offset
, NULL
);
11844 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
11846 if (dwarf_version
>= 5)
11849 /* Modification time. */
11850 dw2_asm_output_data_uleb128 (0, NULL
);
11852 /* File length in bytes. */
11853 dw2_asm_output_data_uleb128 (0, NULL
);
11854 #endif /* VMS_DEBUGGING_INFO */
11857 if (dwarf_version
< 5)
11858 dw2_asm_output_data (1, 0, "End file name table");
11862 /* Output one line number table into the .debug_line section. */
11865 output_one_line_info_table (dw_line_info_table
*table
)
11867 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11868 unsigned int current_line
= 1;
11869 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
11870 dw_line_info_entry
*ent
;
11873 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
11875 switch (ent
->opcode
)
11877 case LI_set_address
:
11878 /* ??? Unfortunately, we have little choice here currently, and
11879 must always use the most general form. GCC does not know the
11880 address delta itself, so we can't use DW_LNS_advance_pc. Many
11881 ports do have length attributes which will give an upper bound
11882 on the address range. We could perhaps use length attributes
11883 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
11884 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
11886 /* This can handle any delta. This takes
11887 4+DWARF2_ADDR_SIZE bytes. */
11888 dw2_asm_output_data (1, 0, "set address %s", line_label
);
11889 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
11890 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
11891 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
11895 if (ent
->val
== current_line
)
11897 /* We still need to start a new row, so output a copy insn. */
11898 dw2_asm_output_data (1, DW_LNS_copy
,
11899 "copy line %u", current_line
);
11903 int line_offset
= ent
->val
- current_line
;
11904 int line_delta
= line_offset
- DWARF_LINE_BASE
;
11906 current_line
= ent
->val
;
11907 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
11909 /* This can handle deltas from -10 to 234, using the current
11910 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
11911 This takes 1 byte. */
11912 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
11913 "line %u", current_line
);
11917 /* This can handle any delta. This takes at least 4 bytes,
11918 depending on the value being encoded. */
11919 dw2_asm_output_data (1, DW_LNS_advance_line
,
11920 "advance to line %u", current_line
);
11921 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
11922 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
11928 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
11929 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
11932 case LI_set_column
:
11933 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
11934 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
11937 case LI_negate_stmt
:
11938 current_is_stmt
= !current_is_stmt
;
11939 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
11940 "is_stmt %d", current_is_stmt
);
11943 case LI_set_prologue_end
:
11944 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
11945 "set prologue end");
11948 case LI_set_epilogue_begin
:
11949 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
11950 "set epilogue begin");
11953 case LI_set_discriminator
:
11954 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
11955 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
11956 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
11957 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
11962 /* Emit debug info for the address of the end of the table. */
11963 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
11964 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
11965 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
11966 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
11968 dw2_asm_output_data (1, 0, "end sequence");
11969 dw2_asm_output_data_uleb128 (1, NULL
);
11970 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
11973 /* Output the source line number correspondence information. This
11974 information goes into the .debug_line section. */
11977 output_line_info (bool prologue_only
)
11979 static unsigned int generation
;
11980 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11981 char p1
[MAX_ARTIFICIAL_LABEL_BYTES
], p2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11982 bool saw_one
= false;
11985 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, generation
);
11986 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, generation
);
11987 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, generation
);
11988 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, generation
++);
11990 if (!XCOFF_DEBUGGING_INFO
)
11992 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11993 dw2_asm_output_data (4, 0xffffffff,
11994 "Initial length escape value indicating 64-bit DWARF extension");
11995 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11996 "Length of Source Line Info");
11999 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
12001 dw2_asm_output_data (2, dwarf_version
, "DWARF Version");
12002 if (dwarf_version
>= 5)
12004 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
12005 dw2_asm_output_data (1, 0, "Segment Size");
12007 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
12008 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
12010 /* Define the architecture-dependent minimum instruction length (in bytes).
12011 In this implementation of DWARF, this field is used for information
12012 purposes only. Since GCC generates assembly language, we have no
12013 a priori knowledge of how many instruction bytes are generated for each
12014 source line, and therefore can use only the DW_LNE_set_address and
12015 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
12016 this as '1', which is "correct enough" for all architectures,
12017 and don't let the target override. */
12018 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
12020 if (dwarf_version
>= 4)
12021 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
12022 "Maximum Operations Per Instruction");
12023 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
12024 "Default is_stmt_start flag");
12025 dw2_asm_output_data (1, DWARF_LINE_BASE
,
12026 "Line Base Value (Special Opcodes)");
12027 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
12028 "Line Range Value (Special Opcodes)");
12029 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
12030 "Special Opcode Base");
12032 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
12037 case DW_LNS_advance_pc
:
12038 case DW_LNS_advance_line
:
12039 case DW_LNS_set_file
:
12040 case DW_LNS_set_column
:
12041 case DW_LNS_fixed_advance_pc
:
12042 case DW_LNS_set_isa
:
12050 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
12054 /* Write out the information about the files we use. */
12055 output_file_names ();
12056 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
12059 /* Output the marker for the end of the line number info. */
12060 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12064 if (separate_line_info
)
12066 dw_line_info_table
*table
;
12069 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
12072 output_one_line_info_table (table
);
12076 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
12078 output_one_line_info_table (cold_text_section_line_info
);
12082 /* ??? Some Darwin linkers crash on a .debug_line section with no
12083 sequences. Further, merely a DW_LNE_end_sequence entry is not
12084 sufficient -- the address column must also be initialized.
12085 Make sure to output at least one set_address/end_sequence pair,
12086 choosing .text since that section is always present. */
12087 if (text_section_line_info
->in_use
|| !saw_one
)
12088 output_one_line_info_table (text_section_line_info
);
12090 /* Output the marker for the end of the line number info. */
12091 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12094 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
12097 need_endianity_attribute_p (bool reverse
)
12099 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
12102 /* Given a pointer to a tree node for some base type, return a pointer to
12103 a DIE that describes the given type. REVERSE is true if the type is
12104 to be interpreted in the reverse storage order wrt the target order.
12106 This routine must only be called for GCC type nodes that correspond to
12107 Dwarf base (fundamental) types. */
12110 base_type_die (tree type
, bool reverse
)
12112 dw_die_ref base_type_result
;
12113 enum dwarf_type encoding
;
12114 bool fpt_used
= false;
12115 struct fixed_point_type_info fpt_info
;
12116 tree type_bias
= NULL_TREE
;
12118 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
12121 /* If this is a subtype that should not be emitted as a subrange type,
12122 use the base type. See subrange_type_for_debug_p. */
12123 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
12124 type
= TREE_TYPE (type
);
12126 switch (TREE_CODE (type
))
12129 if ((dwarf_version
>= 4 || !dwarf_strict
)
12130 && TYPE_NAME (type
)
12131 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12132 && DECL_IS_BUILTIN (TYPE_NAME (type
))
12133 && DECL_NAME (TYPE_NAME (type
)))
12135 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
12136 if (strcmp (name
, "char16_t") == 0
12137 || strcmp (name
, "char32_t") == 0)
12139 encoding
= DW_ATE_UTF
;
12143 if ((dwarf_version
>= 3 || !dwarf_strict
)
12144 && lang_hooks
.types
.get_fixed_point_type_info
)
12146 memset (&fpt_info
, 0, sizeof (fpt_info
));
12147 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
12150 encoding
= ((TYPE_UNSIGNED (type
))
12151 ? DW_ATE_unsigned_fixed
12152 : DW_ATE_signed_fixed
);
12156 if (TYPE_STRING_FLAG (type
))
12158 if (TYPE_UNSIGNED (type
))
12159 encoding
= DW_ATE_unsigned_char
;
12161 encoding
= DW_ATE_signed_char
;
12163 else if (TYPE_UNSIGNED (type
))
12164 encoding
= DW_ATE_unsigned
;
12166 encoding
= DW_ATE_signed
;
12169 && lang_hooks
.types
.get_type_bias
)
12170 type_bias
= lang_hooks
.types
.get_type_bias (type
);
12174 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
12176 if (dwarf_version
>= 3 || !dwarf_strict
)
12177 encoding
= DW_ATE_decimal_float
;
12179 encoding
= DW_ATE_lo_user
;
12182 encoding
= DW_ATE_float
;
12185 case FIXED_POINT_TYPE
:
12186 if (!(dwarf_version
>= 3 || !dwarf_strict
))
12187 encoding
= DW_ATE_lo_user
;
12188 else if (TYPE_UNSIGNED (type
))
12189 encoding
= DW_ATE_unsigned_fixed
;
12191 encoding
= DW_ATE_signed_fixed
;
12194 /* Dwarf2 doesn't know anything about complex ints, so use
12195 a user defined type for it. */
12197 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
12198 encoding
= DW_ATE_complex_float
;
12200 encoding
= DW_ATE_lo_user
;
12204 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12205 encoding
= DW_ATE_boolean
;
12209 /* No other TREE_CODEs are Dwarf fundamental types. */
12210 gcc_unreachable ();
12213 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die (), type
);
12215 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
12216 int_size_in_bytes (type
));
12217 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
12219 if (need_endianity_attribute_p (reverse
))
12220 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
12221 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
12223 add_alignment_attribute (base_type_result
, type
);
12227 switch (fpt_info
.scale_factor_kind
)
12229 case fixed_point_scale_factor_binary
:
12230 add_AT_int (base_type_result
, DW_AT_binary_scale
,
12231 fpt_info
.scale_factor
.binary
);
12234 case fixed_point_scale_factor_decimal
:
12235 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
12236 fpt_info
.scale_factor
.decimal
);
12239 case fixed_point_scale_factor_arbitrary
:
12240 /* Arbitrary scale factors cannot be described in standard DWARF,
12244 /* Describe the scale factor as a rational constant. */
12245 const dw_die_ref scale_factor
12246 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
12248 add_AT_unsigned (scale_factor
, DW_AT_GNU_numerator
,
12249 fpt_info
.scale_factor
.arbitrary
.numerator
);
12250 add_AT_int (scale_factor
, DW_AT_GNU_denominator
,
12251 fpt_info
.scale_factor
.arbitrary
.denominator
);
12253 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
12258 gcc_unreachable ();
12263 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
12264 dw_scalar_form_constant
12265 | dw_scalar_form_exprloc
12266 | dw_scalar_form_reference
,
12269 add_pubtype (type
, base_type_result
);
12271 return base_type_result
;
12274 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
12275 named 'auto' in its type: return true for it, false otherwise. */
12278 is_cxx_auto (tree type
)
12282 tree name
= TYPE_IDENTIFIER (type
);
12283 if (name
== get_identifier ("auto")
12284 || name
== get_identifier ("decltype(auto)"))
12290 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12291 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12294 is_base_type (tree type
)
12296 switch (TREE_CODE (type
))
12302 case FIXED_POINT_TYPE
:
12305 case POINTER_BOUNDS_TYPE
:
12311 case QUAL_UNION_TYPE
:
12312 case ENUMERAL_TYPE
:
12313 case FUNCTION_TYPE
:
12316 case REFERENCE_TYPE
:
12324 if (is_cxx_auto (type
))
12326 gcc_unreachable ();
12332 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12333 node, return the size in bits for the type if it is a constant, or else
12334 return the alignment for the type if the type's size is not constant, or
12335 else return BITS_PER_WORD if the type actually turns out to be an
12336 ERROR_MARK node. */
12338 static inline unsigned HOST_WIDE_INT
12339 simple_type_size_in_bits (const_tree type
)
12341 if (TREE_CODE (type
) == ERROR_MARK
)
12342 return BITS_PER_WORD
;
12343 else if (TYPE_SIZE (type
) == NULL_TREE
)
12345 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
12346 return tree_to_uhwi (TYPE_SIZE (type
));
12348 return TYPE_ALIGN (type
);
12351 /* Similarly, but return an offset_int instead of UHWI. */
12353 static inline offset_int
12354 offset_int_type_size_in_bits (const_tree type
)
12356 if (TREE_CODE (type
) == ERROR_MARK
)
12357 return BITS_PER_WORD
;
12358 else if (TYPE_SIZE (type
) == NULL_TREE
)
12360 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
12361 return wi::to_offset (TYPE_SIZE (type
));
12363 return TYPE_ALIGN (type
);
12366 /* Given a pointer to a tree node for a subrange type, return a pointer
12367 to a DIE that describes the given type. */
12370 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
12371 dw_die_ref context_die
)
12373 dw_die_ref subrange_die
;
12374 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
12376 if (context_die
== NULL
)
12377 context_die
= comp_unit_die ();
12379 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
12381 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
12383 /* The size of the subrange type and its base type do not match,
12384 so we need to generate a size attribute for the subrange type. */
12385 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
12388 add_alignment_attribute (subrange_die
, type
);
12391 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
12393 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
12394 if (bias
&& !dwarf_strict
)
12395 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
12396 dw_scalar_form_constant
12397 | dw_scalar_form_exprloc
12398 | dw_scalar_form_reference
,
12401 return subrange_die
;
12404 /* Returns the (const and/or volatile) cv_qualifiers associated with
12405 the decl node. This will normally be augmented with the
12406 cv_qualifiers of the underlying type in add_type_attribute. */
12409 decl_quals (const_tree decl
)
12411 return ((TREE_READONLY (decl
)
12412 /* The C++ front-end correctly marks reference-typed
12413 variables as readonly, but from a language (and debug
12414 info) standpoint they are not const-qualified. */
12415 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
12416 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
12417 | (TREE_THIS_VOLATILE (decl
)
12418 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
12421 /* Determine the TYPE whose qualifiers match the largest strict subset
12422 of the given TYPE_QUALS, and return its qualifiers. Ignore all
12423 qualifiers outside QUAL_MASK. */
12426 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
12429 int best_rank
= 0, best_qual
= 0, max_rank
;
12431 type_quals
&= qual_mask
;
12432 max_rank
= popcount_hwi (type_quals
) - 1;
12434 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
12435 t
= TYPE_NEXT_VARIANT (t
))
12437 int q
= TYPE_QUALS (t
) & qual_mask
;
12439 if ((q
& type_quals
) == q
&& q
!= type_quals
12440 && check_base_type (t
, type
))
12442 int rank
= popcount_hwi (q
);
12444 if (rank
> best_rank
)
12455 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
12456 static const dwarf_qual_info_t dwarf_qual_info
[] =
12458 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
12459 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
12460 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
12461 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
12463 static const unsigned int dwarf_qual_info_size
12464 = sizeof (dwarf_qual_info
) / sizeof (dwarf_qual_info
[0]);
12466 /* If DIE is a qualified DIE of some base DIE with the same parent,
12467 return the base DIE, otherwise return NULL. Set MASK to the
12468 qualifiers added compared to the returned DIE. */
12471 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
12474 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
12475 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
12477 if (i
== dwarf_qual_info_size
)
12479 if (vec_safe_length (die
->die_attr
) != 1)
12481 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
12482 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
12484 *mask
|= dwarf_qual_info
[i
].q
;
12487 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
12494 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
12495 entry that chains the modifiers specified by CV_QUALS in front of the
12496 given type. REVERSE is true if the type is to be interpreted in the
12497 reverse storage order wrt the target order. */
12500 modified_type_die (tree type
, int cv_quals
, bool reverse
,
12501 dw_die_ref context_die
)
12503 enum tree_code code
= TREE_CODE (type
);
12504 dw_die_ref mod_type_die
;
12505 dw_die_ref sub_die
= NULL
;
12506 tree item_type
= NULL
;
12507 tree qualified_type
;
12508 tree name
, low
, high
;
12509 dw_die_ref mod_scope
;
12510 /* Only these cv-qualifiers are currently handled. */
12511 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
12512 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
);
12514 if (code
== ERROR_MARK
)
12517 if (lang_hooks
.types
.get_debug_type
)
12519 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
12521 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
12522 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
12525 cv_quals
&= cv_qual_mask
;
12527 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
12528 tag modifier (and not an attribute) old consumers won't be able
12530 if (dwarf_version
< 3)
12531 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
12533 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
12534 if (dwarf_version
< 5)
12535 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
12537 /* See if we already have the appropriately qualified variant of
12539 qualified_type
= get_qualified_type (type
, cv_quals
);
12541 if (qualified_type
== sizetype
)
12543 /* Try not to expose the internal sizetype type's name. */
12544 if (TYPE_NAME (qualified_type
)
12545 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
12547 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
12549 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
12550 && (TYPE_PRECISION (t
)
12551 == TYPE_PRECISION (qualified_type
))
12552 && (TYPE_UNSIGNED (t
)
12553 == TYPE_UNSIGNED (qualified_type
)));
12554 qualified_type
= t
;
12556 else if (qualified_type
== sizetype
12557 && TREE_CODE (sizetype
) == TREE_CODE (size_type_node
)
12558 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (size_type_node
)
12559 && TYPE_UNSIGNED (sizetype
) == TYPE_UNSIGNED (size_type_node
))
12560 qualified_type
= size_type_node
;
12564 /* If we do, then we can just use its DIE, if it exists. */
12565 if (qualified_type
)
12567 mod_type_die
= lookup_type_die (qualified_type
);
12569 /* DW_AT_endianity doesn't come from a qualifier on the type. */
12571 && (!need_endianity_attribute_p (reverse
)
12572 || !is_base_type (type
)
12573 || get_AT_unsigned (mod_type_die
, DW_AT_endianity
)))
12574 return mod_type_die
;
12577 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
12579 /* Handle C typedef types. */
12580 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
12581 && !DECL_ARTIFICIAL (name
))
12583 tree dtype
= TREE_TYPE (name
);
12585 if (qualified_type
== dtype
)
12587 tree origin
= decl_ultimate_origin (name
);
12589 /* Typedef variants that have an abstract origin don't get their own
12590 type DIE (see gen_typedef_die), so fall back on the ultimate
12591 abstract origin instead. */
12592 if (origin
!= NULL
&& origin
!= name
)
12593 return modified_type_die (TREE_TYPE (origin
), cv_quals
, reverse
,
12596 /* For a named type, use the typedef. */
12597 gen_type_die (qualified_type
, context_die
);
12598 return lookup_type_die (qualified_type
);
12602 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
12603 dquals
&= cv_qual_mask
;
12604 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
12605 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
12606 /* cv-unqualified version of named type. Just use
12607 the unnamed type to which it refers. */
12608 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
12609 reverse
, context_die
);
12610 /* Else cv-qualified version of named type; fall through. */
12614 mod_scope
= scope_die_for (type
, context_die
);
12618 int sub_quals
= 0, first_quals
= 0;
12620 dw_die_ref first
= NULL
, last
= NULL
;
12622 /* Determine a lesser qualified type that most closely matches
12623 this one. Then generate DW_TAG_* entries for the remaining
12625 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
12627 if (sub_quals
&& use_debug_types
)
12629 bool needed
= false;
12630 /* If emitting type units, make sure the order of qualifiers
12631 is canonical. Thus, start from unqualified type if
12632 an earlier qualifier is missing in sub_quals, but some later
12633 one is present there. */
12634 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
12635 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
12637 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
12643 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
12644 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
12646 /* As not all intermediate qualified DIEs have corresponding
12647 tree types, ensure that qualified DIEs in the same scope
12648 as their DW_AT_type are emitted after their DW_AT_type,
12649 only with other qualified DIEs for the same type possibly
12650 in between them. Determine the range of such qualified
12651 DIEs now (first being the base type, last being corresponding
12652 last qualified DIE for it). */
12653 unsigned int count
= 0;
12654 first
= qualified_die_p (mod_type_die
, &first_quals
,
12655 dwarf_qual_info_size
);
12657 first
= mod_type_die
;
12658 gcc_assert ((first_quals
& ~sub_quals
) == 0);
12659 for (count
= 0, last
= first
;
12660 count
< (1U << dwarf_qual_info_size
);
12661 count
++, last
= last
->die_sib
)
12664 if (last
== mod_scope
->die_child
)
12666 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
12672 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
12673 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
12676 if (first
&& first
!= last
)
12678 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
12681 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
12682 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
12698 d
= ggc_cleared_alloc
<die_node
> ();
12699 d
->die_tag
= dwarf_qual_info
[i
].t
;
12700 add_child_die_after (mod_scope
, d
, last
);
12704 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
12706 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
12708 first_quals
|= dwarf_qual_info
[i
].q
;
12711 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
12713 dwarf_tag tag
= DW_TAG_pointer_type
;
12714 if (code
== REFERENCE_TYPE
)
12716 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
12717 tag
= DW_TAG_rvalue_reference_type
;
12719 tag
= DW_TAG_reference_type
;
12721 mod_type_die
= new_die (tag
, mod_scope
, type
);
12723 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
12724 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
12725 add_alignment_attribute (mod_type_die
, type
);
12726 item_type
= TREE_TYPE (type
);
12728 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
12729 if (!ADDR_SPACE_GENERIC_P (as
))
12731 int action
= targetm
.addr_space
.debug (as
);
12734 /* Positive values indicate an address_class. */
12735 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
12739 /* Negative values indicate an (inverted) segment base reg. */
12741 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
12742 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
12746 else if (code
== INTEGER_TYPE
12747 && TREE_TYPE (type
) != NULL_TREE
12748 && subrange_type_for_debug_p (type
, &low
, &high
))
12750 tree bias
= NULL_TREE
;
12751 if (lang_hooks
.types
.get_type_bias
)
12752 bias
= lang_hooks
.types
.get_type_bias (type
);
12753 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
12754 item_type
= TREE_TYPE (type
);
12756 else if (is_base_type (type
))
12757 mod_type_die
= base_type_die (type
, reverse
);
12760 gen_type_die (type
, context_die
);
12762 /* We have to get the type_main_variant here (and pass that to the
12763 `lookup_type_die' routine) because the ..._TYPE node we have
12764 might simply be a *copy* of some original type node (where the
12765 copy was created to help us keep track of typedef names) and
12766 that copy might have a different TYPE_UID from the original
12768 if (TREE_CODE (type
) == FUNCTION_TYPE
12769 || TREE_CODE (type
) == METHOD_TYPE
)
12771 /* For function/method types, can't just use type_main_variant here,
12772 because that can have different ref-qualifiers for C++,
12773 but try to canonicalize. */
12774 tree main
= TYPE_MAIN_VARIANT (type
);
12775 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
12776 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
12777 && check_base_type (t
, main
)
12778 && check_lang_type (t
, type
))
12779 return lookup_type_die (t
);
12780 return lookup_type_die (type
);
12782 else if (TREE_CODE (type
) != VECTOR_TYPE
12783 && TREE_CODE (type
) != ARRAY_TYPE
)
12784 return lookup_type_die (type_main_variant (type
));
12786 /* Vectors have the debugging information in the type,
12787 not the main variant. */
12788 return lookup_type_die (type
);
12791 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
12792 don't output a DW_TAG_typedef, since there isn't one in the
12793 user's program; just attach a DW_AT_name to the type.
12794 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
12795 if the base type already has the same name. */
12797 && ((TREE_CODE (name
) != TYPE_DECL
12798 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
12799 || (cv_quals
== TYPE_UNQUALIFIED
)))
12800 || (TREE_CODE (name
) == TYPE_DECL
12801 && TREE_TYPE (name
) == qualified_type
12802 && DECL_NAME (name
))))
12804 if (TREE_CODE (name
) == TYPE_DECL
)
12805 /* Could just call add_name_and_src_coords_attributes here,
12806 but since this is a builtin type it doesn't have any
12807 useful source coordinates anyway. */
12808 name
= DECL_NAME (name
);
12809 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
12811 /* This probably indicates a bug. */
12812 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
12814 name
= TYPE_IDENTIFIER (type
);
12815 add_name_attribute (mod_type_die
,
12816 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
12819 if (qualified_type
)
12820 equate_type_number_to_die (qualified_type
, mod_type_die
);
12823 /* We must do this after the equate_type_number_to_die call, in case
12824 this is a recursive type. This ensures that the modified_type_die
12825 recursion will terminate even if the type is recursive. Recursive
12826 types are possible in Ada. */
12827 sub_die
= modified_type_die (item_type
,
12828 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
12832 if (sub_die
!= NULL
)
12833 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
12835 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
12836 if (TYPE_ARTIFICIAL (type
))
12837 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
12839 return mod_type_die
;
12842 /* Generate DIEs for the generic parameters of T.
12843 T must be either a generic type or a generic function.
12844 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
12847 gen_generic_params_dies (tree t
)
12851 dw_die_ref die
= NULL
;
12854 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
12858 die
= lookup_type_die (t
);
12859 else if (DECL_P (t
))
12860 die
= lookup_decl_die (t
);
12864 parms
= lang_hooks
.get_innermost_generic_parms (t
);
12866 /* T has no generic parameter. It means T is neither a generic type
12867 or function. End of story. */
12870 parms_num
= TREE_VEC_LENGTH (parms
);
12871 args
= lang_hooks
.get_innermost_generic_args (t
);
12872 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
12873 non_default
= int_cst_value (TREE_CHAIN (args
));
12875 non_default
= TREE_VEC_LENGTH (args
);
12876 for (i
= 0; i
< parms_num
; i
++)
12878 tree parm
, arg
, arg_pack_elems
;
12879 dw_die_ref parm_die
;
12881 parm
= TREE_VEC_ELT (parms
, i
);
12882 arg
= TREE_VEC_ELT (args
, i
);
12883 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
12884 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
12886 if (parm
&& TREE_VALUE (parm
) && arg
)
12888 /* If PARM represents a template parameter pack,
12889 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
12890 by DW_TAG_template_*_parameter DIEs for the argument
12891 pack elements of ARG. Note that ARG would then be
12892 an argument pack. */
12893 if (arg_pack_elems
)
12894 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
12898 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
12899 true /* emit name */, die
);
12900 if (i
>= non_default
)
12901 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
12906 /* Create and return a DIE for PARM which should be
12907 the representation of a generic type parameter.
12908 For instance, in the C++ front end, PARM would be a template parameter.
12909 ARG is the argument to PARM.
12910 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
12912 PARENT_DIE is the parent DIE which the new created DIE should be added to,
12913 as a child node. */
12916 generic_parameter_die (tree parm
, tree arg
,
12918 dw_die_ref parent_die
)
12920 dw_die_ref tmpl_die
= NULL
;
12921 const char *name
= NULL
;
12923 if (!parm
|| !DECL_NAME (parm
) || !arg
)
12926 /* We support non-type generic parameters and arguments,
12927 type generic parameters and arguments, as well as
12928 generic generic parameters (a.k.a. template template parameters in C++)
12930 if (TREE_CODE (parm
) == PARM_DECL
)
12931 /* PARM is a nontype generic parameter */
12932 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
12933 else if (TREE_CODE (parm
) == TYPE_DECL
)
12934 /* PARM is a type generic parameter. */
12935 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
12936 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
12937 /* PARM is a generic generic parameter.
12938 Its DIE is a GNU extension. It shall have a
12939 DW_AT_name attribute to represent the name of the template template
12940 parameter, and a DW_AT_GNU_template_name attribute to represent the
12941 name of the template template argument. */
12942 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
12945 gcc_unreachable ();
12951 /* If PARM is a generic parameter pack, it means we are
12952 emitting debug info for a template argument pack element.
12953 In other terms, ARG is a template argument pack element.
12954 In that case, we don't emit any DW_AT_name attribute for
12958 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
12960 add_AT_string (tmpl_die
, DW_AT_name
, name
);
12963 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
12965 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
12966 TMPL_DIE should have a child DW_AT_type attribute that is set
12967 to the type of the argument to PARM, which is ARG.
12968 If PARM is a type generic parameter, TMPL_DIE should have a
12969 child DW_AT_type that is set to ARG. */
12970 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
12971 add_type_attribute (tmpl_die
, tmpl_type
,
12972 (TREE_THIS_VOLATILE (tmpl_type
)
12973 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
12974 false, parent_die
);
12978 /* So TMPL_DIE is a DIE representing a
12979 a generic generic template parameter, a.k.a template template
12980 parameter in C++ and arg is a template. */
12982 /* The DW_AT_GNU_template_name attribute of the DIE must be set
12983 to the name of the argument. */
12984 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
12986 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
12989 if (TREE_CODE (parm
) == PARM_DECL
)
12990 /* So PARM is a non-type generic parameter.
12991 DWARF3 5.6.8 says we must set a DW_AT_const_value child
12992 attribute of TMPL_DIE which value represents the value
12994 We must be careful here:
12995 The value of ARG might reference some function decls.
12996 We might currently be emitting debug info for a generic
12997 type and types are emitted before function decls, we don't
12998 know if the function decls referenced by ARG will actually be
12999 emitted after cgraph computations.
13000 So must defer the generation of the DW_AT_const_value to
13001 after cgraph is ready. */
13002 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
13008 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13009 PARM_PACK must be a template parameter pack. The returned DIE
13010 will be child DIE of PARENT_DIE. */
13013 template_parameter_pack_die (tree parm_pack
,
13014 tree parm_pack_args
,
13015 dw_die_ref parent_die
)
13020 gcc_assert (parent_die
&& parm_pack
);
13022 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
13023 add_name_and_src_coords_attributes (die
, parm_pack
);
13024 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
13025 generic_parameter_die (parm_pack
,
13026 TREE_VEC_ELT (parm_pack_args
, j
),
13027 false /* Don't emit DW_AT_name */,
13032 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
13033 an enumerated type. */
13036 type_is_enum (const_tree type
)
13038 return TREE_CODE (type
) == ENUMERAL_TYPE
;
13041 /* Return the DBX register number described by a given RTL node. */
13043 static unsigned int
13044 dbx_reg_number (const_rtx rtl
)
13046 unsigned regno
= REGNO (rtl
);
13048 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
13050 #ifdef LEAF_REG_REMAP
13051 if (crtl
->uses_only_leaf_regs
)
13053 int leaf_reg
= LEAF_REG_REMAP (regno
);
13054 if (leaf_reg
!= -1)
13055 regno
= (unsigned) leaf_reg
;
13059 regno
= DBX_REGISTER_NUMBER (regno
);
13060 gcc_assert (regno
!= INVALID_REGNUM
);
13064 /* Optionally add a DW_OP_piece term to a location description expression.
13065 DW_OP_piece is only added if the location description expression already
13066 doesn't end with DW_OP_piece. */
13069 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
13071 dw_loc_descr_ref loc
;
13073 if (*list_head
!= NULL
)
13075 /* Find the end of the chain. */
13076 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
13079 if (loc
->dw_loc_opc
!= DW_OP_piece
)
13080 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
13084 /* Return a location descriptor that designates a machine register or
13085 zero if there is none. */
13087 static dw_loc_descr_ref
13088 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
13092 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
13095 /* We only use "frame base" when we're sure we're talking about the
13096 post-prologue local stack frame. We do this by *not* running
13097 register elimination until this point, and recognizing the special
13098 argument pointer and soft frame pointer rtx's.
13099 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13100 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
13101 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
13103 dw_loc_descr_ref result
= NULL
;
13105 if (dwarf_version
>= 4 || !dwarf_strict
)
13107 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
13110 add_loc_descr (&result
,
13111 new_loc_descr (DW_OP_stack_value
, 0, 0));
13116 regs
= targetm
.dwarf_register_span (rtl
);
13118 if (REG_NREGS (rtl
) > 1 || regs
)
13119 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
13122 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
13123 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
13125 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
13129 /* Return a location descriptor that designates a machine register for
13130 a given hard register number. */
13132 static dw_loc_descr_ref
13133 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
13135 dw_loc_descr_ref reg_loc_descr
;
13139 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
13141 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
13143 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13144 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13146 return reg_loc_descr
;
13149 /* Given an RTL of a register, return a location descriptor that
13150 designates a value that spans more than one register. */
13152 static dw_loc_descr_ref
13153 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
13154 enum var_init_status initialized
)
13157 dw_loc_descr_ref loc_result
= NULL
;
13159 /* Simple, contiguous registers. */
13160 if (regs
== NULL_RTX
)
13162 unsigned reg
= REGNO (rtl
);
13165 #ifdef LEAF_REG_REMAP
13166 if (crtl
->uses_only_leaf_regs
)
13168 int leaf_reg
= LEAF_REG_REMAP (reg
);
13169 if (leaf_reg
!= -1)
13170 reg
= (unsigned) leaf_reg
;
13174 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
13175 nregs
= REG_NREGS (rtl
);
13177 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
13182 dw_loc_descr_ref t
;
13184 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
13185 VAR_INIT_STATUS_INITIALIZED
);
13186 add_loc_descr (&loc_result
, t
);
13187 add_loc_descr_op_piece (&loc_result
, size
);
13193 /* Now onto stupid register sets in non contiguous locations. */
13195 gcc_assert (GET_CODE (regs
) == PARALLEL
);
13197 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
13200 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
13202 dw_loc_descr_ref t
;
13204 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
13205 VAR_INIT_STATUS_INITIALIZED
);
13206 add_loc_descr (&loc_result
, t
);
13207 add_loc_descr_op_piece (&loc_result
, size
);
13210 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13211 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13215 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
13217 /* Return a location descriptor that designates a constant i,
13218 as a compound operation from constant (i >> shift), constant shift
13221 static dw_loc_descr_ref
13222 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
13224 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
13225 add_loc_descr (&ret
, int_loc_descriptor (shift
));
13226 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
13230 /* Return a location descriptor that designates a constant. */
13232 static dw_loc_descr_ref
13233 int_loc_descriptor (HOST_WIDE_INT i
)
13235 enum dwarf_location_atom op
;
13237 /* Pick the smallest representation of a constant, rather than just
13238 defaulting to the LEB encoding. */
13241 int clz
= clz_hwi (i
);
13242 int ctz
= ctz_hwi (i
);
13244 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
13245 else if (i
<= 0xff)
13246 op
= DW_OP_const1u
;
13247 else if (i
<= 0xffff)
13248 op
= DW_OP_const2u
;
13249 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
13250 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
13251 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
13252 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
13253 while DW_OP_const4u is 5 bytes. */
13254 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
13255 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13256 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
13257 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
13258 while DW_OP_const4u is 5 bytes. */
13259 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13261 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
13262 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
13265 /* As i >= 2**31, the double cast above will yield a negative number.
13266 Since wrapping is defined in DWARF expressions we can output big
13267 positive integers as small negative ones, regardless of the size
13270 Here, since the evaluator will handle 32-bit values and since i >=
13271 2**31, we know it's going to be interpreted as a negative literal:
13272 store it this way if we can do better than 5 bytes this way. */
13273 return int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
13275 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13276 op
= DW_OP_const4u
;
13278 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
13279 least 6 bytes: see if we can do better before falling back to it. */
13280 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13281 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
13282 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
13283 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13284 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
13285 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
13286 >= HOST_BITS_PER_WIDE_INT
)
13287 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
13288 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
13289 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
13290 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
13291 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
13292 && size_of_uleb128 (i
) > 6)
13293 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
13294 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
13301 op
= DW_OP_const1s
;
13302 else if (i
>= -0x8000)
13303 op
= DW_OP_const2s
;
13304 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
13306 if (size_of_int_loc_descriptor (i
) < 5)
13308 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
13309 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13312 op
= DW_OP_const4s
;
13316 if (size_of_int_loc_descriptor (i
)
13317 < (unsigned long) 1 + size_of_sleb128 (i
))
13319 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
13320 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13327 return new_loc_descr (op
, i
, 0);
13330 /* Likewise, for unsigned constants. */
13332 static dw_loc_descr_ref
13333 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
13335 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
13336 const unsigned HOST_WIDE_INT max_uint
13337 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
13339 /* If possible, use the clever signed constants handling. */
13341 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
13343 /* Here, we are left with positive numbers that cannot be represented as
13344 HOST_WIDE_INT, i.e.:
13345 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
13347 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
13348 whereas may be better to output a negative integer: thanks to integer
13349 wrapping, we know that:
13350 x = x - 2 ** DWARF2_ADDR_SIZE
13351 = x - 2 * (max (HOST_WIDE_INT) + 1)
13352 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
13353 small negative integers. Let's try that in cases it will clearly improve
13354 the encoding: there is no gain turning DW_OP_const4u into
13356 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
13357 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
13358 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
13360 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
13362 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
13363 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
13364 const HOST_WIDE_INT second_shift
13365 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
13367 /* So we finally have:
13368 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
13369 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
13370 return int_loc_descriptor (second_shift
);
13373 /* Last chance: fallback to a simple constant operation. */
13374 return new_loc_descr
13375 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13381 /* Generate and return a location description that computes the unsigned
13382 comparison of the two stack top entries (a OP b where b is the top-most
13383 entry and a is the second one). The KIND of comparison can be LT_EXPR,
13384 LE_EXPR, GT_EXPR or GE_EXPR. */
13386 static dw_loc_descr_ref
13387 uint_comparison_loc_list (enum tree_code kind
)
13389 enum dwarf_location_atom op
, flip_op
;
13390 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
13407 gcc_unreachable ();
13410 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
13411 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
13413 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
13414 possible to perform unsigned comparisons: we just have to distinguish
13417 1. when a and b have the same sign (as signed integers); then we should
13418 return: a OP(signed) b;
13420 2. when a is a negative signed integer while b is a positive one, then a
13421 is a greater unsigned integer than b; likewise when a and b's roles
13424 So first, compare the sign of the two operands. */
13425 ret
= new_loc_descr (DW_OP_over
, 0, 0);
13426 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
13427 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
13428 /* If they have different signs (i.e. they have different sign bits), then
13429 the stack top value has now the sign bit set and thus it's smaller than
13431 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
13432 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
13433 add_loc_descr (&ret
, bra_node
);
13435 /* We are in case 1. At this point, we know both operands have the same
13436 sign, to it's safe to use the built-in signed comparison. */
13437 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
13438 add_loc_descr (&ret
, jmp_node
);
13440 /* We are in case 2. Here, we know both operands do not have the same sign,
13441 so we have to flip the signed comparison. */
13442 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
13443 tmp
= new_loc_descr (flip_op
, 0, 0);
13444 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13445 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
13446 add_loc_descr (&ret
, tmp
);
13448 /* This dummy operation is necessary to make the two branches join. */
13449 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
13450 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13451 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
13452 add_loc_descr (&ret
, tmp
);
13457 /* Likewise, but takes the location description lists (might be destructive on
13458 them). Return NULL if either is NULL or if concatenation fails. */
13460 static dw_loc_list_ref
13461 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
13462 enum tree_code kind
)
13464 if (left
== NULL
|| right
== NULL
)
13467 add_loc_list (&left
, right
);
13471 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
13475 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
13476 without actually allocating it. */
13478 static unsigned long
13479 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
13481 return size_of_int_loc_descriptor (i
>> shift
)
13482 + size_of_int_loc_descriptor (shift
)
13486 /* Return size_of_locs (int_loc_descriptor (i)) without
13487 actually allocating it. */
13489 static unsigned long
13490 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
13499 else if (i
<= 0xff)
13501 else if (i
<= 0xffff)
13505 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
13506 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
13507 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13509 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13510 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
13511 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13513 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
13514 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
13516 return size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
13517 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13519 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
13520 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13521 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
13522 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13524 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
13525 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
13526 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13528 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
13529 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
13531 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13540 else if (i
>= -0x8000)
13542 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
13544 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
13546 s
= size_of_int_loc_descriptor (-i
) + 1;
13554 unsigned long r
= 1 + size_of_sleb128 (i
);
13555 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
13557 s
= size_of_int_loc_descriptor (-i
) + 1;
13566 /* Return loc description representing "address" of integer value.
13567 This can appear only as toplevel expression. */
13569 static dw_loc_descr_ref
13570 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
13573 dw_loc_descr_ref loc_result
= NULL
;
13575 if (!(dwarf_version
>= 4 || !dwarf_strict
))
13578 litsize
= size_of_int_loc_descriptor (i
);
13579 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
13580 is more compact. For DW_OP_stack_value we need:
13581 litsize + 1 (DW_OP_stack_value)
13582 and for DW_OP_implicit_value:
13583 1 (DW_OP_implicit_value) + 1 (length) + size. */
13584 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
13586 loc_result
= int_loc_descriptor (i
);
13587 add_loc_descr (&loc_result
,
13588 new_loc_descr (DW_OP_stack_value
, 0, 0));
13592 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13594 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13595 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
13599 /* Return a location descriptor that designates a base+offset location. */
13601 static dw_loc_descr_ref
13602 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
13603 enum var_init_status initialized
)
13605 unsigned int regno
;
13606 dw_loc_descr_ref result
;
13607 dw_fde_ref fde
= cfun
->fde
;
13609 /* We only use "frame base" when we're sure we're talking about the
13610 post-prologue local stack frame. We do this by *not* running
13611 register elimination until this point, and recognizing the special
13612 argument pointer and soft frame pointer rtx's. */
13613 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
13615 rtx elim
= (ira_use_lra_p
13616 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
13617 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
13621 if (GET_CODE (elim
) == PLUS
)
13623 offset
+= INTVAL (XEXP (elim
, 1));
13624 elim
= XEXP (elim
, 0);
13626 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
13627 && (elim
== hard_frame_pointer_rtx
13628 || elim
== stack_pointer_rtx
))
13629 || elim
== (frame_pointer_needed
13630 ? hard_frame_pointer_rtx
13631 : stack_pointer_rtx
));
13633 /* If drap register is used to align stack, use frame
13634 pointer + offset to access stack variables. If stack
13635 is aligned without drap, use stack pointer + offset to
13636 access stack variables. */
13637 if (crtl
->stack_realign_tried
13638 && reg
== frame_pointer_rtx
)
13641 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
13642 ? HARD_FRAME_POINTER_REGNUM
13644 return new_reg_loc_descr (base_reg
, offset
);
13647 gcc_assert (frame_pointer_fb_offset_valid
);
13648 offset
+= frame_pointer_fb_offset
;
13649 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
13653 regno
= REGNO (reg
);
13654 #ifdef LEAF_REG_REMAP
13655 if (crtl
->uses_only_leaf_regs
)
13657 int leaf_reg
= LEAF_REG_REMAP (regno
);
13658 if (leaf_reg
!= -1)
13659 regno
= (unsigned) leaf_reg
;
13662 regno
= DWARF_FRAME_REGNUM (regno
);
13664 if (!optimize
&& fde
13665 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
))
13667 /* Use cfa+offset to represent the location of arguments passed
13668 on the stack when drap is used to align stack.
13669 Only do this when not optimizing, for optimized code var-tracking
13670 is supposed to track where the arguments live and the register
13671 used as vdrap or drap in some spot might be used for something
13672 else in other part of the routine. */
13673 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
13677 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
13680 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
13682 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13683 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13688 /* Return true if this RTL expression describes a base+offset calculation. */
13691 is_based_loc (const_rtx rtl
)
13693 return (GET_CODE (rtl
) == PLUS
13694 && ((REG_P (XEXP (rtl
, 0))
13695 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
13696 && CONST_INT_P (XEXP (rtl
, 1)))));
13699 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
13702 static dw_loc_descr_ref
13703 tls_mem_loc_descriptor (rtx mem
)
13706 dw_loc_descr_ref loc_result
;
13708 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
13711 base
= get_base_address (MEM_EXPR (mem
));
13714 || !DECL_THREAD_LOCAL_P (base
))
13717 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
13718 if (loc_result
== NULL
)
13721 if (MEM_OFFSET (mem
))
13722 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
13727 /* Output debug info about reason why we failed to expand expression as dwarf
13731 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
13733 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
13735 fprintf (dump_file
, "Failed to expand as dwarf: ");
13737 print_generic_expr (dump_file
, expr
, dump_flags
);
13740 fprintf (dump_file
, "\n");
13741 print_rtl (dump_file
, rtl
);
13743 fprintf (dump_file
, "\nReason: %s\n", reason
);
13747 /* Helper function for const_ok_for_output. */
13750 const_ok_for_output_1 (rtx rtl
)
13752 if (GET_CODE (rtl
) == UNSPEC
)
13754 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
13755 we can't express it in the debug info. */
13756 /* Don't complain about TLS UNSPECs, those are just too hard to
13757 delegitimize. Note this could be a non-decl SYMBOL_REF such as
13758 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
13759 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
13761 && (XVECLEN (rtl
, 0) == 0
13762 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
13763 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
13764 inform (current_function_decl
13765 ? DECL_SOURCE_LOCATION (current_function_decl
)
13766 : UNKNOWN_LOCATION
,
13767 #if NUM_UNSPEC_VALUES > 0
13768 "non-delegitimized UNSPEC %s (%d) found in variable location",
13769 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
13770 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
13773 "non-delegitimized UNSPEC %d found in variable location",
13776 expansion_failed (NULL_TREE
, rtl
,
13777 "UNSPEC hasn't been delegitimized.\n");
13781 if (targetm
.const_not_ok_for_debug_p (rtl
))
13783 expansion_failed (NULL_TREE
, rtl
,
13784 "Expression rejected for debug by the backend.\n");
13788 /* FIXME: Refer to PR60655. It is possible for simplification
13789 of rtl expressions in var tracking to produce such expressions.
13790 We should really identify / validate expressions
13791 enclosed in CONST that can be handled by assemblers on various
13792 targets and only handle legitimate cases here. */
13793 if (GET_CODE (rtl
) != SYMBOL_REF
)
13795 if (GET_CODE (rtl
) == NOT
)
13800 if (CONSTANT_POOL_ADDRESS_P (rtl
))
13803 get_pool_constant_mark (rtl
, &marked
);
13804 /* If all references to this pool constant were optimized away,
13805 it was not output and thus we can't represent it. */
13808 expansion_failed (NULL_TREE
, rtl
,
13809 "Constant was removed from constant pool.\n");
13814 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
13817 /* Avoid references to external symbols in debug info, on several targets
13818 the linker might even refuse to link when linking a shared library,
13819 and in many other cases the relocations for .debug_info/.debug_loc are
13820 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
13821 to be defined within the same shared library or executable are fine. */
13822 if (SYMBOL_REF_EXTERNAL_P (rtl
))
13824 tree decl
= SYMBOL_REF_DECL (rtl
);
13826 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
13828 expansion_failed (NULL_TREE
, rtl
,
13829 "Symbol not defined in current TU.\n");
13837 /* Return true if constant RTL can be emitted in DW_OP_addr or
13838 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
13839 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
13842 const_ok_for_output (rtx rtl
)
13844 if (GET_CODE (rtl
) == SYMBOL_REF
)
13845 return const_ok_for_output_1 (rtl
);
13847 if (GET_CODE (rtl
) == CONST
)
13849 subrtx_var_iterator::array_type array
;
13850 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
13851 if (!const_ok_for_output_1 (*iter
))
13859 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
13860 if possible, NULL otherwise. */
13863 base_type_for_mode (machine_mode mode
, bool unsignedp
)
13865 dw_die_ref type_die
;
13866 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
13870 switch (TREE_CODE (type
))
13878 type_die
= lookup_type_die (type
);
13880 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
13882 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
13887 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
13888 type matching MODE, or, if MODE is narrower than or as wide as
13889 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
13892 static dw_loc_descr_ref
13893 convert_descriptor_to_mode (machine_mode mode
, dw_loc_descr_ref op
)
13895 machine_mode outer_mode
= mode
;
13896 dw_die_ref type_die
;
13897 dw_loc_descr_ref cvt
;
13899 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
13901 add_loc_descr (&op
, new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
13904 type_die
= base_type_for_mode (outer_mode
, 1);
13905 if (type_die
== NULL
)
13907 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
13908 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13909 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13910 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13911 add_loc_descr (&op
, cvt
);
13915 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
13917 static dw_loc_descr_ref
13918 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
13919 dw_loc_descr_ref op1
)
13921 dw_loc_descr_ref ret
= op0
;
13922 add_loc_descr (&ret
, op1
);
13923 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
13924 if (STORE_FLAG_VALUE
!= 1)
13926 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
13927 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
13932 /* Subroutine of scompare_loc_descriptor for the case in which we're
13933 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
13934 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
13936 static dw_loc_descr_ref
13937 scompare_loc_descriptor_wide (enum dwarf_location_atom op
,
13938 machine_mode op_mode
,
13939 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
13941 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
13942 dw_loc_descr_ref cvt
;
13944 if (type_die
== NULL
)
13946 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
13947 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13948 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13949 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13950 add_loc_descr (&op0
, cvt
);
13951 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
13952 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13953 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13954 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13955 add_loc_descr (&op1
, cvt
);
13956 return compare_loc_descriptor (op
, op0
, op1
);
13959 /* Subroutine of scompare_loc_descriptor for the case in which we're
13960 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
13961 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
13963 static dw_loc_descr_ref
13964 scompare_loc_descriptor_narrow (enum dwarf_location_atom op
, rtx rtl
,
13965 machine_mode op_mode
,
13966 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
13968 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
13969 /* For eq/ne, if the operands are known to be zero-extended,
13970 there is no need to do the fancy shifting up. */
13971 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
13973 dw_loc_descr_ref last0
, last1
;
13974 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
13976 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
13978 /* deref_size zero extends, and for constants we can check
13979 whether they are zero extended or not. */
13980 if (((last0
->dw_loc_opc
== DW_OP_deref_size
13981 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
13982 || (CONST_INT_P (XEXP (rtl
, 0))
13983 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
13984 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
13985 && ((last1
->dw_loc_opc
== DW_OP_deref_size
13986 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
13987 || (CONST_INT_P (XEXP (rtl
, 1))
13988 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
13989 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
13990 return compare_loc_descriptor (op
, op0
, op1
);
13992 /* EQ/NE comparison against constant in narrower type than
13993 DWARF2_ADDR_SIZE can be performed either as
13994 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
13997 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
13998 DW_OP_{eq,ne}. Pick whatever is shorter. */
13999 if (CONST_INT_P (XEXP (rtl
, 1))
14000 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
14001 && (size_of_int_loc_descriptor (shift
) + 1
14002 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
)
14003 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
14004 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14005 & GET_MODE_MASK (op_mode
))))
14007 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
14008 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14009 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14010 & GET_MODE_MASK (op_mode
));
14011 return compare_loc_descriptor (op
, op0
, op1
);
14014 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14015 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14016 if (CONST_INT_P (XEXP (rtl
, 1)))
14017 op1
= int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
);
14020 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14021 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14023 return compare_loc_descriptor (op
, op0
, op1
);
14026 /* Return location descriptor for signed comparison OP RTL. */
14028 static dw_loc_descr_ref
14029 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14030 machine_mode mem_mode
)
14032 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
14033 dw_loc_descr_ref op0
, op1
;
14035 if (op_mode
== VOIDmode
)
14036 op_mode
= GET_MODE (XEXP (rtl
, 1));
14037 if (op_mode
== VOIDmode
)
14041 && dwarf_version
< 5
14042 && (!SCALAR_INT_MODE_P (op_mode
)
14043 || GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
))
14046 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14047 VAR_INIT_STATUS_INITIALIZED
);
14048 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14049 VAR_INIT_STATUS_INITIALIZED
);
14051 if (op0
== NULL
|| op1
== NULL
)
14054 if (SCALAR_INT_MODE_P (op_mode
))
14056 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
14057 return scompare_loc_descriptor_narrow (op
, rtl
, op_mode
, op0
, op1
);
14059 if (GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
14060 return scompare_loc_descriptor_wide (op
, op_mode
, op0
, op1
);
14062 return compare_loc_descriptor (op
, op0
, op1
);
14065 /* Return location descriptor for unsigned comparison OP RTL. */
14067 static dw_loc_descr_ref
14068 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14069 machine_mode mem_mode
)
14071 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
14072 dw_loc_descr_ref op0
, op1
;
14074 if (op_mode
== VOIDmode
)
14075 op_mode
= GET_MODE (XEXP (rtl
, 1));
14076 if (op_mode
== VOIDmode
)
14078 if (!SCALAR_INT_MODE_P (op_mode
))
14082 && dwarf_version
< 5
14083 && GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
14086 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14087 VAR_INIT_STATUS_INITIALIZED
);
14088 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14089 VAR_INIT_STATUS_INITIALIZED
);
14091 if (op0
== NULL
|| op1
== NULL
)
14094 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
14096 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
14097 dw_loc_descr_ref last0
, last1
;
14098 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14100 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14102 if (CONST_INT_P (XEXP (rtl
, 0)))
14103 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
14104 /* deref_size zero extends, so no need to mask it again. */
14105 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
14106 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14108 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14109 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14111 if (CONST_INT_P (XEXP (rtl
, 1)))
14112 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
14113 /* deref_size zero extends, so no need to mask it again. */
14114 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
14115 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14117 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14118 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14121 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
14123 HOST_WIDE_INT bias
= 1;
14124 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14125 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14126 if (CONST_INT_P (XEXP (rtl
, 1)))
14127 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
14128 + INTVAL (XEXP (rtl
, 1)));
14130 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
14133 return compare_loc_descriptor (op
, op0
, op1
);
14136 /* Return location descriptor for {U,S}{MIN,MAX}. */
14138 static dw_loc_descr_ref
14139 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
14140 machine_mode mem_mode
)
14142 enum dwarf_location_atom op
;
14143 dw_loc_descr_ref op0
, op1
, ret
;
14144 dw_loc_descr_ref bra_node
, drop_node
;
14147 && dwarf_version
< 5
14148 && (!SCALAR_INT_MODE_P (mode
)
14149 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
))
14152 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14153 VAR_INIT_STATUS_INITIALIZED
);
14154 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14155 VAR_INIT_STATUS_INITIALIZED
);
14157 if (op0
== NULL
|| op1
== NULL
)
14160 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
14161 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
14162 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
14163 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
14165 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
14167 HOST_WIDE_INT mask
= GET_MODE_MASK (mode
);
14168 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14169 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14170 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14171 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14173 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
14175 HOST_WIDE_INT bias
= 1;
14176 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14177 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14178 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14181 else if (!SCALAR_INT_MODE_P (mode
)
14182 && GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
14184 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (mode
)) * BITS_PER_UNIT
;
14185 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14186 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14187 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14188 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14190 else if (SCALAR_INT_MODE_P (mode
)
14191 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
14193 dw_die_ref type_die
= base_type_for_mode (mode
, 0);
14194 dw_loc_descr_ref cvt
;
14195 if (type_die
== NULL
)
14197 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14198 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14199 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14200 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14201 add_loc_descr (&op0
, cvt
);
14202 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14203 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14204 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14205 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14206 add_loc_descr (&op1
, cvt
);
14209 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
14214 add_loc_descr (&ret
, op1
);
14215 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14216 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14217 add_loc_descr (&ret
, bra_node
);
14218 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14219 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
14220 add_loc_descr (&ret
, drop_node
);
14221 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14222 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
14223 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
14224 && SCALAR_INT_MODE_P (mode
)
14225 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
14226 ret
= convert_descriptor_to_mode (mode
, ret
);
14230 /* Helper function for mem_loc_descriptor. Perform OP binary op,
14231 but after converting arguments to type_die, afterwards
14232 convert back to unsigned. */
14234 static dw_loc_descr_ref
14235 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
14236 machine_mode mode
, machine_mode mem_mode
)
14238 dw_loc_descr_ref cvt
, op0
, op1
;
14240 if (type_die
== NULL
)
14242 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14243 VAR_INIT_STATUS_INITIALIZED
);
14244 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14245 VAR_INIT_STATUS_INITIALIZED
);
14246 if (op0
== NULL
|| op1
== NULL
)
14248 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14249 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14250 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14251 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14252 add_loc_descr (&op0
, cvt
);
14253 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14254 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14255 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14256 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14257 add_loc_descr (&op1
, cvt
);
14258 add_loc_descr (&op0
, op1
);
14259 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
14260 return convert_descriptor_to_mode (mode
, op0
);
14263 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
14264 const0 is DW_OP_lit0 or corresponding typed constant,
14265 const1 is DW_OP_lit1 or corresponding typed constant
14266 and constMSB is constant with just the MSB bit set
14268 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14269 L1: const0 DW_OP_swap
14270 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
14271 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14276 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14277 L1: const0 DW_OP_swap
14278 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
14279 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14284 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
14285 L1: const1 DW_OP_swap
14286 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
14287 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14291 static dw_loc_descr_ref
14292 clz_loc_descriptor (rtx rtl
, machine_mode mode
,
14293 machine_mode mem_mode
)
14295 dw_loc_descr_ref op0
, ret
, tmp
;
14296 HOST_WIDE_INT valv
;
14297 dw_loc_descr_ref l1jump
, l1label
;
14298 dw_loc_descr_ref l2jump
, l2label
;
14299 dw_loc_descr_ref l3jump
, l3label
;
14300 dw_loc_descr_ref l4jump
, l4label
;
14303 if (!SCALAR_INT_MODE_P (mode
)
14304 || GET_MODE (XEXP (rtl
, 0)) != mode
)
14307 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14308 VAR_INIT_STATUS_INITIALIZED
);
14312 if (GET_CODE (rtl
) == CLZ
)
14314 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
14315 valv
= GET_MODE_BITSIZE (mode
);
14317 else if (GET_CODE (rtl
) == FFS
)
14319 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
14320 valv
= GET_MODE_BITSIZE (mode
);
14321 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
14322 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14323 add_loc_descr (&ret
, l1jump
);
14324 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
14325 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
14326 VAR_INIT_STATUS_INITIALIZED
);
14329 add_loc_descr (&ret
, tmp
);
14330 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
14331 add_loc_descr (&ret
, l4jump
);
14332 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
14333 ? const1_rtx
: const0_rtx
,
14335 VAR_INIT_STATUS_INITIALIZED
);
14336 if (l1label
== NULL
)
14338 add_loc_descr (&ret
, l1label
);
14339 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14340 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
14341 add_loc_descr (&ret
, l2label
);
14342 if (GET_CODE (rtl
) != CLZ
)
14344 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
14345 msb
= GEN_INT (HOST_WIDE_INT_1U
14346 << (GET_MODE_BITSIZE (mode
) - 1));
14348 msb
= immed_wide_int_const
14349 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
14350 GET_MODE_PRECISION (mode
)), mode
);
14351 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
14352 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
14353 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
14354 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
14356 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
14357 VAR_INIT_STATUS_INITIALIZED
);
14360 add_loc_descr (&ret
, tmp
);
14361 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
14362 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14363 add_loc_descr (&ret
, l3jump
);
14364 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
14365 VAR_INIT_STATUS_INITIALIZED
);
14368 add_loc_descr (&ret
, tmp
);
14369 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
14370 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
14371 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14372 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
14373 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14374 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
14375 add_loc_descr (&ret
, l2jump
);
14376 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
14377 add_loc_descr (&ret
, l3label
);
14378 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
14379 add_loc_descr (&ret
, l4label
);
14380 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14381 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
14382 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14383 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
14384 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14385 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
14386 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14387 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
14391 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
14392 const1 is DW_OP_lit1 or corresponding typed constant):
14394 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
14395 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
14399 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
14400 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
14403 static dw_loc_descr_ref
14404 popcount_loc_descriptor (rtx rtl
, machine_mode mode
,
14405 machine_mode mem_mode
)
14407 dw_loc_descr_ref op0
, ret
, tmp
;
14408 dw_loc_descr_ref l1jump
, l1label
;
14409 dw_loc_descr_ref l2jump
, l2label
;
14411 if (!SCALAR_INT_MODE_P (mode
)
14412 || GET_MODE (XEXP (rtl
, 0)) != mode
)
14415 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14416 VAR_INIT_STATUS_INITIALIZED
);
14420 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
14421 VAR_INIT_STATUS_INITIALIZED
);
14424 add_loc_descr (&ret
, tmp
);
14425 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14426 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
14427 add_loc_descr (&ret
, l1label
);
14428 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14429 add_loc_descr (&ret
, l2jump
);
14430 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
14431 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
14432 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
14433 VAR_INIT_STATUS_INITIALIZED
);
14436 add_loc_descr (&ret
, tmp
);
14437 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
14438 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
14439 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
14440 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14441 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
14442 VAR_INIT_STATUS_INITIALIZED
);
14443 add_loc_descr (&ret
, tmp
);
14444 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
14445 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
14446 add_loc_descr (&ret
, l1jump
);
14447 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
14448 add_loc_descr (&ret
, l2label
);
14449 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14450 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
14451 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14452 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
14456 /* BSWAP (constS is initial shift count, either 56 or 24):
14458 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
14459 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
14460 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
14461 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
14462 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
14464 static dw_loc_descr_ref
14465 bswap_loc_descriptor (rtx rtl
, machine_mode mode
,
14466 machine_mode mem_mode
)
14468 dw_loc_descr_ref op0
, ret
, tmp
;
14469 dw_loc_descr_ref l1jump
, l1label
;
14470 dw_loc_descr_ref l2jump
, l2label
;
14472 if (!SCALAR_INT_MODE_P (mode
)
14473 || BITS_PER_UNIT
!= 8
14474 || (GET_MODE_BITSIZE (mode
) != 32
14475 && GET_MODE_BITSIZE (mode
) != 64))
14478 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14479 VAR_INIT_STATUS_INITIALIZED
);
14484 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
14486 VAR_INIT_STATUS_INITIALIZED
);
14489 add_loc_descr (&ret
, tmp
);
14490 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
14491 VAR_INIT_STATUS_INITIALIZED
);
14494 add_loc_descr (&ret
, tmp
);
14495 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
14496 add_loc_descr (&ret
, l1label
);
14497 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
14499 VAR_INIT_STATUS_INITIALIZED
);
14500 add_loc_descr (&ret
, tmp
);
14501 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
14502 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14503 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
14504 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
14505 VAR_INIT_STATUS_INITIALIZED
);
14508 add_loc_descr (&ret
, tmp
);
14509 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
14510 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
14511 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
14512 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
14513 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14514 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
14515 tmp
= mem_loc_descriptor (const0_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_eq
, 0, 0));
14519 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14520 add_loc_descr (&ret
, l2jump
);
14521 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
14522 VAR_INIT_STATUS_INITIALIZED
);
14523 add_loc_descr (&ret
, tmp
);
14524 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14525 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14526 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
14527 add_loc_descr (&ret
, l1jump
);
14528 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
14529 add_loc_descr (&ret
, l2label
);
14530 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14531 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
14532 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14533 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
14534 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14535 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
14539 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
14540 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
14541 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
14542 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
14544 ROTATERT is similar:
14545 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
14546 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
14547 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
14549 static dw_loc_descr_ref
14550 rotate_loc_descriptor (rtx rtl
, machine_mode mode
,
14551 machine_mode mem_mode
)
14553 rtx rtlop1
= XEXP (rtl
, 1);
14554 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
14557 if (!SCALAR_INT_MODE_P (mode
))
14560 if (GET_MODE (rtlop1
) != VOIDmode
14561 && GET_MODE_BITSIZE (GET_MODE (rtlop1
)) < GET_MODE_BITSIZE (mode
))
14562 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
14563 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14564 VAR_INIT_STATUS_INITIALIZED
);
14565 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
14566 VAR_INIT_STATUS_INITIALIZED
);
14567 if (op0
== NULL
|| op1
== NULL
)
14569 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
14570 for (i
= 0; i
< 2; i
++)
14572 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
14573 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
14575 VAR_INIT_STATUS_INITIALIZED
);
14576 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
14577 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
14579 : HOST_BITS_PER_WIDE_INT
== 64
14580 ? DW_OP_const8u
: DW_OP_constu
,
14581 GET_MODE_MASK (mode
), 0);
14584 if (mask
[i
] == NULL
)
14586 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
14589 add_loc_descr (&ret
, op1
);
14590 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14591 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14592 if (GET_CODE (rtl
) == ROTATERT
)
14594 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14595 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
14596 GET_MODE_BITSIZE (mode
), 0));
14598 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
14599 if (mask
[0] != NULL
)
14600 add_loc_descr (&ret
, mask
[0]);
14601 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
14602 if (mask
[1] != NULL
)
14604 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14605 add_loc_descr (&ret
, mask
[1]);
14606 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14608 if (GET_CODE (rtl
) == ROTATE
)
14610 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14611 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
14612 GET_MODE_BITSIZE (mode
), 0));
14614 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
14615 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
14619 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
14620 for DEBUG_PARAMETER_REF RTL. */
14622 static dw_loc_descr_ref
14623 parameter_ref_descriptor (rtx rtl
)
14625 dw_loc_descr_ref ret
;
14630 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
14631 /* With LTO during LTRANS we get the late DIE that refers to the early
14632 DIE, thus we add another indirection here. This seems to confuse
14633 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
14634 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
14635 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
14638 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14639 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
14640 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14644 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
14645 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
14650 /* The following routine converts the RTL for a variable or parameter
14651 (resident in memory) into an equivalent Dwarf representation of a
14652 mechanism for getting the address of that same variable onto the top of a
14653 hypothetical "address evaluation" stack.
14655 When creating memory location descriptors, we are effectively transforming
14656 the RTL for a memory-resident object into its Dwarf postfix expression
14657 equivalent. This routine recursively descends an RTL tree, turning
14658 it into Dwarf postfix code as it goes.
14660 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
14662 MEM_MODE is the mode of the memory reference, needed to handle some
14663 autoincrement addressing modes.
14665 Return 0 if we can't represent the location. */
14668 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
14669 machine_mode mem_mode
,
14670 enum var_init_status initialized
)
14672 dw_loc_descr_ref mem_loc_result
= NULL
;
14673 enum dwarf_location_atom op
;
14674 dw_loc_descr_ref op0
, op1
;
14675 rtx inner
= NULL_RTX
;
14677 if (mode
== VOIDmode
)
14678 mode
= GET_MODE (rtl
);
14680 /* Note that for a dynamically sized array, the location we will generate a
14681 description of here will be the lowest numbered location which is
14682 actually within the array. That's *not* necessarily the same as the
14683 zeroth element of the array. */
14685 rtl
= targetm
.delegitimize_address (rtl
);
14687 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
14690 switch (GET_CODE (rtl
))
14695 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
14698 /* The case of a subreg may arise when we have a local (register)
14699 variable or a formal (register) parameter which doesn't quite fill
14700 up an entire register. For now, just assume that it is
14701 legitimate to make the Dwarf info refer to the whole register which
14702 contains the given subreg. */
14703 if (!subreg_lowpart_p (rtl
))
14705 inner
= SUBREG_REG (rtl
);
14708 if (inner
== NULL_RTX
)
14709 inner
= XEXP (rtl
, 0);
14710 if (SCALAR_INT_MODE_P (mode
)
14711 && SCALAR_INT_MODE_P (GET_MODE (inner
))
14712 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
14713 #ifdef POINTERS_EXTEND_UNSIGNED
14714 || (mode
== Pmode
&& mem_mode
!= VOIDmode
)
14717 && GET_MODE_SIZE (GET_MODE (inner
)) <= DWARF2_ADDR_SIZE
)
14719 mem_loc_result
= mem_loc_descriptor (inner
,
14721 mem_mode
, initialized
);
14724 if (dwarf_strict
&& dwarf_version
< 5)
14726 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (inner
)))
14728 if (GET_MODE_SIZE (mode
) != GET_MODE_SIZE (GET_MODE (inner
))
14729 && (!SCALAR_INT_MODE_P (mode
)
14730 || !SCALAR_INT_MODE_P (GET_MODE (inner
))))
14734 dw_die_ref type_die
;
14735 dw_loc_descr_ref cvt
;
14737 mem_loc_result
= mem_loc_descriptor (inner
,
14739 mem_mode
, initialized
);
14740 if (mem_loc_result
== NULL
)
14742 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
14743 if (type_die
== NULL
)
14745 mem_loc_result
= NULL
;
14748 if (GET_MODE_SIZE (mode
)
14749 != GET_MODE_SIZE (GET_MODE (inner
)))
14750 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14752 cvt
= new_loc_descr (dwarf_OP (DW_OP_reinterpret
), 0, 0);
14753 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14754 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14755 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14756 add_loc_descr (&mem_loc_result
, cvt
);
14757 if (SCALAR_INT_MODE_P (mode
)
14758 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
14760 /* Convert it to untyped afterwards. */
14761 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14762 add_loc_descr (&mem_loc_result
, cvt
);
14768 if (! SCALAR_INT_MODE_P (mode
)
14769 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
14770 && rtl
!= arg_pointer_rtx
14771 && rtl
!= frame_pointer_rtx
14772 #ifdef POINTERS_EXTEND_UNSIGNED
14773 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
14777 dw_die_ref type_die
;
14778 unsigned int dbx_regnum
;
14780 if (dwarf_strict
&& dwarf_version
< 5)
14782 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
14784 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
14785 if (type_die
== NULL
)
14788 dbx_regnum
= dbx_reg_number (rtl
);
14789 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
14791 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_regval_type
),
14793 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
14794 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
14795 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
14798 /* Whenever a register number forms a part of the description of the
14799 method for calculating the (dynamic) address of a memory resident
14800 object, DWARF rules require the register number be referred to as
14801 a "base register". This distinction is not based in any way upon
14802 what category of register the hardware believes the given register
14803 belongs to. This is strictly DWARF terminology we're dealing with
14804 here. Note that in cases where the location of a memory-resident
14805 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
14806 OP_CONST (0)) the actual DWARF location descriptor that we generate
14807 may just be OP_BASEREG (basereg). This may look deceptively like
14808 the object in question was allocated to a register (rather than in
14809 memory) so DWARF consumers need to be aware of the subtle
14810 distinction between OP_REG and OP_BASEREG. */
14811 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
14812 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
14813 else if (stack_realign_drap
14815 && crtl
->args
.internal_arg_pointer
== rtl
14816 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
14818 /* If RTL is internal_arg_pointer, which has been optimized
14819 out, use DRAP instead. */
14820 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
14821 VAR_INIT_STATUS_INITIALIZED
);
14827 if (!SCALAR_INT_MODE_P (mode
))
14829 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
14830 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
14833 else if (GET_CODE (rtl
) == ZERO_EXTEND
14834 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
14835 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
14836 < HOST_BITS_PER_WIDE_INT
14837 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
14838 to expand zero extend as two shifts instead of
14840 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= 4)
14842 machine_mode imode
= GET_MODE (XEXP (rtl
, 0));
14843 mem_loc_result
= op0
;
14844 add_loc_descr (&mem_loc_result
,
14845 int_loc_descriptor (GET_MODE_MASK (imode
)));
14846 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
14848 else if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
14850 int shift
= DWARF2_ADDR_SIZE
14851 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
14852 shift
*= BITS_PER_UNIT
;
14853 if (GET_CODE (rtl
) == SIGN_EXTEND
)
14857 mem_loc_result
= op0
;
14858 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
14859 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
14860 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
14861 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
14863 else if (!dwarf_strict
|| dwarf_version
>= 5)
14865 dw_die_ref type_die1
, type_die2
;
14866 dw_loc_descr_ref cvt
;
14868 type_die1
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
14869 GET_CODE (rtl
) == ZERO_EXTEND
);
14870 if (type_die1
== NULL
)
14872 type_die2
= base_type_for_mode (mode
, 1);
14873 if (type_die2
== NULL
)
14875 mem_loc_result
= op0
;
14876 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14877 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14878 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
14879 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14880 add_loc_descr (&mem_loc_result
, cvt
);
14881 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14882 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14883 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
14884 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14885 add_loc_descr (&mem_loc_result
, cvt
);
14891 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
14892 if (new_rtl
!= rtl
)
14894 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
14896 if (mem_loc_result
!= NULL
)
14897 return mem_loc_result
;
14900 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
14901 get_address_mode (rtl
), mode
,
14902 VAR_INIT_STATUS_INITIALIZED
);
14903 if (mem_loc_result
== NULL
)
14904 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
14905 if (mem_loc_result
!= NULL
)
14907 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
14908 || !SCALAR_INT_MODE_P(mode
))
14910 dw_die_ref type_die
;
14911 dw_loc_descr_ref deref
;
14913 if (dwarf_strict
&& dwarf_version
< 5)
14916 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
14917 if (type_die
== NULL
)
14919 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
),
14920 GET_MODE_SIZE (mode
), 0);
14921 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
14922 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
14923 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
14924 add_loc_descr (&mem_loc_result
, deref
);
14926 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
14927 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
14929 add_loc_descr (&mem_loc_result
,
14930 new_loc_descr (DW_OP_deref_size
,
14931 GET_MODE_SIZE (mode
), 0));
14936 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
14939 /* Some ports can transform a symbol ref into a label ref, because
14940 the symbol ref is too far away and has to be dumped into a constant
14944 if (!SCALAR_INT_MODE_P (mode
)
14945 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
14946 #ifdef POINTERS_EXTEND_UNSIGNED
14947 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
14951 if (GET_CODE (rtl
) == SYMBOL_REF
14952 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
14954 dw_loc_descr_ref temp
;
14956 /* If this is not defined, we have no way to emit the data. */
14957 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
14960 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
14962 /* We check for DWARF 5 here because gdb did not implement
14963 DW_OP_form_tls_address until after 7.12. */
14964 mem_loc_result
= new_loc_descr ((dwarf_version
>= 5
14965 ? DW_OP_form_tls_address
14966 : DW_OP_GNU_push_tls_address
),
14968 add_loc_descr (&mem_loc_result
, temp
);
14973 if (!const_ok_for_output (rtl
))
14975 if (GET_CODE (rtl
) == CONST
)
14976 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14982 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
14983 vec_safe_push (used_rtx_array
, rtl
);
14989 case DEBUG_IMPLICIT_PTR
:
14990 expansion_failed (NULL_TREE
, rtl
,
14991 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
14995 if (dwarf_strict
&& dwarf_version
< 5)
14997 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
14999 if (!SCALAR_INT_MODE_P (mode
)
15000 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
15001 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15002 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15005 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
15006 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15008 op0
= one_reg_loc_descriptor (dbx_regnum
,
15009 VAR_INIT_STATUS_INITIALIZED
);
15012 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
15013 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
15015 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15016 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15017 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
15021 gcc_unreachable ();
15024 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_entry_value
), 0, 0);
15025 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15026 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
15029 case DEBUG_PARAMETER_REF
:
15030 mem_loc_result
= parameter_ref_descriptor (rtl
);
15034 /* Extract the PLUS expression nested inside and fall into
15035 PLUS code below. */
15036 rtl
= XEXP (rtl
, 1);
15041 /* Turn these into a PLUS expression and fall into the PLUS code
15043 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
15044 gen_int_mode (GET_CODE (rtl
) == PRE_INC
15045 ? GET_MODE_UNIT_SIZE (mem_mode
)
15046 : -GET_MODE_UNIT_SIZE (mem_mode
),
15053 if (is_based_loc (rtl
)
15054 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
15055 || XEXP (rtl
, 0) == arg_pointer_rtx
15056 || XEXP (rtl
, 0) == frame_pointer_rtx
)
15057 && SCALAR_INT_MODE_P (mode
))
15058 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
15059 INTVAL (XEXP (rtl
, 1)),
15060 VAR_INIT_STATUS_INITIALIZED
);
15063 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15064 VAR_INIT_STATUS_INITIALIZED
);
15065 if (mem_loc_result
== 0)
15068 if (CONST_INT_P (XEXP (rtl
, 1))
15069 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
15070 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
15073 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15074 VAR_INIT_STATUS_INITIALIZED
);
15077 add_loc_descr (&mem_loc_result
, op1
);
15078 add_loc_descr (&mem_loc_result
,
15079 new_loc_descr (DW_OP_plus
, 0, 0));
15084 /* If a pseudo-reg is optimized away, it is possible for it to
15085 be replaced with a MEM containing a multiply or shift. */
15095 if ((!dwarf_strict
|| dwarf_version
>= 5)
15096 && SCALAR_INT_MODE_P (mode
)
15097 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
15099 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15100 base_type_for_mode (mode
, 0),
15124 if (!SCALAR_INT_MODE_P (mode
))
15126 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15127 VAR_INIT_STATUS_INITIALIZED
);
15129 rtx rtlop1
= XEXP (rtl
, 1);
15130 if (GET_MODE (rtlop1
) != VOIDmode
15131 && GET_MODE_BITSIZE (GET_MODE (rtlop1
))
15132 < GET_MODE_BITSIZE (mode
))
15133 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
15134 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
15135 VAR_INIT_STATUS_INITIALIZED
);
15138 if (op0
== 0 || op1
== 0)
15141 mem_loc_result
= op0
;
15142 add_loc_descr (&mem_loc_result
, op1
);
15143 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15159 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15160 VAR_INIT_STATUS_INITIALIZED
);
15161 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15162 VAR_INIT_STATUS_INITIALIZED
);
15164 if (op0
== 0 || op1
== 0)
15167 mem_loc_result
= op0
;
15168 add_loc_descr (&mem_loc_result
, op1
);
15169 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15173 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
15174 && (!dwarf_strict
|| dwarf_version
>= 5))
15176 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
15177 base_type_for_mode (mode
, 0),
15182 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15183 VAR_INIT_STATUS_INITIALIZED
);
15184 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15185 VAR_INIT_STATUS_INITIALIZED
);
15187 if (op0
== 0 || op1
== 0)
15190 mem_loc_result
= op0
;
15191 add_loc_descr (&mem_loc_result
, op1
);
15192 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15193 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15194 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
15195 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
15196 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
15200 if ((!dwarf_strict
|| dwarf_version
>= 5)
15201 && SCALAR_INT_MODE_P (mode
))
15203 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
15208 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15209 base_type_for_mode (mode
, 1),
15227 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15228 VAR_INIT_STATUS_INITIALIZED
);
15233 mem_loc_result
= op0
;
15234 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15238 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
15239 #ifdef POINTERS_EXTEND_UNSIGNED
15241 && mem_mode
!= VOIDmode
15242 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
15246 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15249 if ((!dwarf_strict
|| dwarf_version
>= 5)
15250 && (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
15251 || GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_DOUBLE_INT
))
15253 dw_die_ref type_die
= base_type_for_mode (mode
, 1);
15254 scalar_int_mode amode
;
15255 if (type_die
== NULL
)
15257 if (INTVAL (rtl
) >= 0
15258 && (int_mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
, 0)
15260 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
15261 /* const DW_OP_convert <XXX> vs.
15262 DW_OP_const_type <XXX, 1, const>. */
15263 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
15264 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode
))
15266 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15267 op0
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15268 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15269 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15270 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15271 add_loc_descr (&mem_loc_result
, op0
);
15272 return mem_loc_result
;
15274 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0,
15276 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15277 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15278 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15279 if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
15280 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
15283 mem_loc_result
->dw_loc_oprnd2
.val_class
15284 = dw_val_class_const_double
;
15285 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
15286 = double_int::from_shwi (INTVAL (rtl
));
15292 if (!dwarf_strict
|| dwarf_version
>= 5)
15294 dw_die_ref type_die
;
15296 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
15297 CONST_DOUBLE rtx could represent either a large integer
15298 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
15299 the value is always a floating point constant.
15301 When it is an integer, a CONST_DOUBLE is used whenever
15302 the constant requires 2 HWIs to be adequately represented.
15303 We output CONST_DOUBLEs as blocks. */
15304 if (mode
== VOIDmode
15305 || (GET_MODE (rtl
) == VOIDmode
15306 && GET_MODE_BITSIZE (mode
) != HOST_BITS_PER_DOUBLE_INT
))
15308 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15309 if (type_die
== NULL
)
15311 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
15312 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15313 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15314 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15315 #if TARGET_SUPPORTS_WIDE_INT == 0
15316 if (!SCALAR_FLOAT_MODE_P (mode
))
15318 mem_loc_result
->dw_loc_oprnd2
.val_class
15319 = dw_val_class_const_double
;
15320 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
15321 = rtx_to_double_int (rtl
);
15326 scalar_float_mode float_mode
= as_a
<scalar_float_mode
> (mode
);
15327 unsigned int length
= GET_MODE_SIZE (float_mode
);
15328 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
15330 insert_float (rtl
, array
);
15331 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
15332 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
15333 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
15334 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
15339 case CONST_WIDE_INT
:
15340 if (!dwarf_strict
|| dwarf_version
>= 5)
15342 dw_die_ref type_die
;
15344 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15345 if (type_die
== NULL
)
15347 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
15348 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15349 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15350 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15351 mem_loc_result
->dw_loc_oprnd2
.val_class
15352 = dw_val_class_wide_int
;
15353 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
15354 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, mode
);
15359 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
15363 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
15367 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
15371 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
15375 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
15379 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
15383 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
15387 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
15391 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
15395 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
15400 if (!SCALAR_INT_MODE_P (mode
))
15405 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
15410 if (CONST_INT_P (XEXP (rtl
, 1))
15411 && CONST_INT_P (XEXP (rtl
, 2))
15412 && ((unsigned) INTVAL (XEXP (rtl
, 1))
15413 + (unsigned) INTVAL (XEXP (rtl
, 2))
15414 <= GET_MODE_BITSIZE (mode
))
15415 && SCALAR_INT_MODE_P (mode
)
15416 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
15417 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
15420 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
15421 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15424 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
15428 mem_loc_result
= op0
;
15429 size
= INTVAL (XEXP (rtl
, 1));
15430 shift
= INTVAL (XEXP (rtl
, 2));
15431 if (BITS_BIG_ENDIAN
)
15432 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
15434 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
15436 add_loc_descr (&mem_loc_result
,
15437 int_loc_descriptor (DWARF2_ADDR_SIZE
15439 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
15441 if (size
!= (int) DWARF2_ADDR_SIZE
)
15443 add_loc_descr (&mem_loc_result
,
15444 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
15445 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15452 dw_loc_descr_ref op2
, bra_node
, drop_node
;
15453 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
15454 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
15455 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
15456 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15457 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15458 VAR_INIT_STATUS_INITIALIZED
);
15459 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
15460 VAR_INIT_STATUS_INITIALIZED
);
15461 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
15464 mem_loc_result
= op1
;
15465 add_loc_descr (&mem_loc_result
, op2
);
15466 add_loc_descr (&mem_loc_result
, op0
);
15467 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
15468 add_loc_descr (&mem_loc_result
, bra_node
);
15469 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
15470 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
15471 add_loc_descr (&mem_loc_result
, drop_node
);
15472 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15473 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
15478 case FLOAT_TRUNCATE
:
15480 case UNSIGNED_FLOAT
:
15483 if (!dwarf_strict
|| dwarf_version
>= 5)
15485 dw_die_ref type_die
;
15486 dw_loc_descr_ref cvt
;
15488 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
15489 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15492 if (SCALAR_INT_MODE_P (GET_MODE (XEXP (rtl
, 0)))
15493 && (GET_CODE (rtl
) == FLOAT
15494 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)))
15495 <= DWARF2_ADDR_SIZE
))
15497 type_die
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
15498 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
15499 if (type_die
== NULL
)
15501 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15502 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15503 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15504 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15505 add_loc_descr (&op0
, cvt
);
15507 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
15508 if (type_die
== NULL
)
15510 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15511 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15512 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15513 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15514 add_loc_descr (&op0
, cvt
);
15515 if (SCALAR_INT_MODE_P (mode
)
15516 && (GET_CODE (rtl
) == FIX
15517 || GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
))
15519 op0
= convert_descriptor_to_mode (mode
, op0
);
15523 mem_loc_result
= op0
;
15530 mem_loc_result
= clz_loc_descriptor (rtl
, mode
, mem_mode
);
15535 mem_loc_result
= popcount_loc_descriptor (rtl
, mode
, mem_mode
);
15539 mem_loc_result
= bswap_loc_descriptor (rtl
, mode
, mem_mode
);
15544 mem_loc_result
= rotate_loc_descriptor (rtl
, mode
, mem_mode
);
15548 /* In theory, we could implement the above. */
15549 /* DWARF cannot represent the unsigned compare operations
15574 case FRACT_CONVERT
:
15575 case UNSIGNED_FRACT_CONVERT
:
15577 case UNSIGNED_SAT_FRACT
:
15583 case VEC_DUPLICATE
:
15587 case STRICT_LOW_PART
:
15592 /* If delegitimize_address couldn't do anything with the UNSPEC, we
15593 can't express it in the debug info. This can happen e.g. with some
15598 resolve_one_addr (&rtl
);
15601 /* RTL sequences inside PARALLEL record a series of DWARF operations for
15602 the expression. An UNSPEC rtx represents a raw DWARF operation,
15603 new_loc_descr is called for it to build the operation directly.
15604 Otherwise mem_loc_descriptor is called recursively. */
15608 dw_loc_descr_ref exp_result
= NULL
;
15610 for (; index
< XVECLEN (rtl
, 0); index
++)
15612 rtx elem
= XVECEXP (rtl
, 0, index
);
15613 if (GET_CODE (elem
) == UNSPEC
)
15615 /* Each DWARF operation UNSPEC contain two operands, if
15616 one operand is not used for the operation, const0_rtx is
15618 gcc_assert (XVECLEN (elem
, 0) == 2);
15620 HOST_WIDE_INT dw_op
= XINT (elem
, 1);
15621 HOST_WIDE_INT oprnd1
= INTVAL (XVECEXP (elem
, 0, 0));
15622 HOST_WIDE_INT oprnd2
= INTVAL (XVECEXP (elem
, 0, 1));
15624 = new_loc_descr ((enum dwarf_location_atom
) dw_op
, oprnd1
,
15629 = mem_loc_descriptor (elem
, mode
, mem_mode
,
15630 VAR_INIT_STATUS_INITIALIZED
);
15632 if (!mem_loc_result
)
15633 mem_loc_result
= exp_result
;
15635 add_loc_descr (&mem_loc_result
, exp_result
);
15644 print_rtl (stderr
, rtl
);
15645 gcc_unreachable ();
15650 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
15651 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
15653 return mem_loc_result
;
15656 /* Return a descriptor that describes the concatenation of two locations.
15657 This is typically a complex variable. */
15659 static dw_loc_descr_ref
15660 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
15662 dw_loc_descr_ref cc_loc_result
= NULL
;
15663 dw_loc_descr_ref x0_ref
15664 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15665 dw_loc_descr_ref x1_ref
15666 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15668 if (x0_ref
== 0 || x1_ref
== 0)
15671 cc_loc_result
= x0_ref
;
15672 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
15674 add_loc_descr (&cc_loc_result
, x1_ref
);
15675 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
15677 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
15678 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
15680 return cc_loc_result
;
15683 /* Return a descriptor that describes the concatenation of N
15686 static dw_loc_descr_ref
15687 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
15690 dw_loc_descr_ref cc_loc_result
= NULL
;
15691 unsigned int n
= XVECLEN (concatn
, 0);
15693 for (i
= 0; i
< n
; ++i
)
15695 dw_loc_descr_ref ref
;
15696 rtx x
= XVECEXP (concatn
, 0, i
);
15698 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15702 add_loc_descr (&cc_loc_result
, ref
);
15703 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
15706 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
15707 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
15709 return cc_loc_result
;
15712 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
15713 for DEBUG_IMPLICIT_PTR RTL. */
15715 static dw_loc_descr_ref
15716 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
15718 dw_loc_descr_ref ret
;
15721 if (dwarf_strict
&& dwarf_version
< 5)
15723 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
15724 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
15725 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
15726 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
15727 ret
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
15728 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
15731 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15732 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
15733 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15737 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
15738 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
15743 /* Output a proper Dwarf location descriptor for a variable or parameter
15744 which is either allocated in a register or in a memory location. For a
15745 register, we just generate an OP_REG and the register number. For a
15746 memory location we provide a Dwarf postfix expression describing how to
15747 generate the (dynamic) address of the object onto the address stack.
15749 MODE is mode of the decl if this loc_descriptor is going to be used in
15750 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
15751 allowed, VOIDmode otherwise.
15753 If we don't know how to describe it, return 0. */
15755 static dw_loc_descr_ref
15756 loc_descriptor (rtx rtl
, machine_mode mode
,
15757 enum var_init_status initialized
)
15759 dw_loc_descr_ref loc_result
= NULL
;
15761 switch (GET_CODE (rtl
))
15764 /* The case of a subreg may arise when we have a local (register)
15765 variable or a formal (register) parameter which doesn't quite fill
15766 up an entire register. For now, just assume that it is
15767 legitimate to make the Dwarf info refer to the whole register which
15768 contains the given subreg. */
15769 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
15770 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
15771 GET_MODE (SUBREG_REG (rtl
)), initialized
);
15777 loc_result
= reg_loc_descriptor (rtl
, initialized
);
15781 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
15782 GET_MODE (rtl
), initialized
);
15783 if (loc_result
== NULL
)
15784 loc_result
= tls_mem_loc_descriptor (rtl
);
15785 if (loc_result
== NULL
)
15787 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
15788 if (new_rtl
!= rtl
)
15789 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
15794 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
15799 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
15804 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
15806 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
15807 if (GET_CODE (loc
) == EXPR_LIST
)
15808 loc
= XEXP (loc
, 0);
15809 loc_result
= loc_descriptor (loc
, mode
, initialized
);
15813 rtl
= XEXP (rtl
, 1);
15818 rtvec par_elems
= XVEC (rtl
, 0);
15819 int num_elem
= GET_NUM_ELEM (par_elems
);
15823 /* Create the first one, so we have something to add to. */
15824 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
15825 VOIDmode
, initialized
);
15826 if (loc_result
== NULL
)
15828 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
15829 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
15830 for (i
= 1; i
< num_elem
; i
++)
15832 dw_loc_descr_ref temp
;
15834 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
15835 VOIDmode
, initialized
);
15838 add_loc_descr (&loc_result
, temp
);
15839 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
15840 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
15846 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
15847 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
15852 if (mode
== VOIDmode
)
15853 mode
= GET_MODE (rtl
);
15855 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
15857 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
15859 /* Note that a CONST_DOUBLE rtx could represent either an integer
15860 or a floating-point constant. A CONST_DOUBLE is used whenever
15861 the constant requires more than one word in order to be
15862 adequately represented. We output CONST_DOUBLEs as blocks. */
15863 loc_result
= new_loc_descr (DW_OP_implicit_value
,
15864 GET_MODE_SIZE (mode
), 0);
15865 #if TARGET_SUPPORTS_WIDE_INT == 0
15866 if (!SCALAR_FLOAT_MODE_P (mode
))
15868 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
15869 loc_result
->dw_loc_oprnd2
.v
.val_double
15870 = rtx_to_double_int (rtl
);
15875 unsigned int length
= GET_MODE_SIZE (mode
);
15876 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
15878 insert_float (rtl
, array
);
15879 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
15880 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
15881 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
15882 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
15887 case CONST_WIDE_INT
:
15888 if (mode
== VOIDmode
)
15889 mode
= GET_MODE (rtl
);
15891 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
15893 loc_result
= new_loc_descr (DW_OP_implicit_value
,
15894 GET_MODE_SIZE (mode
), 0);
15895 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
15896 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
15897 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, mode
);
15902 if (mode
== VOIDmode
)
15903 mode
= GET_MODE (rtl
);
15905 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
15907 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
15908 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
15909 unsigned char *array
15910 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
15913 machine_mode imode
= GET_MODE_INNER (mode
);
15915 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
15916 switch (GET_MODE_CLASS (mode
))
15918 case MODE_VECTOR_INT
:
15919 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15921 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15922 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
15926 case MODE_VECTOR_FLOAT
:
15927 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15929 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15930 insert_float (elt
, p
);
15935 gcc_unreachable ();
15938 loc_result
= new_loc_descr (DW_OP_implicit_value
,
15939 length
* elt_size
, 0);
15940 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
15941 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
15942 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
15943 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
15948 if (mode
== VOIDmode
15949 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
15950 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
15951 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
15953 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
15958 if (!const_ok_for_output (rtl
))
15962 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
15963 && (dwarf_version
>= 4 || !dwarf_strict
))
15965 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15966 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
15967 vec_safe_push (used_rtx_array
, rtl
);
15971 case DEBUG_IMPLICIT_PTR
:
15972 loc_result
= implicit_ptr_descriptor (rtl
, 0);
15976 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
15977 && CONST_INT_P (XEXP (rtl
, 1)))
15980 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
15986 if ((SCALAR_INT_MODE_P (mode
)
15987 && GET_MODE (rtl
) == mode
15988 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
15989 && dwarf_version
>= 4)
15990 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
15992 /* Value expression. */
15993 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
15995 add_loc_descr (&loc_result
,
15996 new_loc_descr (DW_OP_stack_value
, 0, 0));
16004 /* We need to figure out what section we should use as the base for the
16005 address ranges where a given location is valid.
16006 1. If this particular DECL has a section associated with it, use that.
16007 2. If this function has a section associated with it, use that.
16008 3. Otherwise, use the text section.
16009 XXX: If you split a variable across multiple sections, we won't notice. */
16011 static const char *
16012 secname_for_decl (const_tree decl
)
16014 const char *secname
;
16016 if (VAR_OR_FUNCTION_DECL_P (decl
)
16017 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
16018 && DECL_SECTION_NAME (decl
))
16019 secname
= DECL_SECTION_NAME (decl
);
16020 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
16021 secname
= DECL_SECTION_NAME (current_function_decl
);
16022 else if (cfun
&& in_cold_section_p
)
16023 secname
= crtl
->subsections
.cold_section_label
;
16025 secname
= text_section_label
;
16030 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
16033 decl_by_reference_p (tree decl
)
16035 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
16037 && DECL_BY_REFERENCE (decl
));
16040 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16043 static dw_loc_descr_ref
16044 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
16045 enum var_init_status initialized
)
16047 int have_address
= 0;
16048 dw_loc_descr_ref descr
;
16051 if (want_address
!= 2)
16053 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
16055 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16057 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16058 if (GET_CODE (varloc
) == EXPR_LIST
)
16059 varloc
= XEXP (varloc
, 0);
16060 mode
= GET_MODE (varloc
);
16061 if (MEM_P (varloc
))
16063 rtx addr
= XEXP (varloc
, 0);
16064 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
16065 mode
, initialized
);
16070 rtx x
= avoid_constant_pool_reference (varloc
);
16072 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
16077 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
16084 if (GET_CODE (varloc
) == VAR_LOCATION
)
16085 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
16087 mode
= DECL_MODE (loc
);
16088 descr
= loc_descriptor (varloc
, mode
, initialized
);
16095 if (want_address
== 2 && !have_address
16096 && (dwarf_version
>= 4 || !dwarf_strict
))
16098 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
16100 expansion_failed (loc
, NULL_RTX
,
16101 "DWARF address size mismatch");
16104 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16107 /* Show if we can't fill the request for an address. */
16108 if (want_address
&& !have_address
)
16110 expansion_failed (loc
, NULL_RTX
,
16111 "Want address and only have value");
16115 /* If we've got an address and don't want one, dereference. */
16116 if (!want_address
&& have_address
)
16118 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
16119 enum dwarf_location_atom op
;
16121 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
16123 expansion_failed (loc
, NULL_RTX
,
16124 "DWARF address size mismatch");
16127 else if (size
== DWARF2_ADDR_SIZE
)
16130 op
= DW_OP_deref_size
;
16132 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
16138 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
16139 if it is not possible. */
16141 static dw_loc_descr_ref
16142 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
16144 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
16145 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
16146 else if (dwarf_version
>= 3 || !dwarf_strict
)
16147 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
16152 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16153 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
16155 static dw_loc_descr_ref
16156 dw_sra_loc_expr (tree decl
, rtx loc
)
16159 unsigned HOST_WIDE_INT padsize
= 0;
16160 dw_loc_descr_ref descr
, *descr_tail
;
16161 unsigned HOST_WIDE_INT decl_size
;
16163 enum var_init_status initialized
;
16165 if (DECL_SIZE (decl
) == NULL
16166 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
16169 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
16171 descr_tail
= &descr
;
16173 for (p
= loc
; p
; p
= XEXP (p
, 1))
16175 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
16176 rtx loc_note
= *decl_piece_varloc_ptr (p
);
16177 dw_loc_descr_ref cur_descr
;
16178 dw_loc_descr_ref
*tail
, last
= NULL
;
16179 unsigned HOST_WIDE_INT opsize
= 0;
16181 if (loc_note
== NULL_RTX
16182 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
16184 padsize
+= bitsize
;
16187 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
16188 varloc
= NOTE_VAR_LOCATION (loc_note
);
16189 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
16190 if (cur_descr
== NULL
)
16192 padsize
+= bitsize
;
16196 /* Check that cur_descr either doesn't use
16197 DW_OP_*piece operations, or their sum is equal
16198 to bitsize. Otherwise we can't embed it. */
16199 for (tail
= &cur_descr
; *tail
!= NULL
;
16200 tail
= &(*tail
)->dw_loc_next
)
16201 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
16203 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
16207 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
16209 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
16213 if (last
!= NULL
&& opsize
!= bitsize
)
16215 padsize
+= bitsize
;
16216 /* Discard the current piece of the descriptor and release any
16217 addr_table entries it uses. */
16218 remove_loc_list_addr_table_entries (cur_descr
);
16222 /* If there is a hole, add DW_OP_*piece after empty DWARF
16223 expression, which means that those bits are optimized out. */
16226 if (padsize
> decl_size
)
16228 remove_loc_list_addr_table_entries (cur_descr
);
16229 goto discard_descr
;
16231 decl_size
-= padsize
;
16232 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
16233 if (*descr_tail
== NULL
)
16235 remove_loc_list_addr_table_entries (cur_descr
);
16236 goto discard_descr
;
16238 descr_tail
= &(*descr_tail
)->dw_loc_next
;
16241 *descr_tail
= cur_descr
;
16243 if (bitsize
> decl_size
)
16244 goto discard_descr
;
16245 decl_size
-= bitsize
;
16248 HOST_WIDE_INT offset
= 0;
16249 if (GET_CODE (varloc
) == VAR_LOCATION
16250 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16252 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16253 if (GET_CODE (varloc
) == EXPR_LIST
)
16254 varloc
= XEXP (varloc
, 0);
16258 if (GET_CODE (varloc
) == CONST
16259 || GET_CODE (varloc
) == SIGN_EXTEND
16260 || GET_CODE (varloc
) == ZERO_EXTEND
)
16261 varloc
= XEXP (varloc
, 0);
16262 else if (GET_CODE (varloc
) == SUBREG
)
16263 varloc
= SUBREG_REG (varloc
);
16268 /* DW_OP_bit_size offset should be zero for register
16269 or implicit location descriptions and empty location
16270 descriptions, but for memory addresses needs big endian
16272 if (MEM_P (varloc
))
16274 unsigned HOST_WIDE_INT memsize
16275 = MEM_SIZE (varloc
) * BITS_PER_UNIT
;
16276 if (memsize
!= bitsize
)
16278 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
16279 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
16280 goto discard_descr
;
16281 if (memsize
< bitsize
)
16282 goto discard_descr
;
16283 if (BITS_BIG_ENDIAN
)
16284 offset
= memsize
- bitsize
;
16288 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
16289 if (*descr_tail
== NULL
)
16290 goto discard_descr
;
16291 descr_tail
= &(*descr_tail
)->dw_loc_next
;
16295 /* If there were any non-empty expressions, add padding till the end of
16297 if (descr
!= NULL
&& decl_size
!= 0)
16299 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
16300 if (*descr_tail
== NULL
)
16301 goto discard_descr
;
16306 /* Discard the descriptor and release any addr_table entries it uses. */
16307 remove_loc_list_addr_table_entries (descr
);
16311 /* Return the dwarf representation of the location list LOC_LIST of
16312 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
16315 static dw_loc_list_ref
16316 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
16318 const char *endname
, *secname
;
16320 enum var_init_status initialized
;
16321 struct var_loc_node
*node
;
16322 dw_loc_descr_ref descr
;
16323 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
16324 dw_loc_list_ref list
= NULL
;
16325 dw_loc_list_ref
*listp
= &list
;
16327 /* Now that we know what section we are using for a base,
16328 actually construct the list of locations.
16329 The first location information is what is passed to the
16330 function that creates the location list, and the remaining
16331 locations just get added on to that list.
16332 Note that we only know the start address for a location
16333 (IE location changes), so to build the range, we use
16334 the range [current location start, next location start].
16335 This means we have to special case the last node, and generate
16336 a range of [last location start, end of function label]. */
16338 secname
= secname_for_decl (decl
);
16340 for (node
= loc_list
->first
; node
; node
= node
->next
)
16341 if (GET_CODE (node
->loc
) == EXPR_LIST
16342 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
16344 if (GET_CODE (node
->loc
) == EXPR_LIST
)
16346 /* This requires DW_OP_{,bit_}piece, which is not usable
16347 inside DWARF expressions. */
16348 if (want_address
!= 2)
16350 descr
= dw_sra_loc_expr (decl
, node
->loc
);
16356 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
16357 varloc
= NOTE_VAR_LOCATION (node
->loc
);
16358 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
16362 bool range_across_switch
= false;
16363 /* If section switch happens in between node->label
16364 and node->next->label (or end of function) and
16365 we can't emit it as a single entry list,
16366 emit two ranges, first one ending at the end
16367 of first partition and second one starting at the
16368 beginning of second partition. */
16369 if (node
== loc_list
->last_before_switch
16370 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
16371 && current_function_decl
)
16373 endname
= cfun
->fde
->dw_fde_end
;
16374 range_across_switch
= true;
16376 /* The variable has a location between NODE->LABEL and
16377 NODE->NEXT->LABEL. */
16378 else if (node
->next
)
16379 endname
= node
->next
->label
;
16380 /* If the variable has a location at the last label
16381 it keeps its location until the end of function. */
16382 else if (!current_function_decl
)
16383 endname
= text_end_label
;
16386 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
16387 current_function_funcdef_no
);
16388 endname
= ggc_strdup (label_id
);
16391 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
16392 if (TREE_CODE (decl
) == PARM_DECL
16393 && node
== loc_list
->first
16394 && NOTE_P (node
->loc
)
16395 && strcmp (node
->label
, endname
) == 0)
16396 (*listp
)->force
= true;
16397 listp
= &(*listp
)->dw_loc_next
;
16399 if (range_across_switch
)
16401 if (GET_CODE (node
->loc
) == EXPR_LIST
)
16402 descr
= dw_sra_loc_expr (decl
, node
->loc
);
16405 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
16406 varloc
= NOTE_VAR_LOCATION (node
->loc
);
16407 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
16410 gcc_assert (descr
);
16411 /* The variable has a location between NODE->LABEL and
16412 NODE->NEXT->LABEL. */
16414 endname
= node
->next
->label
;
16416 endname
= cfun
->fde
->dw_fde_second_end
;
16417 *listp
= new_loc_list (descr
,
16418 cfun
->fde
->dw_fde_second_begin
,
16420 listp
= &(*listp
)->dw_loc_next
;
16425 /* Try to avoid the overhead of a location list emitting a location
16426 expression instead, but only if we didn't have more than one
16427 location entry in the first place. If some entries were not
16428 representable, we don't want to pretend a single entry that was
16429 applies to the entire scope in which the variable is
16431 if (list
&& loc_list
->first
->next
)
16437 /* Return if the loc_list has only single element and thus can be represented
16438 as location description. */
16441 single_element_loc_list_p (dw_loc_list_ref list
)
16443 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
16444 return !list
->ll_symbol
;
16447 /* Duplicate a single element of location list. */
16449 static inline dw_loc_descr_ref
16450 copy_loc_descr (dw_loc_descr_ref ref
)
16452 dw_loc_descr_ref copy
= ggc_alloc
<dw_loc_descr_node
> ();
16453 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
16457 /* To each location in list LIST append loc descr REF. */
16460 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
16462 dw_loc_descr_ref copy
;
16463 add_loc_descr (&list
->expr
, ref
);
16464 list
= list
->dw_loc_next
;
16467 copy
= copy_loc_descr (ref
);
16468 add_loc_descr (&list
->expr
, copy
);
16469 while (copy
->dw_loc_next
)
16470 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
16471 list
= list
->dw_loc_next
;
16475 /* To each location in list LIST prepend loc descr REF. */
16478 prepend_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
16480 dw_loc_descr_ref copy
;
16481 dw_loc_descr_ref ref_end
= list
->expr
;
16482 add_loc_descr (&ref
, list
->expr
);
16484 list
= list
->dw_loc_next
;
16487 dw_loc_descr_ref end
= list
->expr
;
16488 list
->expr
= copy
= copy_loc_descr (ref
);
16489 while (copy
->dw_loc_next
!= ref_end
)
16490 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
16491 copy
->dw_loc_next
= end
;
16492 list
= list
->dw_loc_next
;
16496 /* Given two lists RET and LIST
16497 produce location list that is result of adding expression in LIST
16498 to expression in RET on each position in program.
16499 Might be destructive on both RET and LIST.
16501 TODO: We handle only simple cases of RET or LIST having at most one
16502 element. General case would involve sorting the lists in program order
16503 and merging them that will need some additional work.
16504 Adding that will improve quality of debug info especially for SRA-ed
16508 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
16517 if (!list
->dw_loc_next
)
16519 add_loc_descr_to_each (*ret
, list
->expr
);
16522 if (!(*ret
)->dw_loc_next
)
16524 prepend_loc_descr_to_each (list
, (*ret
)->expr
);
16528 expansion_failed (NULL_TREE
, NULL_RTX
,
16529 "Don't know how to merge two non-trivial"
16530 " location lists.\n");
16535 /* LOC is constant expression. Try a luck, look it up in constant
16536 pool and return its loc_descr of its address. */
16538 static dw_loc_descr_ref
16539 cst_pool_loc_descr (tree loc
)
16541 /* Get an RTL for this, if something has been emitted. */
16542 rtx rtl
= lookup_constant_def (loc
);
16544 if (!rtl
|| !MEM_P (rtl
))
16549 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
16551 /* TODO: We might get more coverage if we was actually delaying expansion
16552 of all expressions till end of compilation when constant pools are fully
16554 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
16556 expansion_failed (loc
, NULL_RTX
,
16557 "CST value in contant pool but not marked.");
16560 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
16561 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
16564 /* Return dw_loc_list representing address of addr_expr LOC
16565 by looking for inner INDIRECT_REF expression and turning
16566 it into simple arithmetics.
16568 See loc_list_from_tree for the meaning of CONTEXT. */
16570 static dw_loc_list_ref
16571 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
16572 loc_descr_context
*context
)
16575 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
16577 int unsignedp
, reversep
, volatilep
= 0;
16578 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
16580 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
16581 &bitsize
, &bitpos
, &offset
, &mode
,
16582 &unsignedp
, &reversep
, &volatilep
);
16584 if (bitpos
% BITS_PER_UNIT
)
16586 expansion_failed (loc
, NULL_RTX
, "bitfield access");
16589 if (!INDIRECT_REF_P (obj
))
16591 expansion_failed (obj
,
16592 NULL_RTX
, "no indirect ref in inner refrence");
16595 if (!offset
&& !bitpos
)
16596 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
16599 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
16600 && (dwarf_version
>= 4 || !dwarf_strict
))
16602 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
16607 /* Variable offset. */
16608 list_ret1
= loc_list_from_tree (offset
, 0, context
);
16609 if (list_ret1
== 0)
16611 add_loc_list (&list_ret
, list_ret1
);
16614 add_loc_descr_to_each (list_ret
,
16615 new_loc_descr (DW_OP_plus
, 0, 0));
16617 bytepos
= bitpos
/ BITS_PER_UNIT
;
16619 add_loc_descr_to_each (list_ret
,
16620 new_loc_descr (DW_OP_plus_uconst
,
16622 else if (bytepos
< 0)
16623 loc_list_plus_const (list_ret
, bytepos
);
16624 add_loc_descr_to_each (list_ret
,
16625 new_loc_descr (DW_OP_stack_value
, 0, 0));
16630 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
16631 all operations from LOC are nops, move to the last one. Insert in NOPS all
16632 operations that are skipped. */
16635 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
16636 hash_set
<dw_loc_descr_ref
> &nops
)
16638 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
16641 loc
= loc
->dw_loc_next
;
16645 /* Helper for loc_descr_without_nops: free the location description operation
16649 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
16655 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
16659 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
16661 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
16664 /* Set of all DW_OP_nop operations we remove. */
16665 hash_set
<dw_loc_descr_ref
> nops
;
16667 /* First, strip all prefix NOP operations in order to keep the head of the
16668 operations list. */
16669 loc_descr_to_next_no_nop (loc
, nops
);
16671 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
16673 /* For control flow operations: strip "prefix" nops in destination
16675 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
16676 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
16677 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
16678 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
16680 /* Do the same for the operations that follow, then move to the next
16682 if (cur
->dw_loc_next
!= NULL
)
16683 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
16684 cur
= cur
->dw_loc_next
;
16687 nops
.traverse
<void *, free_loc_descr
> (NULL
);
16691 struct dwarf_procedure_info
;
16693 /* Helper structure for location descriptions generation. */
16694 struct loc_descr_context
16696 /* The type that is implicitly referenced by DW_OP_push_object_address, or
16697 NULL_TREE if DW_OP_push_object_address in invalid for this location
16698 description. This is used when processing PLACEHOLDER_EXPR nodes. */
16700 /* The ..._DECL node that should be translated as a
16701 DW_OP_push_object_address operation. */
16703 /* Information about the DWARF procedure we are currently generating. NULL if
16704 we are not generating a DWARF procedure. */
16705 struct dwarf_procedure_info
*dpi
;
16706 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
16707 by consumer. Used for DW_TAG_generic_subrange attributes. */
16708 bool placeholder_arg
;
16709 /* True if PLACEHOLDER_EXPR has been seen. */
16710 bool placeholder_seen
;
16713 /* DWARF procedures generation
16715 DWARF expressions (aka. location descriptions) are used to encode variable
16716 things such as sizes or offsets. Such computations can have redundant parts
16717 that can be factorized in order to reduce the size of the output debug
16718 information. This is the whole point of DWARF procedures.
16720 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
16721 already factorized into functions ("size functions") in order to handle very
16722 big and complex types. Such functions are quite simple: they have integral
16723 arguments, they return an integral result and their body contains only a
16724 return statement with arithmetic expressions. This is the only kind of
16725 function we are interested in translating into DWARF procedures, here.
16727 DWARF expressions and DWARF procedure are executed using a stack, so we have
16728 to define some calling convention for them to interact. Let's say that:
16730 - Before calling a DWARF procedure, DWARF expressions must push on the stack
16731 all arguments in reverse order (right-to-left) so that when the DWARF
16732 procedure execution starts, the first argument is the top of the stack.
16734 - Then, when returning, the DWARF procedure must have consumed all arguments
16735 on the stack, must have pushed the result and touched nothing else.
16737 - Each integral argument and the result are integral types can be hold in a
16740 - We call "frame offset" the number of stack slots that are "under DWARF
16741 procedure control": it includes the arguments slots, the temporaries and
16742 the result slot. Thus, it is equal to the number of arguments when the
16743 procedure execution starts and must be equal to one (the result) when it
16746 /* Helper structure used when generating operations for a DWARF procedure. */
16747 struct dwarf_procedure_info
16749 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
16750 currently translated. */
16752 /* The number of arguments FNDECL takes. */
16753 unsigned args_count
;
16756 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
16757 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
16758 equate it to this DIE. */
16761 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
16762 dw_die_ref parent_die
)
16764 dw_die_ref dwarf_proc_die
;
16766 if ((dwarf_version
< 3 && dwarf_strict
)
16767 || location
== NULL
)
16770 dwarf_proc_die
= new_die (DW_TAG_dwarf_procedure
, parent_die
, fndecl
);
16772 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
16773 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
16774 return dwarf_proc_die
;
16777 /* Return whether TYPE is a supported type as a DWARF procedure argument
16778 type or return type (we handle only scalar types and pointer types that
16779 aren't wider than the DWARF expression evaluation stack. */
16782 is_handled_procedure_type (tree type
)
16784 return ((INTEGRAL_TYPE_P (type
)
16785 || TREE_CODE (type
) == OFFSET_TYPE
16786 || TREE_CODE (type
) == POINTER_TYPE
)
16787 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
16790 /* Helper for resolve_args_picking: do the same but stop when coming across
16791 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
16792 offset *before* evaluating the corresponding operation. */
16795 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
16796 struct dwarf_procedure_info
*dpi
,
16797 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
16799 /* The "frame_offset" identifier is already used to name a macro... */
16800 unsigned frame_offset_
= initial_frame_offset
;
16801 dw_loc_descr_ref l
;
16803 for (l
= loc
; l
!= NULL
;)
16806 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
16808 /* If we already met this node, there is nothing to compute anymore. */
16811 /* Make sure that the stack size is consistent wherever the execution
16812 flow comes from. */
16813 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
16816 l_frame_offset
= frame_offset_
;
16818 /* If needed, relocate the picking offset with respect to the frame
16820 if (l
->frame_offset_rel
)
16822 unsigned HOST_WIDE_INT off
;
16823 switch (l
->dw_loc_opc
)
16826 off
= l
->dw_loc_oprnd1
.v
.val_unsigned
;
16835 gcc_unreachable ();
16837 /* frame_offset_ is the size of the current stack frame, including
16838 incoming arguments. Besides, the arguments are pushed
16839 right-to-left. Thus, in order to access the Nth argument from
16840 this operation node, the picking has to skip temporaries *plus*
16841 one stack slot per argument (0 for the first one, 1 for the second
16844 The targetted argument number (N) is already set as the operand,
16845 and the number of temporaries can be computed with:
16846 frame_offsets_ - dpi->args_count */
16847 off
+= frame_offset_
- dpi
->args_count
;
16849 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
16855 l
->dw_loc_opc
= DW_OP_dup
;
16856 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
16860 l
->dw_loc_opc
= DW_OP_over
;
16861 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
16865 l
->dw_loc_opc
= DW_OP_pick
;
16866 l
->dw_loc_oprnd1
.v
.val_unsigned
= off
;
16870 /* Update frame_offset according to the effect the current operation has
16872 switch (l
->dw_loc_opc
)
16880 case DW_OP_plus_uconst
:
16916 case DW_OP_deref_size
:
16918 case DW_OP_bit_piece
:
16919 case DW_OP_implicit_value
:
16920 case DW_OP_stack_value
:
16924 case DW_OP_const1u
:
16925 case DW_OP_const1s
:
16926 case DW_OP_const2u
:
16927 case DW_OP_const2s
:
16928 case DW_OP_const4u
:
16929 case DW_OP_const4s
:
16930 case DW_OP_const8u
:
16931 case DW_OP_const8s
:
17002 case DW_OP_push_object_address
:
17003 case DW_OP_call_frame_cfa
:
17004 case DW_OP_GNU_variable_value
:
17029 case DW_OP_xderef_size
:
17035 case DW_OP_call_ref
:
17037 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
17038 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
17040 if (stack_usage
== NULL
)
17042 frame_offset_
+= *stack_usage
;
17046 case DW_OP_implicit_pointer
:
17047 case DW_OP_entry_value
:
17048 case DW_OP_const_type
:
17049 case DW_OP_regval_type
:
17050 case DW_OP_deref_type
:
17051 case DW_OP_convert
:
17052 case DW_OP_reinterpret
:
17053 case DW_OP_form_tls_address
:
17054 case DW_OP_GNU_push_tls_address
:
17055 case DW_OP_GNU_uninit
:
17056 case DW_OP_GNU_encoded_addr
:
17057 case DW_OP_GNU_implicit_pointer
:
17058 case DW_OP_GNU_entry_value
:
17059 case DW_OP_GNU_const_type
:
17060 case DW_OP_GNU_regval_type
:
17061 case DW_OP_GNU_deref_type
:
17062 case DW_OP_GNU_convert
:
17063 case DW_OP_GNU_reinterpret
:
17064 case DW_OP_GNU_parameter_ref
:
17065 /* loc_list_from_tree will probably not output these operations for
17066 size functions, so assume they will not appear here. */
17067 /* Fall through... */
17070 gcc_unreachable ();
17073 /* Now, follow the control flow (except subroutine calls). */
17074 switch (l
->dw_loc_opc
)
17077 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
17080 /* Fall through. */
17083 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
17086 case DW_OP_stack_value
:
17090 l
= l
->dw_loc_next
;
17098 /* Make a DFS over operations reachable through LOC (i.e. follow branch
17099 operations) in order to resolve the operand of DW_OP_pick operations that
17100 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
17101 offset *before* LOC is executed. Return if all relocations were
17105 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17106 struct dwarf_procedure_info
*dpi
)
17108 /* Associate to all visited operations the frame offset *before* evaluating
17110 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
17112 return resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
,
17116 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
17117 Return NULL if it is not possible. */
17120 function_to_dwarf_procedure (tree fndecl
)
17122 struct loc_descr_context ctx
;
17123 struct dwarf_procedure_info dpi
;
17124 dw_die_ref dwarf_proc_die
;
17125 tree tree_body
= DECL_SAVED_TREE (fndecl
);
17126 dw_loc_descr_ref loc_body
, epilogue
;
17131 /* Do not generate multiple DWARF procedures for the same function
17133 dwarf_proc_die
= lookup_decl_die (fndecl
);
17134 if (dwarf_proc_die
!= NULL
)
17135 return dwarf_proc_die
;
17137 /* DWARF procedures are available starting with the DWARFv3 standard. */
17138 if (dwarf_version
< 3 && dwarf_strict
)
17141 /* We handle only functions for which we still have a body, that return a
17142 supported type and that takes arguments with supported types. Note that
17143 there is no point translating functions that return nothing. */
17144 if (tree_body
== NULL_TREE
17145 || DECL_RESULT (fndecl
) == NULL_TREE
17146 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
17149 for (cursor
= DECL_ARGUMENTS (fndecl
);
17150 cursor
!= NULL_TREE
;
17151 cursor
= TREE_CHAIN (cursor
))
17152 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
17155 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
17156 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
17158 tree_body
= TREE_OPERAND (tree_body
, 0);
17159 if (TREE_CODE (tree_body
) != MODIFY_EXPR
17160 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
17162 tree_body
= TREE_OPERAND (tree_body
, 1);
17164 /* Try to translate the body expression itself. Note that this will probably
17165 cause an infinite recursion if its call graph has a cycle. This is very
17166 unlikely for size functions, however, so don't bother with such things at
17168 ctx
.context_type
= NULL_TREE
;
17169 ctx
.base_decl
= NULL_TREE
;
17171 ctx
.placeholder_arg
= false;
17172 ctx
.placeholder_seen
= false;
17173 dpi
.fndecl
= fndecl
;
17174 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
17175 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
17179 /* After evaluating all operands in "loc_body", we should still have on the
17180 stack all arguments plus the desired function result (top of the stack).
17181 Generate code in order to keep only the result in our stack frame. */
17183 for (i
= 0; i
< dpi
.args_count
; ++i
)
17185 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
17186 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
17187 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
17188 epilogue
= op_couple
;
17190 add_loc_descr (&loc_body
, epilogue
);
17191 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
17194 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
17195 because they are considered useful. Now there is an epilogue, they are
17196 not anymore, so give it another try. */
17197 loc_descr_without_nops (loc_body
);
17199 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
17200 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
17201 though, given that size functions do not come from source, so they should
17202 not have a dedicated DW_TAG_subprogram DIE. */
17204 = new_dwarf_proc_die (loc_body
, fndecl
,
17205 get_context_die (DECL_CONTEXT (fndecl
)));
17207 /* The called DWARF procedure consumes one stack slot per argument and
17208 returns one stack slot. */
17209 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
17211 return dwarf_proc_die
;
17215 /* Generate Dwarf location list representing LOC.
17216 If WANT_ADDRESS is false, expression computing LOC will be computed
17217 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
17218 if WANT_ADDRESS is 2, expression computing address useable in location
17219 will be returned (i.e. DW_OP_reg can be used
17220 to refer to register values).
17222 CONTEXT provides information to customize the location descriptions
17223 generation. Its context_type field specifies what type is implicitly
17224 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
17225 will not be generated.
17227 Its DPI field determines whether we are generating a DWARF expression for a
17228 DWARF procedure, so PARM_DECL references are processed specifically.
17230 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
17231 and dpi fields were null. */
17233 static dw_loc_list_ref
17234 loc_list_from_tree_1 (tree loc
, int want_address
,
17235 struct loc_descr_context
*context
)
17237 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
17238 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
17239 int have_address
= 0;
17240 enum dwarf_location_atom op
;
17242 /* ??? Most of the time we do not take proper care for sign/zero
17243 extending the values properly. Hopefully this won't be a real
17246 if (context
!= NULL
17247 && context
->base_decl
== loc
17248 && want_address
== 0)
17250 if (dwarf_version
>= 3 || !dwarf_strict
)
17251 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
17257 switch (TREE_CODE (loc
))
17260 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
17263 case PLACEHOLDER_EXPR
:
17264 /* This case involves extracting fields from an object to determine the
17265 position of other fields. It is supposed to appear only as the first
17266 operand of COMPONENT_REF nodes and to reference precisely the type
17267 that the context allows. */
17268 if (context
!= NULL
17269 && TREE_TYPE (loc
) == context
->context_type
17270 && want_address
>= 1)
17272 if (dwarf_version
>= 3 || !dwarf_strict
)
17274 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
17281 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
17282 the single argument passed by consumer. */
17283 else if (context
!= NULL
17284 && context
->placeholder_arg
17285 && INTEGRAL_TYPE_P (TREE_TYPE (loc
))
17286 && want_address
== 0)
17288 ret
= new_loc_descr (DW_OP_pick
, 0, 0);
17289 ret
->frame_offset_rel
= 1;
17290 context
->placeholder_seen
= true;
17294 expansion_failed (loc
, NULL_RTX
,
17295 "PLACEHOLDER_EXPR for an unexpected type");
17300 const int nargs
= call_expr_nargs (loc
);
17301 tree callee
= get_callee_fndecl (loc
);
17303 dw_die_ref dwarf_proc
;
17305 if (callee
== NULL_TREE
)
17306 goto call_expansion_failed
;
17308 /* We handle only functions that return an integer. */
17309 if (!is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
))))
17310 goto call_expansion_failed
;
17312 dwarf_proc
= function_to_dwarf_procedure (callee
);
17313 if (dwarf_proc
== NULL
)
17314 goto call_expansion_failed
;
17316 /* Evaluate arguments right-to-left so that the first argument will
17317 be the top-most one on the stack. */
17318 for (i
= nargs
- 1; i
>= 0; --i
)
17320 dw_loc_descr_ref loc_descr
17321 = loc_descriptor_from_tree (CALL_EXPR_ARG (loc
, i
), 0,
17324 if (loc_descr
== NULL
)
17325 goto call_expansion_failed
;
17327 add_loc_descr (&ret
, loc_descr
);
17330 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
17331 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
17332 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
17333 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
17334 add_loc_descr (&ret
, ret1
);
17337 call_expansion_failed
:
17338 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
17339 /* There are no opcodes for these operations. */
17343 case PREINCREMENT_EXPR
:
17344 case PREDECREMENT_EXPR
:
17345 case POSTINCREMENT_EXPR
:
17346 case POSTDECREMENT_EXPR
:
17347 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
17348 /* There are no opcodes for these operations. */
17352 /* If we already want an address, see if there is INDIRECT_REF inside
17353 e.g. for &this->field. */
17356 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
17357 (loc
, want_address
== 2, context
);
17360 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
17361 && (ret
= cst_pool_loc_descr (loc
)))
17364 /* Otherwise, process the argument and look for the address. */
17365 if (!list_ret
&& !ret
)
17366 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
17370 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
17376 if (DECL_THREAD_LOCAL_P (loc
))
17379 enum dwarf_location_atom tls_op
;
17380 enum dtprel_bool dtprel
= dtprel_false
;
17382 if (targetm
.have_tls
)
17384 /* If this is not defined, we have no way to emit the
17386 if (!targetm
.asm_out
.output_dwarf_dtprel
)
17389 /* The way DW_OP_GNU_push_tls_address is specified, we
17390 can only look up addresses of objects in the current
17391 module. We used DW_OP_addr as first op, but that's
17392 wrong, because DW_OP_addr is relocated by the debug
17393 info consumer, while DW_OP_GNU_push_tls_address
17394 operand shouldn't be. */
17395 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
17397 dtprel
= dtprel_true
;
17398 /* We check for DWARF 5 here because gdb did not implement
17399 DW_OP_form_tls_address until after 7.12. */
17400 tls_op
= (dwarf_version
>= 5 ? DW_OP_form_tls_address
17401 : DW_OP_GNU_push_tls_address
);
17405 if (!targetm
.emutls
.debug_form_tls_address
17406 || !(dwarf_version
>= 3 || !dwarf_strict
))
17408 /* We stuffed the control variable into the DECL_VALUE_EXPR
17409 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
17410 no longer appear in gimple code. We used the control
17411 variable in specific so that we could pick it up here. */
17412 loc
= DECL_VALUE_EXPR (loc
);
17413 tls_op
= DW_OP_form_tls_address
;
17416 rtl
= rtl_for_decl_location (loc
);
17417 if (rtl
== NULL_RTX
)
17422 rtl
= XEXP (rtl
, 0);
17423 if (! CONSTANT_P (rtl
))
17426 ret
= new_addr_loc_descr (rtl
, dtprel
);
17427 ret1
= new_loc_descr (tls_op
, 0, 0);
17428 add_loc_descr (&ret
, ret1
);
17436 if (context
!= NULL
&& context
->dpi
!= NULL
17437 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
17439 /* We are generating code for a DWARF procedure and we want to access
17440 one of its arguments: find the appropriate argument offset and let
17441 the resolve_args_picking pass compute the offset that complies
17442 with the stack frame size. */
17446 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
17447 cursor
!= NULL_TREE
&& cursor
!= loc
;
17448 cursor
= TREE_CHAIN (cursor
), ++i
)
17450 /* If we are translating a DWARF procedure, all referenced parameters
17451 must belong to the current function. */
17452 gcc_assert (cursor
!= NULL_TREE
);
17454 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
17455 ret
->frame_offset_rel
= 1;
17461 if (DECL_HAS_VALUE_EXPR_P (loc
))
17462 return loc_list_from_tree_1 (DECL_VALUE_EXPR (loc
),
17463 want_address
, context
);
17466 case FUNCTION_DECL
:
17469 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
17471 if (loc_list
&& loc_list
->first
)
17473 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
17474 have_address
= want_address
!= 0;
17477 rtl
= rtl_for_decl_location (loc
);
17478 if (rtl
== NULL_RTX
)
17480 if (TREE_CODE (loc
) != FUNCTION_DECL
17482 && current_function_decl
17483 && want_address
!= 1
17484 && ! DECL_IGNORED_P (loc
)
17485 && (INTEGRAL_TYPE_P (TREE_TYPE (loc
))
17486 || POINTER_TYPE_P (TREE_TYPE (loc
)))
17487 && DECL_CONTEXT (loc
) == current_function_decl
17488 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (loc
)))
17489 <= DWARF2_ADDR_SIZE
))
17491 dw_die_ref ref
= lookup_decl_die (loc
);
17492 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
17495 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
17496 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
17497 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
17501 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
17502 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= loc
;
17506 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
17509 else if (CONST_INT_P (rtl
))
17511 HOST_WIDE_INT val
= INTVAL (rtl
);
17512 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
17513 val
&= GET_MODE_MASK (DECL_MODE (loc
));
17514 ret
= int_loc_descriptor (val
);
17516 else if (GET_CODE (rtl
) == CONST_STRING
)
17518 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
17521 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
17522 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
17525 machine_mode mode
, mem_mode
;
17527 /* Certain constructs can only be represented at top-level. */
17528 if (want_address
== 2)
17530 ret
= loc_descriptor (rtl
, VOIDmode
,
17531 VAR_INIT_STATUS_INITIALIZED
);
17536 mode
= GET_MODE (rtl
);
17537 mem_mode
= VOIDmode
;
17541 mode
= get_address_mode (rtl
);
17542 rtl
= XEXP (rtl
, 0);
17545 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
17546 VAR_INIT_STATUS_INITIALIZED
);
17549 expansion_failed (loc
, rtl
,
17550 "failed to produce loc descriptor for rtl");
17556 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
17563 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17567 case TARGET_MEM_REF
:
17569 case DEBUG_EXPR_DECL
:
17572 case COMPOUND_EXPR
:
17573 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
17577 case VIEW_CONVERT_EXPR
:
17580 case NON_LVALUE_EXPR
:
17581 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
17584 case COMPONENT_REF
:
17585 case BIT_FIELD_REF
:
17587 case ARRAY_RANGE_REF
:
17588 case REALPART_EXPR
:
17589 case IMAGPART_EXPR
:
17592 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
17594 int unsignedp
, reversep
, volatilep
= 0;
17596 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
17597 &unsignedp
, &reversep
, &volatilep
);
17599 gcc_assert (obj
!= loc
);
17601 list_ret
= loc_list_from_tree_1 (obj
,
17603 && !bitpos
&& !offset
? 2 : 1,
17605 /* TODO: We can extract value of the small expression via shifting even
17606 for nonzero bitpos. */
17609 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
17611 expansion_failed (loc
, NULL_RTX
,
17612 "bitfield access");
17616 if (offset
!= NULL_TREE
)
17618 /* Variable offset. */
17619 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
17620 if (list_ret1
== 0)
17622 add_loc_list (&list_ret
, list_ret1
);
17625 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
17628 bytepos
= bitpos
/ BITS_PER_UNIT
;
17630 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
17631 else if (bytepos
< 0)
17632 loc_list_plus_const (list_ret
, bytepos
);
17639 if ((want_address
|| !tree_fits_shwi_p (loc
))
17640 && (ret
= cst_pool_loc_descr (loc
)))
17642 else if (want_address
== 2
17643 && tree_fits_shwi_p (loc
)
17644 && (ret
= address_of_int_loc_descriptor
17645 (int_size_in_bytes (TREE_TYPE (loc
)),
17646 tree_to_shwi (loc
))))
17648 else if (tree_fits_shwi_p (loc
))
17649 ret
= int_loc_descriptor (tree_to_shwi (loc
));
17650 else if (tree_fits_uhwi_p (loc
))
17651 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
17654 expansion_failed (loc
, NULL_RTX
,
17655 "Integer operand is not host integer");
17664 if ((ret
= cst_pool_loc_descr (loc
)))
17666 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
17668 tree type
= TREE_TYPE (loc
);
17669 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
17670 unsigned HOST_WIDE_INT offset
= 0;
17671 unsigned HOST_WIDE_INT cnt
;
17672 constructor_elt
*ce
;
17674 if (TREE_CODE (type
) == RECORD_TYPE
)
17676 /* This is very limited, but it's enough to output
17677 pointers to member functions, as long as the
17678 referenced function is defined in the current
17679 translation unit. */
17680 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
17682 tree val
= ce
->value
;
17684 tree field
= ce
->index
;
17689 if (!field
|| DECL_BIT_FIELD (field
))
17691 expansion_failed (loc
, NULL_RTX
,
17692 "bitfield in record type constructor");
17693 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
17698 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
17699 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
17700 gcc_assert (pos
+ fieldsize
<= size
);
17703 expansion_failed (loc
, NULL_RTX
,
17704 "out-of-order fields in record constructor");
17705 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
17711 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
17712 add_loc_descr (&ret
, ret1
);
17715 if (val
&& fieldsize
!= 0)
17717 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
17720 expansion_failed (loc
, NULL_RTX
,
17721 "unsupported expression in field");
17722 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
17726 add_loc_descr (&ret
, ret1
);
17730 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
17731 add_loc_descr (&ret
, ret1
);
17732 offset
= pos
+ fieldsize
;
17736 if (offset
!= size
)
17738 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
17739 add_loc_descr (&ret
, ret1
);
17743 have_address
= !!want_address
;
17746 expansion_failed (loc
, NULL_RTX
,
17747 "constructor of non-record type");
17750 /* We can construct small constants here using int_loc_descriptor. */
17751 expansion_failed (loc
, NULL_RTX
,
17752 "constructor or constant not in constant pool");
17755 case TRUTH_AND_EXPR
:
17756 case TRUTH_ANDIF_EXPR
:
17761 case TRUTH_XOR_EXPR
:
17766 case TRUTH_OR_EXPR
:
17767 case TRUTH_ORIF_EXPR
:
17772 case FLOOR_DIV_EXPR
:
17773 case CEIL_DIV_EXPR
:
17774 case ROUND_DIV_EXPR
:
17775 case TRUNC_DIV_EXPR
:
17776 case EXACT_DIV_EXPR
:
17777 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
17786 case FLOOR_MOD_EXPR
:
17787 case CEIL_MOD_EXPR
:
17788 case ROUND_MOD_EXPR
:
17789 case TRUNC_MOD_EXPR
:
17790 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
17795 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17796 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
17797 if (list_ret
== 0 || list_ret1
== 0)
17800 add_loc_list (&list_ret
, list_ret1
);
17803 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
17804 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
17805 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
17806 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
17807 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
17819 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
17822 case POINTER_PLUS_EXPR
:
17825 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
17827 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
17828 smarter to encode their opposite. The DW_OP_plus_uconst operation
17829 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
17830 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
17831 bytes, Y being the size of the operation that pushes the opposite
17832 of the addend. So let's choose the smallest representation. */
17833 const tree tree_addend
= TREE_OPERAND (loc
, 1);
17834 offset_int wi_addend
;
17835 HOST_WIDE_INT shwi_addend
;
17836 dw_loc_descr_ref loc_naddend
;
17838 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17842 /* Try to get the literal to push. It is the opposite of the addend,
17843 so as we rely on wrapping during DWARF evaluation, first decode
17844 the literal as a "DWARF-sized" signed number. */
17845 wi_addend
= wi::to_offset (tree_addend
);
17846 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
17847 shwi_addend
= wi_addend
.to_shwi ();
17848 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
17849 ? int_loc_descriptor (-shwi_addend
)
17852 if (loc_naddend
!= NULL
17853 && ((unsigned) size_of_uleb128 (shwi_addend
)
17854 > size_of_loc_descr (loc_naddend
)))
17856 add_loc_descr_to_each (list_ret
, loc_naddend
);
17857 add_loc_descr_to_each (list_ret
,
17858 new_loc_descr (DW_OP_minus
, 0, 0));
17862 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
17864 loc_naddend
= loc_cur
;
17865 loc_cur
= loc_cur
->dw_loc_next
;
17866 ggc_free (loc_naddend
);
17868 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
17878 goto do_comp_binop
;
17882 goto do_comp_binop
;
17886 goto do_comp_binop
;
17890 goto do_comp_binop
;
17893 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
17895 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
17896 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
17897 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
17913 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17914 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
17915 if (list_ret
== 0 || list_ret1
== 0)
17918 add_loc_list (&list_ret
, list_ret1
);
17921 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
17924 case TRUTH_NOT_EXPR
:
17938 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17942 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
17948 const enum tree_code code
=
17949 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
17951 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
17952 build2 (code
, integer_type_node
,
17953 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
17954 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
17961 dw_loc_descr_ref lhs
17962 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
17963 dw_loc_list_ref rhs
17964 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
17965 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
17967 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17968 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
17971 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
17972 add_loc_descr_to_each (list_ret
, bra_node
);
17974 add_loc_list (&list_ret
, rhs
);
17975 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
17976 add_loc_descr_to_each (list_ret
, jump_node
);
17978 add_loc_descr_to_each (list_ret
, lhs
);
17979 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
17980 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
17982 /* ??? Need a node to point the skip at. Use a nop. */
17983 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
17984 add_loc_descr_to_each (list_ret
, tmp
);
17985 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
17986 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
17990 case FIX_TRUNC_EXPR
:
17994 /* Leave front-end specific codes as simply unknown. This comes
17995 up, for instance, with the C STMT_EXPR. */
17996 if ((unsigned int) TREE_CODE (loc
)
17997 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
17999 expansion_failed (loc
, NULL_RTX
,
18000 "language specific tree node");
18004 /* Otherwise this is a generic code; we should just lists all of
18005 these explicitly. We forgot one. */
18007 gcc_unreachable ();
18009 /* In a release build, we want to degrade gracefully: better to
18010 generate incomplete debugging information than to crash. */
18014 if (!ret
&& !list_ret
)
18017 if (want_address
== 2 && !have_address
18018 && (dwarf_version
>= 4 || !dwarf_strict
))
18020 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
18022 expansion_failed (loc
, NULL_RTX
,
18023 "DWARF address size mismatch");
18027 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
18029 add_loc_descr_to_each (list_ret
,
18030 new_loc_descr (DW_OP_stack_value
, 0, 0));
18033 /* Show if we can't fill the request for an address. */
18034 if (want_address
&& !have_address
)
18036 expansion_failed (loc
, NULL_RTX
,
18037 "Want address and only have value");
18041 gcc_assert (!ret
|| !list_ret
);
18043 /* If we've got an address and don't want one, dereference. */
18044 if (!want_address
&& have_address
)
18046 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
18048 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
18050 expansion_failed (loc
, NULL_RTX
,
18051 "DWARF address size mismatch");
18054 else if (size
== DWARF2_ADDR_SIZE
)
18057 op
= DW_OP_deref_size
;
18060 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
18062 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
18065 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
18070 /* Likewise, but strip useless DW_OP_nop operations in the resulting
18073 static dw_loc_list_ref
18074 loc_list_from_tree (tree loc
, int want_address
,
18075 struct loc_descr_context
*context
)
18077 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
18079 for (dw_loc_list_ref loc_cur
= result
;
18080 loc_cur
!= NULL
; loc_cur
= loc_cur
->dw_loc_next
)
18081 loc_descr_without_nops (loc_cur
->expr
);
18085 /* Same as above but return only single location expression. */
18086 static dw_loc_descr_ref
18087 loc_descriptor_from_tree (tree loc
, int want_address
,
18088 struct loc_descr_context
*context
)
18090 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
18093 if (ret
->dw_loc_next
)
18095 expansion_failed (loc
, NULL_RTX
,
18096 "Location list where only loc descriptor needed");
18102 /* Given a value, round it up to the lowest multiple of `boundary'
18103 which is not less than the value itself. */
18105 static inline HOST_WIDE_INT
18106 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
18108 return (((value
+ boundary
- 1) / boundary
) * boundary
);
18111 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
18112 pointer to the declared type for the relevant field variable, or return
18113 `integer_type_node' if the given node turns out to be an
18114 ERROR_MARK node. */
18117 field_type (const_tree decl
)
18121 if (TREE_CODE (decl
) == ERROR_MARK
)
18122 return integer_type_node
;
18124 type
= DECL_BIT_FIELD_TYPE (decl
);
18125 if (type
== NULL_TREE
)
18126 type
= TREE_TYPE (decl
);
18131 /* Given a pointer to a tree node, return the alignment in bits for
18132 it, or else return BITS_PER_WORD if the node actually turns out to
18133 be an ERROR_MARK node. */
18135 static inline unsigned
18136 simple_type_align_in_bits (const_tree type
)
18138 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
18141 static inline unsigned
18142 simple_decl_align_in_bits (const_tree decl
)
18144 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
18147 /* Return the result of rounding T up to ALIGN. */
18149 static inline offset_int
18150 round_up_to_align (const offset_int
&t
, unsigned int align
)
18152 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
18155 /* Compute the size of TYPE in bytes. If possible, return NULL and store the
18156 size as an integer constant in CST_SIZE. Otherwise, if possible, return a
18157 DWARF expression that computes the size. Return NULL and set CST_SIZE to -1
18158 if we fail to return the size in one of these two forms. */
18160 static dw_loc_descr_ref
18161 type_byte_size (const_tree type
, HOST_WIDE_INT
*cst_size
)
18164 struct loc_descr_context ctx
;
18166 /* Return a constant integer in priority, if possible. */
18167 *cst_size
= int_size_in_bytes (type
);
18168 if (*cst_size
!= -1)
18171 ctx
.context_type
= const_cast<tree
> (type
);
18172 ctx
.base_decl
= NULL_TREE
;
18174 ctx
.placeholder_arg
= false;
18175 ctx
.placeholder_seen
= false;
18177 type
= TYPE_MAIN_VARIANT (type
);
18178 tree_size
= TYPE_SIZE_UNIT (type
);
18179 return ((tree_size
!= NULL_TREE
)
18180 ? loc_descriptor_from_tree (tree_size
, 0, &ctx
)
18184 /* Helper structure for RECORD_TYPE processing. */
18187 /* Root RECORD_TYPE. It is needed to generate data member location
18188 descriptions in variable-length records (VLR), but also to cope with
18189 variants, which are composed of nested structures multiplexed with
18190 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
18191 function processing a FIELD_DECL, it is required to be non null. */
18193 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
18194 QUAL_UNION_TYPE), this holds an expression that computes the offset for
18195 this variant part as part of the root record (in storage units). For
18196 regular records, it must be NULL_TREE. */
18197 tree variant_part_offset
;
18200 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
18201 addressed byte of the "containing object" for the given FIELD_DECL. If
18202 possible, return a native constant through CST_OFFSET (in which case NULL is
18203 returned); otherwise return a DWARF expression that computes the offset.
18205 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
18206 that offset is, either because the argument turns out to be a pointer to an
18207 ERROR_MARK node, or because the offset expression is too complex for us.
18209 CTX is required: see the comment for VLR_CONTEXT. */
18211 static dw_loc_descr_ref
18212 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
18213 HOST_WIDE_INT
*cst_offset
)
18216 dw_loc_list_ref loc_result
;
18220 if (TREE_CODE (decl
) == ERROR_MARK
)
18223 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
18225 /* We cannot handle variable bit offsets at the moment, so abort if it's the
18227 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
)
18230 #ifdef PCC_BITFIELD_TYPE_MATTERS
18231 /* We used to handle only constant offsets in all cases. Now, we handle
18232 properly dynamic byte offsets only when PCC bitfield type doesn't
18234 if (PCC_BITFIELD_TYPE_MATTERS
18235 && TREE_CODE (DECL_FIELD_OFFSET (decl
)) == INTEGER_CST
)
18237 offset_int object_offset_in_bits
;
18238 offset_int object_offset_in_bytes
;
18239 offset_int bitpos_int
;
18241 tree field_size_tree
;
18242 offset_int deepest_bitpos
;
18243 offset_int field_size_in_bits
;
18244 unsigned int type_align_in_bits
;
18245 unsigned int decl_align_in_bits
;
18246 offset_int type_size_in_bits
;
18248 bitpos_int
= wi::to_offset (bit_position (decl
));
18249 type
= field_type (decl
);
18250 type_size_in_bits
= offset_int_type_size_in_bits (type
);
18251 type_align_in_bits
= simple_type_align_in_bits (type
);
18253 field_size_tree
= DECL_SIZE (decl
);
18255 /* The size could be unspecified if there was an error, or for
18256 a flexible array member. */
18257 if (!field_size_tree
)
18258 field_size_tree
= bitsize_zero_node
;
18260 /* If the size of the field is not constant, use the type size. */
18261 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
18262 field_size_in_bits
= wi::to_offset (field_size_tree
);
18264 field_size_in_bits
= type_size_in_bits
;
18266 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
18268 /* The GCC front-end doesn't make any attempt to keep track of the
18269 starting bit offset (relative to the start of the containing
18270 structure type) of the hypothetical "containing object" for a
18271 bit-field. Thus, when computing the byte offset value for the
18272 start of the "containing object" of a bit-field, we must deduce
18273 this information on our own. This can be rather tricky to do in
18274 some cases. For example, handling the following structure type
18275 definition when compiling for an i386/i486 target (which only
18276 aligns long long's to 32-bit boundaries) can be very tricky:
18278 struct S { int field1; long long field2:31; };
18280 Fortunately, there is a simple rule-of-thumb which can be used
18281 in such cases. When compiling for an i386/i486, GCC will
18282 allocate 8 bytes for the structure shown above. It decides to
18283 do this based upon one simple rule for bit-field allocation.
18284 GCC allocates each "containing object" for each bit-field at
18285 the first (i.e. lowest addressed) legitimate alignment boundary
18286 (based upon the required minimum alignment for the declared
18287 type of the field) which it can possibly use, subject to the
18288 condition that there is still enough available space remaining
18289 in the containing object (when allocated at the selected point)
18290 to fully accommodate all of the bits of the bit-field itself.
18292 This simple rule makes it obvious why GCC allocates 8 bytes for
18293 each object of the structure type shown above. When looking
18294 for a place to allocate the "containing object" for `field2',
18295 the compiler simply tries to allocate a 64-bit "containing
18296 object" at each successive 32-bit boundary (starting at zero)
18297 until it finds a place to allocate that 64- bit field such that
18298 at least 31 contiguous (and previously unallocated) bits remain
18299 within that selected 64 bit field. (As it turns out, for the
18300 example above, the compiler finds it is OK to allocate the
18301 "containing object" 64-bit field at bit-offset zero within the
18304 Here we attempt to work backwards from the limited set of facts
18305 we're given, and we try to deduce from those facts, where GCC
18306 must have believed that the containing object started (within
18307 the structure type). The value we deduce is then used (by the
18308 callers of this routine) to generate DW_AT_location and
18309 DW_AT_bit_offset attributes for fields (both bit-fields and, in
18310 the case of DW_AT_location, regular fields as well). */
18312 /* Figure out the bit-distance from the start of the structure to
18313 the "deepest" bit of the bit-field. */
18314 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
18316 /* This is the tricky part. Use some fancy footwork to deduce
18317 where the lowest addressed bit of the containing object must
18319 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
18321 /* Round up to type_align by default. This works best for
18323 object_offset_in_bits
18324 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
18326 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
18328 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
18330 /* Round up to decl_align instead. */
18331 object_offset_in_bits
18332 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
18335 object_offset_in_bytes
18336 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
18337 if (ctx
->variant_part_offset
== NULL_TREE
)
18339 *cst_offset
= object_offset_in_bytes
.to_shwi ();
18342 tree_result
= wide_int_to_tree (sizetype
, object_offset_in_bytes
);
18345 #endif /* PCC_BITFIELD_TYPE_MATTERS */
18346 tree_result
= byte_position (decl
);
18348 if (ctx
->variant_part_offset
!= NULL_TREE
)
18349 tree_result
= fold_build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
18350 ctx
->variant_part_offset
, tree_result
);
18352 /* If the byte offset is a constant, it's simplier to handle a native
18353 constant rather than a DWARF expression. */
18354 if (TREE_CODE (tree_result
) == INTEGER_CST
)
18356 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
18359 struct loc_descr_context loc_ctx
= {
18360 ctx
->struct_type
, /* context_type */
18361 NULL_TREE
, /* base_decl */
18363 false, /* placeholder_arg */
18364 false /* placeholder_seen */
18366 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
18368 /* We want a DWARF expression: abort if we only have a location list with
18369 multiple elements. */
18370 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
18373 return loc_result
->expr
;
18376 /* The following routines define various Dwarf attributes and any data
18377 associated with them. */
18379 /* Add a location description attribute value to a DIE.
18381 This emits location attributes suitable for whole variables and
18382 whole parameters. Note that the location attributes for struct fields are
18383 generated by the routine `data_member_location_attribute' below. */
18386 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
18387 dw_loc_list_ref descr
)
18391 if (single_element_loc_list_p (descr
))
18392 add_AT_loc (die
, attr_kind
, descr
->expr
);
18394 add_AT_loc_list (die
, attr_kind
, descr
);
18397 /* Add DW_AT_accessibility attribute to DIE if needed. */
18400 add_accessibility_attribute (dw_die_ref die
, tree decl
)
18402 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
18403 children, otherwise the default is DW_ACCESS_public. In DWARF2
18404 the default has always been DW_ACCESS_public. */
18405 if (TREE_PROTECTED (decl
))
18406 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
18407 else if (TREE_PRIVATE (decl
))
18409 if (dwarf_version
== 2
18410 || die
->die_parent
== NULL
18411 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
18412 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
18414 else if (dwarf_version
> 2
18416 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
18417 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
18420 /* Attach the specialized form of location attribute used for data members of
18421 struct and union types. In the special case of a FIELD_DECL node which
18422 represents a bit-field, the "offset" part of this special location
18423 descriptor must indicate the distance in bytes from the lowest-addressed
18424 byte of the containing struct or union type to the lowest-addressed byte of
18425 the "containing object" for the bit-field. (See the `field_byte_offset'
18428 For any given bit-field, the "containing object" is a hypothetical object
18429 (of some integral or enum type) within which the given bit-field lives. The
18430 type of this hypothetical "containing object" is always the same as the
18431 declared type of the individual bit-field itself (for GCC anyway... the
18432 DWARF spec doesn't actually mandate this). Note that it is the size (in
18433 bytes) of the hypothetical "containing object" which will be given in the
18434 DW_AT_byte_size attribute for this bit-field. (See the
18435 `byte_size_attribute' function below.) It is also used when calculating the
18436 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
18439 CTX is required: see the comment for VLR_CONTEXT. */
18442 add_data_member_location_attribute (dw_die_ref die
,
18444 struct vlr_context
*ctx
)
18446 HOST_WIDE_INT offset
;
18447 dw_loc_descr_ref loc_descr
= 0;
18449 if (TREE_CODE (decl
) == TREE_BINFO
)
18451 /* We're working on the TAG_inheritance for a base class. */
18452 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
18454 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
18455 aren't at a fixed offset from all (sub)objects of the same
18456 type. We need to extract the appropriate offset from our
18457 vtable. The following dwarf expression means
18459 BaseAddr = ObAddr + *((*ObAddr) - Offset)
18461 This is specific to the V3 ABI, of course. */
18463 dw_loc_descr_ref tmp
;
18465 /* Make a copy of the object address. */
18466 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
18467 add_loc_descr (&loc_descr
, tmp
);
18469 /* Extract the vtable address. */
18470 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
18471 add_loc_descr (&loc_descr
, tmp
);
18473 /* Calculate the address of the offset. */
18474 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
18475 gcc_assert (offset
< 0);
18477 tmp
= int_loc_descriptor (-offset
);
18478 add_loc_descr (&loc_descr
, tmp
);
18479 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
18480 add_loc_descr (&loc_descr
, tmp
);
18482 /* Extract the offset. */
18483 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
18484 add_loc_descr (&loc_descr
, tmp
);
18486 /* Add it to the object address. */
18487 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
18488 add_loc_descr (&loc_descr
, tmp
);
18491 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
18495 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
18497 /* If loc_descr is available then we know the field offset is dynamic.
18498 However, GDB does not handle dynamic field offsets very well at the
18500 if (loc_descr
!= NULL
&& gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
)
18506 /* Data member location evalutation starts with the base address on the
18507 stack. Compute the field offset and add it to this base address. */
18508 else if (loc_descr
!= NULL
)
18509 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
18514 /* While DW_AT_data_bit_offset has been added already in DWARF4,
18515 e.g. GDB only added support to it in November 2016. For DWARF5
18516 we need newer debug info consumers anyway. We might change this
18517 to dwarf_version >= 4 once most consumers catched up. */
18518 if (dwarf_version
>= 5
18519 && TREE_CODE (decl
) == FIELD_DECL
18520 && DECL_BIT_FIELD_TYPE (decl
))
18522 tree off
= bit_position (decl
);
18523 if (tree_fits_uhwi_p (off
) && get_AT (die
, DW_AT_bit_size
))
18525 remove_AT (die
, DW_AT_byte_size
);
18526 remove_AT (die
, DW_AT_bit_offset
);
18527 add_AT_unsigned (die
, DW_AT_data_bit_offset
, tree_to_uhwi (off
));
18531 if (dwarf_version
> 2)
18533 /* Don't need to output a location expression, just the constant. */
18535 add_AT_int (die
, DW_AT_data_member_location
, offset
);
18537 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
18542 enum dwarf_location_atom op
;
18544 /* The DWARF2 standard says that we should assume that the structure
18545 address is already on the stack, so we can specify a structure
18546 field address by using DW_OP_plus_uconst. */
18547 op
= DW_OP_plus_uconst
;
18548 loc_descr
= new_loc_descr (op
, offset
, 0);
18552 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
18555 /* Writes integer values to dw_vec_const array. */
18558 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
18562 *dest
++ = val
& 0xff;
18568 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
18570 static HOST_WIDE_INT
18571 extract_int (const unsigned char *src
, unsigned int size
)
18573 HOST_WIDE_INT val
= 0;
18579 val
|= *--src
& 0xff;
18585 /* Writes wide_int values to dw_vec_const array. */
18588 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
18592 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
18594 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
18598 /* We'd have to extend this code to support odd sizes. */
18599 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
18601 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
18603 if (WORDS_BIG_ENDIAN
)
18604 for (i
= n
- 1; i
>= 0; i
--)
18606 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
18607 dest
+= sizeof (HOST_WIDE_INT
);
18610 for (i
= 0; i
< n
; i
++)
18612 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
18613 dest
+= sizeof (HOST_WIDE_INT
);
18617 /* Writes floating point values to dw_vec_const array. */
18620 insert_float (const_rtx rtl
, unsigned char *array
)
18624 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
18626 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), mode
);
18628 /* real_to_target puts 32-bit pieces in each long. Pack them. */
18629 for (i
= 0; i
< GET_MODE_SIZE (mode
) / 4; i
++)
18631 insert_int (val
[i
], 4, array
);
18636 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
18637 does not have a "location" either in memory or in a register. These
18638 things can arise in GNU C when a constant is passed as an actual parameter
18639 to an inlined function. They can also arise in C++ where declared
18640 constants do not necessarily get memory "homes". */
18643 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
18645 switch (GET_CODE (rtl
))
18649 HOST_WIDE_INT val
= INTVAL (rtl
);
18652 add_AT_int (die
, DW_AT_const_value
, val
);
18654 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
18658 case CONST_WIDE_INT
:
18660 wide_int w1
= rtx_mode_t (rtl
, MAX_MODE_INT
);
18661 unsigned int prec
= MIN (wi::min_precision (w1
, UNSIGNED
),
18662 (unsigned int)CONST_WIDE_INT_NUNITS (rtl
) * HOST_BITS_PER_WIDE_INT
);
18663 wide_int w
= wi::zext (w1
, prec
);
18664 add_AT_wide (die
, DW_AT_const_value
, w
);
18669 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
18670 floating-point constant. A CONST_DOUBLE is used whenever the
18671 constant requires more than one word in order to be adequately
18673 if (TARGET_SUPPORTS_WIDE_INT
== 0
18674 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl
)))
18675 add_AT_double (die
, DW_AT_const_value
,
18676 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
18679 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
18680 unsigned int length
= GET_MODE_SIZE (mode
);
18681 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
18683 insert_float (rtl
, array
);
18684 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
18690 machine_mode mode
= GET_MODE (rtl
);
18691 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
18692 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
18693 unsigned char *array
18694 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
18697 machine_mode imode
= GET_MODE_INNER (mode
);
18699 switch (GET_MODE_CLASS (mode
))
18701 case MODE_VECTOR_INT
:
18702 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
18704 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
18705 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
18709 case MODE_VECTOR_FLOAT
:
18710 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
18712 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
18713 insert_float (elt
, p
);
18718 gcc_unreachable ();
18721 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
18726 if (dwarf_version
>= 4 || !dwarf_strict
)
18728 dw_loc_descr_ref loc_result
;
18729 resolve_one_addr (&rtl
);
18731 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
18732 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
18733 add_AT_loc (die
, DW_AT_location
, loc_result
);
18734 vec_safe_push (used_rtx_array
, rtl
);
18740 if (CONSTANT_P (XEXP (rtl
, 0)))
18741 return add_const_value_attribute (die
, XEXP (rtl
, 0));
18744 if (!const_ok_for_output (rtl
))
18748 if (dwarf_version
>= 4 || !dwarf_strict
)
18753 /* In cases where an inlined instance of an inline function is passed
18754 the address of an `auto' variable (which is local to the caller) we
18755 can get a situation where the DECL_RTL of the artificial local
18756 variable (for the inlining) which acts as a stand-in for the
18757 corresponding formal parameter (of the inline function) will look
18758 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
18759 exactly a compile-time constant expression, but it isn't the address
18760 of the (artificial) local variable either. Rather, it represents the
18761 *value* which the artificial local variable always has during its
18762 lifetime. We currently have no way to represent such quasi-constant
18763 values in Dwarf, so for now we just punt and generate nothing. */
18771 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
18772 && MEM_READONLY_P (rtl
)
18773 && GET_MODE (rtl
) == BLKmode
)
18775 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
18781 /* No other kinds of rtx should be possible here. */
18782 gcc_unreachable ();
18787 /* Determine whether the evaluation of EXPR references any variables
18788 or functions which aren't otherwise used (and therefore may not be
18791 reference_to_unused (tree
* tp
, int * walk_subtrees
,
18792 void * data ATTRIBUTE_UNUSED
)
18794 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
18795 *walk_subtrees
= 0;
18797 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
18798 && ! TREE_ASM_WRITTEN (*tp
))
18800 /* ??? The C++ FE emits debug information for using decls, so
18801 putting gcc_unreachable here falls over. See PR31899. For now
18802 be conservative. */
18803 else if (!symtab
->global_info_ready
&& VAR_OR_FUNCTION_DECL_P (*tp
))
18805 else if (VAR_P (*tp
))
18807 varpool_node
*node
= varpool_node::get (*tp
);
18808 if (!node
|| !node
->definition
)
18811 else if (TREE_CODE (*tp
) == FUNCTION_DECL
18812 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
18814 /* The call graph machinery must have finished analyzing,
18815 optimizing and gimplifying the CU by now.
18816 So if *TP has no call graph node associated
18817 to it, it means *TP will not be emitted. */
18818 if (!cgraph_node::get (*tp
))
18821 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
18827 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
18828 for use in a later add_const_value_attribute call. */
18831 rtl_for_decl_init (tree init
, tree type
)
18833 rtx rtl
= NULL_RTX
;
18837 /* If a variable is initialized with a string constant without embedded
18838 zeros, build CONST_STRING. */
18839 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
18841 tree enttype
= TREE_TYPE (type
);
18842 tree domain
= TYPE_DOMAIN (type
);
18843 scalar_int_mode mode
;
18845 if (is_int_mode (TYPE_MODE (enttype
), &mode
)
18846 && GET_MODE_SIZE (mode
) == 1
18848 && integer_zerop (TYPE_MIN_VALUE (domain
))
18849 && compare_tree_int (TYPE_MAX_VALUE (domain
),
18850 TREE_STRING_LENGTH (init
) - 1) == 0
18851 && ((size_t) TREE_STRING_LENGTH (init
)
18852 == strlen (TREE_STRING_POINTER (init
)) + 1))
18854 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
18855 ggc_strdup (TREE_STRING_POINTER (init
)));
18856 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
18857 MEM_READONLY_P (rtl
) = 1;
18860 /* Other aggregates, and complex values, could be represented using
18862 else if (AGGREGATE_TYPE_P (type
)
18863 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
18864 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
18865 || TREE_CODE (type
) == COMPLEX_TYPE
)
18867 /* Vectors only work if their mode is supported by the target.
18868 FIXME: generic vectors ought to work too. */
18869 else if (TREE_CODE (type
) == VECTOR_TYPE
18870 && !VECTOR_MODE_P (TYPE_MODE (type
)))
18872 /* If the initializer is something that we know will expand into an
18873 immediate RTL constant, expand it now. We must be careful not to
18874 reference variables which won't be output. */
18875 else if (initializer_constant_valid_p (init
, type
)
18876 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
18878 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
18880 if (TREE_CODE (type
) == VECTOR_TYPE
)
18881 switch (TREE_CODE (init
))
18886 if (TREE_CONSTANT (init
))
18888 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
18889 bool constant_p
= true;
18891 unsigned HOST_WIDE_INT ix
;
18893 /* Even when ctor is constant, it might contain non-*_CST
18894 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
18895 belong into VECTOR_CST nodes. */
18896 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
18897 if (!CONSTANT_CLASS_P (value
))
18899 constant_p
= false;
18905 init
= build_vector_from_ctor (type
, elts
);
18915 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
18917 /* If expand_expr returns a MEM, it wasn't immediate. */
18918 gcc_assert (!rtl
|| !MEM_P (rtl
));
18924 /* Generate RTL for the variable DECL to represent its location. */
18927 rtl_for_decl_location (tree decl
)
18931 /* Here we have to decide where we are going to say the parameter "lives"
18932 (as far as the debugger is concerned). We only have a couple of
18933 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
18935 DECL_RTL normally indicates where the parameter lives during most of the
18936 activation of the function. If optimization is enabled however, this
18937 could be either NULL or else a pseudo-reg. Both of those cases indicate
18938 that the parameter doesn't really live anywhere (as far as the code
18939 generation parts of GCC are concerned) during most of the function's
18940 activation. That will happen (for example) if the parameter is never
18941 referenced within the function.
18943 We could just generate a location descriptor here for all non-NULL
18944 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
18945 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
18946 where DECL_RTL is NULL or is a pseudo-reg.
18948 Note however that we can only get away with using DECL_INCOMING_RTL as
18949 a backup substitute for DECL_RTL in certain limited cases. In cases
18950 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
18951 we can be sure that the parameter was passed using the same type as it is
18952 declared to have within the function, and that its DECL_INCOMING_RTL
18953 points us to a place where a value of that type is passed.
18955 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
18956 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
18957 because in these cases DECL_INCOMING_RTL points us to a value of some
18958 type which is *different* from the type of the parameter itself. Thus,
18959 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
18960 such cases, the debugger would end up (for example) trying to fetch a
18961 `float' from a place which actually contains the first part of a
18962 `double'. That would lead to really incorrect and confusing
18963 output at debug-time.
18965 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
18966 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
18967 are a couple of exceptions however. On little-endian machines we can
18968 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
18969 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
18970 an integral type that is smaller than TREE_TYPE (decl). These cases arise
18971 when (on a little-endian machine) a non-prototyped function has a
18972 parameter declared to be of type `short' or `char'. In such cases,
18973 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
18974 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
18975 passed `int' value. If the debugger then uses that address to fetch
18976 a `short' or a `char' (on a little-endian machine) the result will be
18977 the correct data, so we allow for such exceptional cases below.
18979 Note that our goal here is to describe the place where the given formal
18980 parameter lives during most of the function's activation (i.e. between the
18981 end of the prologue and the start of the epilogue). We'll do that as best
18982 as we can. Note however that if the given formal parameter is modified
18983 sometime during the execution of the function, then a stack backtrace (at
18984 debug-time) will show the function as having been called with the *new*
18985 value rather than the value which was originally passed in. This happens
18986 rarely enough that it is not a major problem, but it *is* a problem, and
18987 I'd like to fix it.
18989 A future version of dwarf2out.c may generate two additional attributes for
18990 any given DW_TAG_formal_parameter DIE which will describe the "passed
18991 type" and the "passed location" for the given formal parameter in addition
18992 to the attributes we now generate to indicate the "declared type" and the
18993 "active location" for each parameter. This additional set of attributes
18994 could be used by debuggers for stack backtraces. Separately, note that
18995 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
18996 This happens (for example) for inlined-instances of inline function formal
18997 parameters which are never referenced. This really shouldn't be
18998 happening. All PARM_DECL nodes should get valid non-NULL
18999 DECL_INCOMING_RTL values. FIXME. */
19001 /* Use DECL_RTL as the "location" unless we find something better. */
19002 rtl
= DECL_RTL_IF_SET (decl
);
19004 /* When generating abstract instances, ignore everything except
19005 constants, symbols living in memory, and symbols living in
19006 fixed registers. */
19007 if (! reload_completed
)
19010 && (CONSTANT_P (rtl
)
19012 && CONSTANT_P (XEXP (rtl
, 0)))
19015 && TREE_STATIC (decl
))))
19017 rtl
= targetm
.delegitimize_address (rtl
);
19022 else if (TREE_CODE (decl
) == PARM_DECL
)
19024 if (rtl
== NULL_RTX
19025 || is_pseudo_reg (rtl
)
19027 && is_pseudo_reg (XEXP (rtl
, 0))
19028 && DECL_INCOMING_RTL (decl
)
19029 && MEM_P (DECL_INCOMING_RTL (decl
))
19030 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
19032 tree declared_type
= TREE_TYPE (decl
);
19033 tree passed_type
= DECL_ARG_TYPE (decl
);
19034 machine_mode dmode
= TYPE_MODE (declared_type
);
19035 machine_mode pmode
= TYPE_MODE (passed_type
);
19037 /* This decl represents a formal parameter which was optimized out.
19038 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
19039 all cases where (rtl == NULL_RTX) just below. */
19040 if (dmode
== pmode
)
19041 rtl
= DECL_INCOMING_RTL (decl
);
19042 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
19043 && SCALAR_INT_MODE_P (dmode
)
19044 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
19045 && DECL_INCOMING_RTL (decl
))
19047 rtx inc
= DECL_INCOMING_RTL (decl
);
19050 else if (MEM_P (inc
))
19052 if (BYTES_BIG_ENDIAN
)
19053 rtl
= adjust_address_nv (inc
, dmode
,
19054 GET_MODE_SIZE (pmode
)
19055 - GET_MODE_SIZE (dmode
));
19062 /* If the parm was passed in registers, but lives on the stack, then
19063 make a big endian correction if the mode of the type of the
19064 parameter is not the same as the mode of the rtl. */
19065 /* ??? This is the same series of checks that are made in dbxout.c before
19066 we reach the big endian correction code there. It isn't clear if all
19067 of these checks are necessary here, but keeping them all is the safe
19069 else if (MEM_P (rtl
)
19070 && XEXP (rtl
, 0) != const0_rtx
19071 && ! CONSTANT_P (XEXP (rtl
, 0))
19072 /* Not passed in memory. */
19073 && !MEM_P (DECL_INCOMING_RTL (decl
))
19074 /* Not passed by invisible reference. */
19075 && (!REG_P (XEXP (rtl
, 0))
19076 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
19077 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
19078 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
19079 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
19082 /* Big endian correction check. */
19083 && BYTES_BIG_ENDIAN
19084 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
19085 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
19088 machine_mode addr_mode
= get_address_mode (rtl
);
19089 int offset
= (UNITS_PER_WORD
19090 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
19092 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19093 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19096 else if (VAR_P (decl
)
19099 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
19100 && BYTES_BIG_ENDIAN
)
19102 machine_mode addr_mode
= get_address_mode (rtl
);
19103 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
19104 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
19106 /* If a variable is declared "register" yet is smaller than
19107 a register, then if we store the variable to memory, it
19108 looks like we're storing a register-sized value, when in
19109 fact we are not. We need to adjust the offset of the
19110 storage location to reflect the actual value's bytes,
19111 else gdb will not be able to display it. */
19113 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19114 plus_constant (addr_mode
, XEXP (rtl
, 0),
19118 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
19119 and will have been substituted directly into all expressions that use it.
19120 C does not have such a concept, but C++ and other languages do. */
19121 if (!rtl
&& VAR_P (decl
) && DECL_INITIAL (decl
))
19122 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
19125 rtl
= targetm
.delegitimize_address (rtl
);
19127 /* If we don't look past the constant pool, we risk emitting a
19128 reference to a constant pool entry that isn't referenced from
19129 code, and thus is not emitted. */
19131 rtl
= avoid_constant_pool_reference (rtl
);
19133 /* Try harder to get a rtl. If this symbol ends up not being emitted
19134 in the current CU, resolve_addr will remove the expression referencing
19136 if (rtl
== NULL_RTX
19138 && !DECL_EXTERNAL (decl
)
19139 && TREE_STATIC (decl
)
19140 && DECL_NAME (decl
)
19141 && !DECL_HARD_REGISTER (decl
)
19142 && DECL_MODE (decl
) != VOIDmode
)
19144 rtl
= make_decl_rtl_for_debug (decl
);
19146 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
19147 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
19154 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
19155 returned. If so, the decl for the COMMON block is returned, and the
19156 value is the offset into the common block for the symbol. */
19159 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
19161 tree val_expr
, cvar
;
19163 HOST_WIDE_INT bitsize
, bitpos
;
19165 int unsignedp
, reversep
, volatilep
= 0;
19167 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
19168 it does not have a value (the offset into the common area), or if it
19169 is thread local (as opposed to global) then it isn't common, and shouldn't
19170 be handled as such. */
19172 || !TREE_STATIC (decl
)
19173 || !DECL_HAS_VALUE_EXPR_P (decl
)
19177 val_expr
= DECL_VALUE_EXPR (decl
);
19178 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
19181 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
19182 &unsignedp
, &reversep
, &volatilep
);
19184 if (cvar
== NULL_TREE
19186 || DECL_ARTIFICIAL (cvar
)
19187 || !TREE_PUBLIC (cvar
))
19191 if (offset
!= NULL
)
19193 if (!tree_fits_shwi_p (offset
))
19195 *value
= tree_to_shwi (offset
);
19198 *value
+= bitpos
/ BITS_PER_UNIT
;
19203 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
19204 data attribute for a variable or a parameter. We generate the
19205 DW_AT_const_value attribute only in those cases where the given variable
19206 or parameter does not have a true "location" either in memory or in a
19207 register. This can happen (for example) when a constant is passed as an
19208 actual argument in a call to an inline function. (It's possible that
19209 these things can crop up in other ways also.) Note that one type of
19210 constant value which can be passed into an inlined function is a constant
19211 pointer. This can happen for example if an actual argument in an inlined
19212 function call evaluates to a compile-time constant address.
19214 CACHE_P is true if it is worth caching the location list for DECL,
19215 so that future calls can reuse it rather than regenerate it from scratch.
19216 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
19217 since we will need to refer to them each time the function is inlined. */
19220 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
19223 dw_loc_list_ref list
;
19224 var_loc_list
*loc_list
;
19225 cached_dw_loc_list
*cache
;
19230 if (TREE_CODE (decl
) == ERROR_MARK
)
19233 if (get_AT (die
, DW_AT_location
)
19234 || get_AT (die
, DW_AT_const_value
))
19237 gcc_assert (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
19238 || TREE_CODE (decl
) == RESULT_DECL
);
19240 /* Try to get some constant RTL for this decl, and use that as the value of
19243 rtl
= rtl_for_decl_location (decl
);
19244 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
19245 && add_const_value_attribute (die
, rtl
))
19248 /* See if we have single element location list that is equivalent to
19249 a constant value. That way we are better to use add_const_value_attribute
19250 rather than expanding constant value equivalent. */
19251 loc_list
= lookup_decl_loc (decl
);
19254 && loc_list
->first
->next
== NULL
19255 && NOTE_P (loc_list
->first
->loc
)
19256 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
19257 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
19259 struct var_loc_node
*node
;
19261 node
= loc_list
->first
;
19262 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
19263 if (GET_CODE (rtl
) == EXPR_LIST
)
19264 rtl
= XEXP (rtl
, 0);
19265 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
19266 && add_const_value_attribute (die
, rtl
))
19269 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
19270 list several times. See if we've already cached the contents. */
19272 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
19276 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
19278 list
= cache
->loc_list
;
19282 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
19284 /* It is usually worth caching this result if the decl is from
19285 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
19286 if (cache_p
&& list
&& list
->dw_loc_next
)
19288 cached_dw_loc_list
**slot
19289 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
19292 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
19293 cache
->decl_id
= DECL_UID (decl
);
19294 cache
->loc_list
= list
;
19300 add_AT_location_description (die
, DW_AT_location
, list
);
19303 /* None of that worked, so it must not really have a location;
19304 try adding a constant value attribute from the DECL_INITIAL. */
19305 return tree_add_const_value_attribute_for_decl (die
, decl
);
19308 /* Helper function for tree_add_const_value_attribute. Natively encode
19309 initializer INIT into an array. Return true if successful. */
19312 native_encode_initializer (tree init
, unsigned char *array
, int size
)
19316 if (init
== NULL_TREE
)
19320 switch (TREE_CODE (init
))
19323 type
= TREE_TYPE (init
);
19324 if (TREE_CODE (type
) == ARRAY_TYPE
)
19326 tree enttype
= TREE_TYPE (type
);
19327 scalar_int_mode mode
;
19329 if (!is_int_mode (TYPE_MODE (enttype
), &mode
)
19330 || GET_MODE_SIZE (mode
) != 1)
19332 if (int_size_in_bytes (type
) != size
)
19334 if (size
> TREE_STRING_LENGTH (init
))
19336 memcpy (array
, TREE_STRING_POINTER (init
),
19337 TREE_STRING_LENGTH (init
));
19338 memset (array
+ TREE_STRING_LENGTH (init
),
19339 '\0', size
- TREE_STRING_LENGTH (init
));
19342 memcpy (array
, TREE_STRING_POINTER (init
), size
);
19347 type
= TREE_TYPE (init
);
19348 if (int_size_in_bytes (type
) != size
)
19350 if (TREE_CODE (type
) == ARRAY_TYPE
)
19352 HOST_WIDE_INT min_index
;
19353 unsigned HOST_WIDE_INT cnt
;
19354 int curpos
= 0, fieldsize
;
19355 constructor_elt
*ce
;
19357 if (TYPE_DOMAIN (type
) == NULL_TREE
19358 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
19361 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
19362 if (fieldsize
<= 0)
19365 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
19366 memset (array
, '\0', size
);
19367 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
19369 tree val
= ce
->value
;
19370 tree index
= ce
->index
;
19372 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
19373 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
19376 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
19381 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
19384 curpos
= pos
+ fieldsize
;
19385 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
19387 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
19388 - tree_to_shwi (TREE_OPERAND (index
, 0));
19389 while (count
-- > 0)
19392 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
19393 curpos
+= fieldsize
;
19396 gcc_assert (curpos
<= size
);
19400 else if (TREE_CODE (type
) == RECORD_TYPE
19401 || TREE_CODE (type
) == UNION_TYPE
)
19403 tree field
= NULL_TREE
;
19404 unsigned HOST_WIDE_INT cnt
;
19405 constructor_elt
*ce
;
19407 if (int_size_in_bytes (type
) != size
)
19410 if (TREE_CODE (type
) == RECORD_TYPE
)
19411 field
= TYPE_FIELDS (type
);
19413 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
19415 tree val
= ce
->value
;
19416 int pos
, fieldsize
;
19418 if (ce
->index
!= 0)
19424 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
19427 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
19428 && TYPE_DOMAIN (TREE_TYPE (field
))
19429 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
19431 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
19432 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
19434 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
19435 pos
= int_byte_position (field
);
19436 gcc_assert (pos
+ fieldsize
<= size
);
19437 if (val
&& fieldsize
!= 0
19438 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
19444 case VIEW_CONVERT_EXPR
:
19445 case NON_LVALUE_EXPR
:
19446 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
19448 return native_encode_expr (init
, array
, size
) == size
;
19452 /* Attach a DW_AT_const_value attribute to DIE. The value of the
19453 attribute is the const value T. */
19456 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
19459 tree type
= TREE_TYPE (t
);
19462 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
19466 gcc_assert (!DECL_P (init
));
19470 rtl
= rtl_for_decl_init (init
, type
);
19472 return add_const_value_attribute (die
, rtl
);
19474 /* If the host and target are sane, try harder. */
19475 if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
19476 && initializer_constant_valid_p (init
, type
))
19478 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
19479 if (size
> 0 && (int) size
== size
)
19481 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
19483 if (native_encode_initializer (init
, array
, size
))
19485 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
19494 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
19495 attribute is the const value of T, where T is an integral constant
19496 variable with static storage duration
19497 (so it can't be a PARM_DECL or a RESULT_DECL). */
19500 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
19504 || (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
19505 || (VAR_P (decl
) && !TREE_STATIC (decl
)))
19508 if (TREE_READONLY (decl
)
19509 && ! TREE_THIS_VOLATILE (decl
)
19510 && DECL_INITIAL (decl
))
19515 /* Don't add DW_AT_const_value if abstract origin already has one. */
19516 if (get_AT (var_die
, DW_AT_const_value
))
19519 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
19522 /* Convert the CFI instructions for the current function into a
19523 location list. This is used for DW_AT_frame_base when we targeting
19524 a dwarf2 consumer that does not support the dwarf3
19525 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
19528 static dw_loc_list_ref
19529 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
19533 dw_loc_list_ref list
, *list_tail
;
19535 dw_cfa_location last_cfa
, next_cfa
;
19536 const char *start_label
, *last_label
, *section
;
19537 dw_cfa_location remember
;
19540 gcc_assert (fde
!= NULL
);
19542 section
= secname_for_decl (current_function_decl
);
19546 memset (&next_cfa
, 0, sizeof (next_cfa
));
19547 next_cfa
.reg
= INVALID_REGNUM
;
19548 remember
= next_cfa
;
19550 start_label
= fde
->dw_fde_begin
;
19552 /* ??? Bald assumption that the CIE opcode list does not contain
19553 advance opcodes. */
19554 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
19555 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
19557 last_cfa
= next_cfa
;
19558 last_label
= start_label
;
19560 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
19562 /* If the first partition contained no CFI adjustments, the
19563 CIE opcodes apply to the whole first partition. */
19564 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19565 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
19566 list_tail
=&(*list_tail
)->dw_loc_next
;
19567 start_label
= last_label
= fde
->dw_fde_second_begin
;
19570 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
19572 switch (cfi
->dw_cfi_opc
)
19574 case DW_CFA_set_loc
:
19575 case DW_CFA_advance_loc1
:
19576 case DW_CFA_advance_loc2
:
19577 case DW_CFA_advance_loc4
:
19578 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
19580 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19581 start_label
, last_label
, section
);
19583 list_tail
= &(*list_tail
)->dw_loc_next
;
19584 last_cfa
= next_cfa
;
19585 start_label
= last_label
;
19587 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
19590 case DW_CFA_advance_loc
:
19591 /* The encoding is complex enough that we should never emit this. */
19592 gcc_unreachable ();
19595 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
19598 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
19600 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
19602 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19603 start_label
, last_label
, section
);
19605 list_tail
= &(*list_tail
)->dw_loc_next
;
19606 last_cfa
= next_cfa
;
19607 start_label
= last_label
;
19609 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19610 start_label
, fde
->dw_fde_end
, section
);
19611 list_tail
= &(*list_tail
)->dw_loc_next
;
19612 start_label
= last_label
= fde
->dw_fde_second_begin
;
19616 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
19618 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19619 start_label
, last_label
, section
);
19620 list_tail
= &(*list_tail
)->dw_loc_next
;
19621 start_label
= last_label
;
19624 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
19626 fde
->dw_fde_second_begin
19627 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
19630 if (list
&& list
->dw_loc_next
)
19636 /* Compute a displacement from the "steady-state frame pointer" to the
19637 frame base (often the same as the CFA), and store it in
19638 frame_pointer_fb_offset. OFFSET is added to the displacement
19639 before the latter is negated. */
19642 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
19646 #ifdef FRAME_POINTER_CFA_OFFSET
19647 reg
= frame_pointer_rtx
;
19648 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
19650 reg
= arg_pointer_rtx
;
19651 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
19654 elim
= (ira_use_lra_p
19655 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
19656 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
19657 if (GET_CODE (elim
) == PLUS
)
19659 offset
+= INTVAL (XEXP (elim
, 1));
19660 elim
= XEXP (elim
, 0);
19663 frame_pointer_fb_offset
= -offset
;
19665 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
19666 in which to eliminate. This is because it's stack pointer isn't
19667 directly accessible as a register within the ISA. To work around
19668 this, assume that while we cannot provide a proper value for
19669 frame_pointer_fb_offset, we won't need one either. */
19670 frame_pointer_fb_offset_valid
19671 = ((SUPPORTS_STACK_ALIGNMENT
19672 && (elim
== hard_frame_pointer_rtx
19673 || elim
== stack_pointer_rtx
))
19674 || elim
== (frame_pointer_needed
19675 ? hard_frame_pointer_rtx
19676 : stack_pointer_rtx
));
19679 /* Generate a DW_AT_name attribute given some string value to be included as
19680 the value of the attribute. */
19683 add_name_attribute (dw_die_ref die
, const char *name_string
)
19685 if (name_string
!= NULL
&& *name_string
!= 0)
19687 if (demangle_name_func
)
19688 name_string
= (*demangle_name_func
) (name_string
);
19690 add_AT_string (die
, DW_AT_name
, name_string
);
19694 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
19695 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
19696 of TYPE accordingly.
19698 ??? This is a temporary measure until after we're able to generate
19699 regular DWARF for the complex Ada type system. */
19702 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
19703 dw_die_ref context_die
)
19706 dw_die_ref dtype_die
;
19708 if (!lang_hooks
.types
.descriptive_type
)
19711 dtype
= lang_hooks
.types
.descriptive_type (type
);
19715 dtype_die
= lookup_type_die (dtype
);
19718 gen_type_die (dtype
, context_die
);
19719 dtype_die
= lookup_type_die (dtype
);
19720 gcc_assert (dtype_die
);
19723 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
19726 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
19728 static const char *
19729 comp_dir_string (void)
19733 static const char *cached_wd
= NULL
;
19735 if (cached_wd
!= NULL
)
19738 wd
= get_src_pwd ();
19742 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
19746 wdlen
= strlen (wd
);
19747 wd1
= ggc_vec_alloc
<char> (wdlen
+ 2);
19749 wd1
[wdlen
] = DIR_SEPARATOR
;
19750 wd1
[wdlen
+ 1] = 0;
19754 cached_wd
= remap_debug_filename (wd
);
19758 /* Generate a DW_AT_comp_dir attribute for DIE. */
19761 add_comp_dir_attribute (dw_die_ref die
)
19763 const char * wd
= comp_dir_string ();
19765 add_AT_string (die
, DW_AT_comp_dir
, wd
);
19768 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
19769 pointer computation, ...), output a representation for that bound according
19770 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
19771 loc_list_from_tree for the meaning of CONTEXT. */
19774 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
19775 int forms
, struct loc_descr_context
*context
)
19777 dw_die_ref context_die
, decl_die
;
19778 dw_loc_list_ref list
;
19779 bool strip_conversions
= true;
19780 bool placeholder_seen
= false;
19782 while (strip_conversions
)
19783 switch (TREE_CODE (value
))
19790 case VIEW_CONVERT_EXPR
:
19791 value
= TREE_OPERAND (value
, 0);
19795 strip_conversions
= false;
19799 /* If possible and permitted, output the attribute as a constant. */
19800 if ((forms
& dw_scalar_form_constant
) != 0
19801 && TREE_CODE (value
) == INTEGER_CST
)
19803 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
19805 /* If HOST_WIDE_INT is big enough then represent the bound as
19806 a constant value. We need to choose a form based on
19807 whether the type is signed or unsigned. We cannot just
19808 call add_AT_unsigned if the value itself is positive
19809 (add_AT_unsigned might add the unsigned value encoded as
19810 DW_FORM_data[1248]). Some DWARF consumers will lookup the
19811 bounds type and then sign extend any unsigned values found
19812 for signed types. This is needed only for
19813 DW_AT_{lower,upper}_bound, since for most other attributes,
19814 consumers will treat DW_FORM_data[1248] as unsigned values,
19815 regardless of the underlying type. */
19816 if (prec
<= HOST_BITS_PER_WIDE_INT
19817 || tree_fits_uhwi_p (value
))
19819 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
19820 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
19822 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
19825 /* Otherwise represent the bound as an unsigned value with
19826 the precision of its type. The precision and signedness
19827 of the type will be necessary to re-interpret it
19829 add_AT_wide (die
, attr
, value
);
19833 /* Otherwise, if it's possible and permitted too, output a reference to
19835 if ((forms
& dw_scalar_form_reference
) != 0)
19837 tree decl
= NULL_TREE
;
19839 /* Some type attributes reference an outer type. For instance, the upper
19840 bound of an array may reference an embedding record (this happens in
19842 if (TREE_CODE (value
) == COMPONENT_REF
19843 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
19844 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
19845 decl
= TREE_OPERAND (value
, 1);
19847 else if (VAR_P (value
)
19848 || TREE_CODE (value
) == PARM_DECL
19849 || TREE_CODE (value
) == RESULT_DECL
)
19852 if (decl
!= NULL_TREE
)
19854 dw_die_ref decl_die
= lookup_decl_die (decl
);
19856 /* ??? Can this happen, or should the variable have been bound
19857 first? Probably it can, since I imagine that we try to create
19858 the types of parameters in the order in which they exist in
19859 the list, and won't have created a forward reference to a
19860 later parameter. */
19861 if (decl_die
!= NULL
)
19863 add_AT_die_ref (die
, attr
, decl_die
);
19869 /* Last chance: try to create a stack operation procedure to evaluate the
19870 value. Do nothing if even that is not possible or permitted. */
19871 if ((forms
& dw_scalar_form_exprloc
) == 0)
19874 list
= loc_list_from_tree (value
, 2, context
);
19875 if (context
&& context
->placeholder_arg
)
19877 placeholder_seen
= context
->placeholder_seen
;
19878 context
->placeholder_seen
= false;
19880 if (list
== NULL
|| single_element_loc_list_p (list
))
19882 /* If this attribute is not a reference nor constant, it is
19883 a DWARF expression rather than location description. For that
19884 loc_list_from_tree (value, 0, &context) is needed. */
19885 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
19886 if (list2
&& single_element_loc_list_p (list2
))
19888 if (placeholder_seen
)
19890 struct dwarf_procedure_info dpi
;
19891 dpi
.fndecl
= NULL_TREE
;
19892 dpi
.args_count
= 1;
19893 if (!resolve_args_picking (list2
->expr
, 1, &dpi
))
19896 add_AT_loc (die
, attr
, list2
->expr
);
19901 /* If that failed to give a single element location list, fall back to
19902 outputting this as a reference... still if permitted. */
19904 || (forms
& dw_scalar_form_reference
) == 0
19905 || placeholder_seen
)
19908 if (current_function_decl
== 0)
19909 context_die
= comp_unit_die ();
19911 context_die
= lookup_decl_die (current_function_decl
);
19913 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
19914 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
19915 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
19917 add_AT_location_description (decl_die
, DW_AT_location
, list
);
19918 add_AT_die_ref (die
, attr
, decl_die
);
19921 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
19925 lower_bound_default (void)
19927 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
19933 case DW_LANG_C_plus_plus
:
19934 case DW_LANG_C_plus_plus_11
:
19935 case DW_LANG_C_plus_plus_14
:
19937 case DW_LANG_ObjC_plus_plus
:
19939 case DW_LANG_Fortran77
:
19940 case DW_LANG_Fortran90
:
19941 case DW_LANG_Fortran95
:
19942 case DW_LANG_Fortran03
:
19943 case DW_LANG_Fortran08
:
19947 case DW_LANG_Python
:
19948 return dwarf_version
>= 4 ? 0 : -1;
19949 case DW_LANG_Ada95
:
19950 case DW_LANG_Ada83
:
19951 case DW_LANG_Cobol74
:
19952 case DW_LANG_Cobol85
:
19953 case DW_LANG_Modula2
:
19955 return dwarf_version
>= 4 ? 1 : -1;
19961 /* Given a tree node describing an array bound (either lower or upper) output
19962 a representation for that bound. */
19965 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
19966 tree bound
, struct loc_descr_context
*context
)
19971 switch (TREE_CODE (bound
))
19973 /* Strip all conversions. */
19975 case VIEW_CONVERT_EXPR
:
19976 bound
= TREE_OPERAND (bound
, 0);
19979 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
19980 are even omitted when they are the default. */
19982 /* If the value for this bound is the default one, we can even omit the
19984 if (bound_attr
== DW_AT_lower_bound
19985 && tree_fits_shwi_p (bound
)
19986 && (dflt
= lower_bound_default ()) != -1
19987 && tree_to_shwi (bound
) == dflt
)
19993 /* Because of the complex interaction there can be with other GNAT
19994 encodings, GDB isn't ready yet to handle proper DWARF description
19995 for self-referencial subrange bounds: let GNAT encodings do the
19996 magic in such a case. */
19998 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
19999 && contains_placeholder_p (bound
))
20002 add_scalar_info (subrange_die
, bound_attr
, bound
,
20003 dw_scalar_form_constant
20004 | dw_scalar_form_exprloc
20005 | dw_scalar_form_reference
,
20011 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
20012 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
20013 Note that the block of subscript information for an array type also
20014 includes information about the element type of the given array type.
20016 This function reuses previously set type and bound information if
20020 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
20022 unsigned dimension_number
;
20024 dw_die_ref child
= type_die
->die_child
;
20026 for (dimension_number
= 0;
20027 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
20028 type
= TREE_TYPE (type
), dimension_number
++)
20030 tree domain
= TYPE_DOMAIN (type
);
20032 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
20035 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
20036 and (in GNU C only) variable bounds. Handle all three forms
20039 /* Find and reuse a previously generated DW_TAG_subrange_type if
20042 For multi-dimensional arrays, as we iterate through the
20043 various dimensions in the enclosing for loop above, we also
20044 iterate through the DIE children and pick at each
20045 DW_TAG_subrange_type previously generated (if available).
20046 Each child DW_TAG_subrange_type DIE describes the range of
20047 the current dimension. At this point we should have as many
20048 DW_TAG_subrange_type's as we have dimensions in the
20050 dw_die_ref subrange_die
= NULL
;
20054 child
= child
->die_sib
;
20055 if (child
->die_tag
== DW_TAG_subrange_type
)
20056 subrange_die
= child
;
20057 if (child
== type_die
->die_child
)
20059 /* If we wrapped around, stop looking next time. */
20063 if (child
->die_tag
== DW_TAG_subrange_type
)
20067 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
20071 /* We have an array type with specified bounds. */
20072 lower
= TYPE_MIN_VALUE (domain
);
20073 upper
= TYPE_MAX_VALUE (domain
);
20075 /* Define the index type. */
20076 if (TREE_TYPE (domain
)
20077 && !get_AT (subrange_die
, DW_AT_type
))
20079 /* ??? This is probably an Ada unnamed subrange type. Ignore the
20080 TREE_TYPE field. We can't emit debug info for this
20081 because it is an unnamed integral type. */
20082 if (TREE_CODE (domain
) == INTEGER_TYPE
20083 && TYPE_NAME (domain
) == NULL_TREE
20084 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
20085 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
20088 add_type_attribute (subrange_die
, TREE_TYPE (domain
),
20089 TYPE_UNQUALIFIED
, false, type_die
);
20092 /* ??? If upper is NULL, the array has unspecified length,
20093 but it does have a lower bound. This happens with Fortran
20095 Since the debugger is definitely going to need to know N
20096 to produce useful results, go ahead and output the lower
20097 bound solo, and hope the debugger can cope. */
20099 if (!get_AT (subrange_die
, DW_AT_lower_bound
))
20100 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
20101 if (upper
&& !get_AT (subrange_die
, DW_AT_upper_bound
))
20102 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
20105 /* Otherwise we have an array type with an unspecified length. The
20106 DWARF-2 spec does not say how to handle this; let's just leave out the
20111 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
20114 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
20116 dw_die_ref decl_die
;
20117 HOST_WIDE_INT size
;
20118 dw_loc_descr_ref size_expr
= NULL
;
20120 switch (TREE_CODE (tree_node
))
20125 case ENUMERAL_TYPE
:
20128 case QUAL_UNION_TYPE
:
20129 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
20130 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
20132 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
20135 size_expr
= type_byte_size (tree_node
, &size
);
20138 /* For a data member of a struct or union, the DW_AT_byte_size is
20139 generally given as the number of bytes normally allocated for an
20140 object of the *declared* type of the member itself. This is true
20141 even for bit-fields. */
20142 size
= int_size_in_bytes (field_type (tree_node
));
20145 gcc_unreachable ();
20148 /* Support for dynamically-sized objects was introduced by DWARFv3.
20149 At the moment, GDB does not handle variable byte sizes very well,
20151 if ((dwarf_version
>= 3 || !dwarf_strict
)
20152 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
20153 && size_expr
!= NULL
)
20154 add_AT_loc (die
, DW_AT_byte_size
, size_expr
);
20156 /* Note that `size' might be -1 when we get to this point. If it is, that
20157 indicates that the byte size of the entity in question is variable and
20158 that we could not generate a DWARF expression that computes it. */
20160 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
20163 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
20167 add_alignment_attribute (dw_die_ref die
, tree tree_node
)
20169 if (dwarf_version
< 5 && dwarf_strict
)
20174 if (DECL_P (tree_node
))
20176 if (!DECL_USER_ALIGN (tree_node
))
20179 align
= DECL_ALIGN_UNIT (tree_node
);
20181 else if (TYPE_P (tree_node
))
20183 if (!TYPE_USER_ALIGN (tree_node
))
20186 align
= TYPE_ALIGN_UNIT (tree_node
);
20189 gcc_unreachable ();
20191 add_AT_unsigned (die
, DW_AT_alignment
, align
);
20194 /* For a FIELD_DECL node which represents a bit-field, output an attribute
20195 which specifies the distance in bits from the highest order bit of the
20196 "containing object" for the bit-field to the highest order bit of the
20199 For any given bit-field, the "containing object" is a hypothetical object
20200 (of some integral or enum type) within which the given bit-field lives. The
20201 type of this hypothetical "containing object" is always the same as the
20202 declared type of the individual bit-field itself. The determination of the
20203 exact location of the "containing object" for a bit-field is rather
20204 complicated. It's handled by the `field_byte_offset' function (above).
20206 CTX is required: see the comment for VLR_CONTEXT.
20208 Note that it is the size (in bytes) of the hypothetical "containing object"
20209 which will be given in the DW_AT_byte_size attribute for this bit-field.
20210 (See `byte_size_attribute' above). */
20213 add_bit_offset_attribute (dw_die_ref die
, tree decl
, struct vlr_context
*ctx
)
20215 HOST_WIDE_INT object_offset_in_bytes
;
20216 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
20217 HOST_WIDE_INT bitpos_int
;
20218 HOST_WIDE_INT highest_order_object_bit_offset
;
20219 HOST_WIDE_INT highest_order_field_bit_offset
;
20220 HOST_WIDE_INT bit_offset
;
20222 field_byte_offset (decl
, ctx
, &object_offset_in_bytes
);
20224 /* Must be a field and a bit field. */
20225 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
20227 /* We can't yet handle bit-fields whose offsets are variable, so if we
20228 encounter such things, just return without generating any attribute
20229 whatsoever. Likewise for variable or too large size. */
20230 if (! tree_fits_shwi_p (bit_position (decl
))
20231 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
20234 bitpos_int
= int_bit_position (decl
);
20236 /* Note that the bit offset is always the distance (in bits) from the
20237 highest-order bit of the "containing object" to the highest-order bit of
20238 the bit-field itself. Since the "high-order end" of any object or field
20239 is different on big-endian and little-endian machines, the computation
20240 below must take account of these differences. */
20241 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
20242 highest_order_field_bit_offset
= bitpos_int
;
20244 if (! BYTES_BIG_ENDIAN
)
20246 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
20247 highest_order_object_bit_offset
+=
20248 simple_type_size_in_bits (original_type
);
20252 = (! BYTES_BIG_ENDIAN
20253 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
20254 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
20256 if (bit_offset
< 0)
20257 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
20259 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
20262 /* For a FIELD_DECL node which represents a bit field, output an attribute
20263 which specifies the length in bits of the given field. */
20266 add_bit_size_attribute (dw_die_ref die
, tree decl
)
20268 /* Must be a field and a bit field. */
20269 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
20270 && DECL_BIT_FIELD_TYPE (decl
));
20272 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
20273 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
20276 /* If the compiled language is ANSI C, then add a 'prototyped'
20277 attribute, if arg types are given for the parameters of a function. */
20280 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
20282 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
20289 if (prototype_p (func_type
))
20290 add_AT_flag (die
, DW_AT_prototyped
, 1);
20297 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
20298 by looking in the type declaration, the object declaration equate table or
20299 the block mapping. */
20301 static inline dw_die_ref
20302 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
20304 dw_die_ref origin_die
= NULL
;
20306 if (DECL_P (origin
))
20309 origin_die
= lookup_decl_die (origin
);
20310 /* "Unwrap" the decls DIE which we put in the imported unit context.
20311 We are looking for the abstract copy here. */
20314 && (c
= get_AT_ref (origin_die
, DW_AT_abstract_origin
))
20315 /* ??? Identify this better. */
20319 else if (TYPE_P (origin
))
20320 origin_die
= lookup_type_die (origin
);
20321 else if (TREE_CODE (origin
) == BLOCK
)
20322 origin_die
= BLOCK_DIE (origin
);
20324 /* XXX: Functions that are never lowered don't always have correct block
20325 trees (in the case of java, they simply have no block tree, in some other
20326 languages). For these functions, there is nothing we can really do to
20327 output correct debug info for inlined functions in all cases. Rather
20328 than die, we'll just produce deficient debug info now, in that we will
20329 have variables without a proper abstract origin. In the future, when all
20330 functions are lowered, we should re-add a gcc_assert (origin_die)
20334 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
20338 /* We do not currently support the pure_virtual attribute. */
20341 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
20343 if (DECL_VINDEX (func_decl
))
20345 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
20347 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
20348 add_AT_loc (die
, DW_AT_vtable_elem_location
,
20349 new_loc_descr (DW_OP_constu
,
20350 tree_to_shwi (DECL_VINDEX (func_decl
)),
20353 /* GNU extension: Record what type this method came from originally. */
20354 if (debug_info_level
> DINFO_LEVEL_TERSE
20355 && DECL_CONTEXT (func_decl
))
20356 add_AT_die_ref (die
, DW_AT_containing_type
,
20357 lookup_type_die (DECL_CONTEXT (func_decl
)));
20361 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
20362 given decl. This used to be a vendor extension until after DWARF 4
20363 standardized it. */
20366 add_linkage_attr (dw_die_ref die
, tree decl
)
20368 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
20370 /* Mimic what assemble_name_raw does with a leading '*'. */
20371 if (name
[0] == '*')
20374 if (dwarf_version
>= 4)
20375 add_AT_string (die
, DW_AT_linkage_name
, name
);
20377 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
20380 /* Add source coordinate attributes for the given decl. */
20383 add_src_coords_attributes (dw_die_ref die
, tree decl
)
20385 expanded_location s
;
20387 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
20389 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
20390 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
20391 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
20392 if (debug_column_info
&& s
.column
)
20393 add_AT_unsigned (die
, DW_AT_decl_column
, s
.column
);
20396 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
20399 add_linkage_name_raw (dw_die_ref die
, tree decl
)
20401 /* Defer until we have an assembler name set. */
20402 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
20404 limbo_die_node
*asm_name
;
20406 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
20407 asm_name
->die
= die
;
20408 asm_name
->created_for
= decl
;
20409 asm_name
->next
= deferred_asm_name
;
20410 deferred_asm_name
= asm_name
;
20412 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
20413 add_linkage_attr (die
, decl
);
20416 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
20419 add_linkage_name (dw_die_ref die
, tree decl
)
20421 if (debug_info_level
> DINFO_LEVEL_NONE
20422 && VAR_OR_FUNCTION_DECL_P (decl
)
20423 && TREE_PUBLIC (decl
)
20424 && !(VAR_P (decl
) && DECL_REGISTER (decl
))
20425 && die
->die_tag
!= DW_TAG_member
)
20426 add_linkage_name_raw (die
, decl
);
20429 /* Add a DW_AT_name attribute and source coordinate attribute for the
20430 given decl, but only if it actually has a name. */
20433 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
,
20434 bool no_linkage_name
)
20438 decl_name
= DECL_NAME (decl
);
20439 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
20441 const char *name
= dwarf2_name (decl
, 0);
20443 add_name_attribute (die
, name
);
20444 if (! DECL_ARTIFICIAL (decl
))
20445 add_src_coords_attributes (die
, decl
);
20447 if (!no_linkage_name
)
20448 add_linkage_name (die
, decl
);
20451 #ifdef VMS_DEBUGGING_INFO
20452 /* Get the function's name, as described by its RTL. This may be different
20453 from the DECL_NAME name used in the source file. */
20454 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
20456 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
20457 XEXP (DECL_RTL (decl
), 0), false);
20458 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
20460 #endif /* VMS_DEBUGGING_INFO */
20463 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
20466 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
20470 attr
.dw_attr
= DW_AT_discr_value
;
20471 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
20472 attr
.dw_attr_val
.val_entry
= NULL
;
20473 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
20475 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
20477 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
20478 add_dwarf_attr (die
, &attr
);
20481 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
20484 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
20488 attr
.dw_attr
= DW_AT_discr_list
;
20489 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
20490 attr
.dw_attr_val
.val_entry
= NULL
;
20491 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
20492 add_dwarf_attr (die
, &attr
);
20495 static inline dw_discr_list_ref
20496 AT_discr_list (dw_attr_node
*attr
)
20498 return attr
->dw_attr_val
.v
.val_discr_list
;
20501 #ifdef VMS_DEBUGGING_INFO
20502 /* Output the debug main pointer die for VMS */
20505 dwarf2out_vms_debug_main_pointer (void)
20507 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
20510 /* Allocate the VMS debug main subprogram die. */
20511 die
= ggc_cleared_alloc
<die_node
> ();
20512 die
->die_tag
= DW_TAG_subprogram
;
20513 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
20514 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
20515 current_function_funcdef_no
);
20516 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
20518 /* Make it the first child of comp_unit_die (). */
20519 die
->die_parent
= comp_unit_die ();
20520 if (comp_unit_die ()->die_child
)
20522 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
20523 comp_unit_die ()->die_child
->die_sib
= die
;
20527 die
->die_sib
= die
;
20528 comp_unit_die ()->die_child
= die
;
20531 #endif /* VMS_DEBUGGING_INFO */
20533 /* Push a new declaration scope. */
20536 push_decl_scope (tree scope
)
20538 vec_safe_push (decl_scope_table
, scope
);
20541 /* Pop a declaration scope. */
20544 pop_decl_scope (void)
20546 decl_scope_table
->pop ();
20549 /* walk_tree helper function for uses_local_type, below. */
20552 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
20555 *walk_subtrees
= 0;
20558 tree name
= TYPE_NAME (*tp
);
20559 if (name
&& DECL_P (name
) && decl_function_context (name
))
20565 /* If TYPE involves a function-local type (including a local typedef to a
20566 non-local type), returns that type; otherwise returns NULL_TREE. */
20569 uses_local_type (tree type
)
20571 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
20575 /* Return the DIE for the scope that immediately contains this type.
20576 Non-named types that do not involve a function-local type get global
20577 scope. Named types nested in namespaces or other types get their
20578 containing scope. All other types (i.e. function-local named types) get
20579 the current active scope. */
20582 scope_die_for (tree t
, dw_die_ref context_die
)
20584 dw_die_ref scope_die
= NULL
;
20585 tree containing_scope
;
20587 /* Non-types always go in the current scope. */
20588 gcc_assert (TYPE_P (t
));
20590 /* Use the scope of the typedef, rather than the scope of the type
20592 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
20593 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
20595 containing_scope
= TYPE_CONTEXT (t
);
20597 /* Use the containing namespace if there is one. */
20598 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
20600 if (context_die
== lookup_decl_die (containing_scope
))
20602 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
20603 context_die
= get_context_die (containing_scope
);
20605 containing_scope
= NULL_TREE
;
20608 /* Ignore function type "scopes" from the C frontend. They mean that
20609 a tagged type is local to a parmlist of a function declarator, but
20610 that isn't useful to DWARF. */
20611 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
20612 containing_scope
= NULL_TREE
;
20614 if (SCOPE_FILE_SCOPE_P (containing_scope
))
20616 /* If T uses a local type keep it local as well, to avoid references
20617 to function-local DIEs from outside the function. */
20618 if (current_function_decl
&& uses_local_type (t
))
20619 scope_die
= context_die
;
20621 scope_die
= comp_unit_die ();
20623 else if (TYPE_P (containing_scope
))
20625 /* For types, we can just look up the appropriate DIE. */
20626 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20627 scope_die
= get_context_die (containing_scope
);
20630 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
20631 if (scope_die
== NULL
)
20632 scope_die
= comp_unit_die ();
20636 scope_die
= context_die
;
20641 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
20644 local_scope_p (dw_die_ref context_die
)
20646 for (; context_die
; context_die
= context_die
->die_parent
)
20647 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
20648 || context_die
->die_tag
== DW_TAG_subprogram
)
20654 /* Returns nonzero if CONTEXT_DIE is a class. */
20657 class_scope_p (dw_die_ref context_die
)
20659 return (context_die
20660 && (context_die
->die_tag
== DW_TAG_structure_type
20661 || context_die
->die_tag
== DW_TAG_class_type
20662 || context_die
->die_tag
== DW_TAG_interface_type
20663 || context_die
->die_tag
== DW_TAG_union_type
));
20666 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
20667 whether or not to treat a DIE in this context as a declaration. */
20670 class_or_namespace_scope_p (dw_die_ref context_die
)
20672 return (class_scope_p (context_die
)
20673 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
20676 /* Many forms of DIEs require a "type description" attribute. This
20677 routine locates the proper "type descriptor" die for the type given
20678 by 'type' plus any additional qualifiers given by 'cv_quals', and
20679 adds a DW_AT_type attribute below the given die. */
20682 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
20683 bool reverse
, dw_die_ref context_die
)
20685 enum tree_code code
= TREE_CODE (type
);
20686 dw_die_ref type_die
= NULL
;
20688 /* ??? If this type is an unnamed subrange type of an integral, floating-point
20689 or fixed-point type, use the inner type. This is because we have no
20690 support for unnamed types in base_type_die. This can happen if this is
20691 an Ada subrange type. Correct solution is emit a subrange type die. */
20692 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
20693 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
20694 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
20696 if (code
== ERROR_MARK
20697 /* Handle a special case. For functions whose return type is void, we
20698 generate *no* type attribute. (Note that no object may have type
20699 `void', so this only applies to function return types). */
20700 || code
== VOID_TYPE
)
20703 type_die
= modified_type_die (type
,
20704 cv_quals
| TYPE_QUALS_NO_ADDR_SPACE (type
),
20708 if (type_die
!= NULL
)
20709 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
20712 /* Given an object die, add the calling convention attribute for the
20713 function call type. */
20715 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
20717 enum dwarf_calling_convention value
= DW_CC_normal
;
20719 value
= ((enum dwarf_calling_convention
)
20720 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
20723 && id_equal (DECL_ASSEMBLER_NAME (decl
), "MAIN__"))
20725 /* DWARF 2 doesn't provide a way to identify a program's source-level
20726 entry point. DW_AT_calling_convention attributes are only meant
20727 to describe functions' calling conventions. However, lacking a
20728 better way to signal the Fortran main program, we used this for
20729 a long time, following existing custom. Now, DWARF 4 has
20730 DW_AT_main_subprogram, which we add below, but some tools still
20731 rely on the old way, which we thus keep. */
20732 value
= DW_CC_program
;
20734 if (dwarf_version
>= 4 || !dwarf_strict
)
20735 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
20738 /* Only add the attribute if the backend requests it, and
20739 is not DW_CC_normal. */
20740 if (value
&& (value
!= DW_CC_normal
))
20741 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
20744 /* Given a tree pointer to a struct, class, union, or enum type node, return
20745 a pointer to the (string) tag name for the given type, or zero if the type
20746 was declared without a tag. */
20748 static const char *
20749 type_tag (const_tree type
)
20751 const char *name
= 0;
20753 if (TYPE_NAME (type
) != 0)
20757 /* Find the IDENTIFIER_NODE for the type name. */
20758 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
20759 && !TYPE_NAMELESS (type
))
20760 t
= TYPE_NAME (type
);
20762 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
20763 a TYPE_DECL node, regardless of whether or not a `typedef' was
20765 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
20766 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
20768 /* We want to be extra verbose. Don't call dwarf_name if
20769 DECL_NAME isn't set. The default hook for decl_printable_name
20770 doesn't like that, and in this context it's correct to return
20771 0, instead of "<anonymous>" or the like. */
20772 if (DECL_NAME (TYPE_NAME (type
))
20773 && !DECL_NAMELESS (TYPE_NAME (type
)))
20774 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
20777 /* Now get the name as a string, or invent one. */
20778 if (!name
&& t
!= 0)
20779 name
= IDENTIFIER_POINTER (t
);
20782 return (name
== 0 || *name
== '\0') ? 0 : name
;
20785 /* Return the type associated with a data member, make a special check
20786 for bit field types. */
20789 member_declared_type (const_tree member
)
20791 return (DECL_BIT_FIELD_TYPE (member
)
20792 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
20795 /* Get the decl's label, as described by its RTL. This may be different
20796 from the DECL_NAME name used in the source file. */
20799 static const char *
20800 decl_start_label (tree decl
)
20803 const char *fnname
;
20805 x
= DECL_RTL (decl
);
20806 gcc_assert (MEM_P (x
));
20809 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
20811 fnname
= XSTR (x
, 0);
20816 /* For variable-length arrays that have been previously generated, but
20817 may be incomplete due to missing subscript info, fill the subscript
20818 info. Return TRUE if this is one of those cases. */
20820 fill_variable_array_bounds (tree type
)
20822 if (TREE_ASM_WRITTEN (type
)
20823 && TREE_CODE (type
) == ARRAY_TYPE
20824 && variably_modified_type_p (type
, NULL
))
20826 dw_die_ref array_die
= lookup_type_die (type
);
20829 add_subscript_info (array_die
, type
, !is_ada ());
20835 /* These routines generate the internal representation of the DIE's for
20836 the compilation unit. Debugging information is collected by walking
20837 the declaration trees passed in from dwarf2out_decl(). */
20840 gen_array_type_die (tree type
, dw_die_ref context_die
)
20842 dw_die_ref array_die
;
20844 /* GNU compilers represent multidimensional array types as sequences of one
20845 dimensional array types whose element types are themselves array types.
20846 We sometimes squish that down to a single array_type DIE with multiple
20847 subscripts in the Dwarf debugging info. The draft Dwarf specification
20848 say that we are allowed to do this kind of compression in C, because
20849 there is no difference between an array of arrays and a multidimensional
20850 array. We don't do this for Ada to remain as close as possible to the
20851 actual representation, which is especially important against the language
20852 flexibilty wrt arrays of variable size. */
20854 bool collapse_nested_arrays
= !is_ada ();
20856 if (fill_variable_array_bounds (type
))
20859 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
20862 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
20863 DW_TAG_string_type doesn't have DW_AT_type attribute). */
20864 if (TYPE_STRING_FLAG (type
)
20865 && TREE_CODE (type
) == ARRAY_TYPE
20867 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
20869 HOST_WIDE_INT size
;
20871 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
20872 add_name_attribute (array_die
, type_tag (type
));
20873 equate_type_number_to_die (type
, array_die
);
20874 size
= int_size_in_bytes (type
);
20876 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
20877 /* ??? We can't annotate types late, but for LTO we may not
20878 generate a location early either (gfortran.dg/save_6.f90). */
20879 else if (! (early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
20880 && TYPE_DOMAIN (type
) != NULL_TREE
20881 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
)
20883 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
20884 tree rszdecl
= szdecl
;
20886 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
20887 if (!DECL_P (szdecl
))
20889 if (TREE_CODE (szdecl
) == INDIRECT_REF
20890 && DECL_P (TREE_OPERAND (szdecl
, 0)))
20892 rszdecl
= TREE_OPERAND (szdecl
, 0);
20893 if (int_size_in_bytes (TREE_TYPE (rszdecl
))
20894 != DWARF2_ADDR_SIZE
)
20902 dw_loc_list_ref loc
20903 = loc_list_from_tree (rszdecl
, szdecl
== rszdecl
? 2 : 0,
20907 add_AT_location_description (array_die
, DW_AT_string_length
,
20909 if (size
!= DWARF2_ADDR_SIZE
)
20910 add_AT_unsigned (array_die
, dwarf_version
>= 5
20911 ? DW_AT_string_length_byte_size
20912 : DW_AT_byte_size
, size
);
20919 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
20920 add_name_attribute (array_die
, type_tag (type
));
20921 equate_type_number_to_die (type
, array_die
);
20923 if (TREE_CODE (type
) == VECTOR_TYPE
)
20924 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
20926 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
20928 && TREE_CODE (type
) == ARRAY_TYPE
20929 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
20930 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
20931 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
20934 /* We default the array ordering. SDB will probably do
20935 the right things even if DW_AT_ordering is not present. It's not even
20936 an issue until we start to get into multidimensional arrays anyway. If
20937 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
20938 then we'll have to put the DW_AT_ordering attribute back in. (But if
20939 and when we find out that we need to put these in, we will only do so
20940 for multidimensional arrays. */
20941 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
20944 if (TREE_CODE (type
) == VECTOR_TYPE
)
20946 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
20947 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
20948 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
, NULL
);
20949 add_bound_info (subrange_die
, DW_AT_upper_bound
,
20950 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
20953 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
20955 /* Add representation of the type of the elements of this array type and
20956 emit the corresponding DIE if we haven't done it already. */
20957 element_type
= TREE_TYPE (type
);
20958 if (collapse_nested_arrays
)
20959 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
20961 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
20963 element_type
= TREE_TYPE (element_type
);
20966 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
20967 TREE_CODE (type
) == ARRAY_TYPE
20968 && TYPE_REVERSE_STORAGE_ORDER (type
),
20971 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
20972 if (TYPE_ARTIFICIAL (type
))
20973 add_AT_flag (array_die
, DW_AT_artificial
, 1);
20975 if (get_AT (array_die
, DW_AT_name
))
20976 add_pubtype (type
, array_die
);
20978 add_alignment_attribute (array_die
, type
);
20981 /* This routine generates DIE for array with hidden descriptor, details
20982 are filled into *info by a langhook. */
20985 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
20986 dw_die_ref context_die
)
20988 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
20989 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
20990 struct loc_descr_context context
= { type
, info
->base_decl
, NULL
,
20992 enum dwarf_tag subrange_tag
= DW_TAG_subrange_type
;
20995 add_name_attribute (array_die
, type_tag (type
));
20996 equate_type_number_to_die (type
, array_die
);
20998 if (info
->ndimensions
> 1)
20999 switch (info
->ordering
)
21001 case array_descr_ordering_row_major
:
21002 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21004 case array_descr_ordering_column_major
:
21005 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21011 if (dwarf_version
>= 3 || !dwarf_strict
)
21013 if (info
->data_location
)
21014 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
21015 dw_scalar_form_exprloc
, &context
);
21016 if (info
->associated
)
21017 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
21018 dw_scalar_form_constant
21019 | dw_scalar_form_exprloc
21020 | dw_scalar_form_reference
, &context
);
21021 if (info
->allocated
)
21022 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
21023 dw_scalar_form_constant
21024 | dw_scalar_form_exprloc
21025 | dw_scalar_form_reference
, &context
);
21028 const enum dwarf_attribute attr
21029 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
21031 = (info
->stride_in_bits
)
21032 ? dw_scalar_form_constant
21033 : (dw_scalar_form_constant
21034 | dw_scalar_form_exprloc
21035 | dw_scalar_form_reference
);
21037 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
21040 if (dwarf_version
>= 5)
21044 add_scalar_info (array_die
, DW_AT_rank
, info
->rank
,
21045 dw_scalar_form_constant
21046 | dw_scalar_form_exprloc
, &context
);
21047 subrange_tag
= DW_TAG_generic_subrange
;
21048 context
.placeholder_arg
= true;
21052 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21054 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
21056 dw_die_ref subrange_die
= new_die (subrange_tag
, array_die
, NULL
);
21058 if (info
->dimen
[dim
].bounds_type
)
21059 add_type_attribute (subrange_die
,
21060 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
21061 false, context_die
);
21062 if (info
->dimen
[dim
].lower_bound
)
21063 add_bound_info (subrange_die
, DW_AT_lower_bound
,
21064 info
->dimen
[dim
].lower_bound
, &context
);
21065 if (info
->dimen
[dim
].upper_bound
)
21066 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21067 info
->dimen
[dim
].upper_bound
, &context
);
21068 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
21069 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
21070 info
->dimen
[dim
].stride
,
21071 dw_scalar_form_constant
21072 | dw_scalar_form_exprloc
21073 | dw_scalar_form_reference
,
21077 gen_type_die (info
->element_type
, context_die
);
21078 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
21079 TREE_CODE (type
) == ARRAY_TYPE
21080 && TYPE_REVERSE_STORAGE_ORDER (type
),
21083 if (get_AT (array_die
, DW_AT_name
))
21084 add_pubtype (type
, array_die
);
21086 add_alignment_attribute (array_die
, type
);
21091 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
21093 tree origin
= decl_ultimate_origin (decl
);
21094 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
21096 if (origin
!= NULL
)
21097 add_abstract_origin_attribute (decl_die
, origin
);
21100 add_name_and_src_coords_attributes (decl_die
, decl
);
21101 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
21102 TYPE_UNQUALIFIED
, false, context_die
);
21105 if (DECL_ABSTRACT_P (decl
))
21106 equate_decl_number_to_die (decl
, decl_die
);
21108 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
21112 /* Walk through the list of incomplete types again, trying once more to
21113 emit full debugging info for them. */
21116 retry_incomplete_types (void)
21121 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
21122 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
21123 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
21124 vec_safe_truncate (incomplete_types
, 0);
21127 /* Determine what tag to use for a record type. */
21129 static enum dwarf_tag
21130 record_type_tag (tree type
)
21132 if (! lang_hooks
.types
.classify_record
)
21133 return DW_TAG_structure_type
;
21135 switch (lang_hooks
.types
.classify_record (type
))
21137 case RECORD_IS_STRUCT
:
21138 return DW_TAG_structure_type
;
21140 case RECORD_IS_CLASS
:
21141 return DW_TAG_class_type
;
21143 case RECORD_IS_INTERFACE
:
21144 if (dwarf_version
>= 3 || !dwarf_strict
)
21145 return DW_TAG_interface_type
;
21146 return DW_TAG_structure_type
;
21149 gcc_unreachable ();
21153 /* Generate a DIE to represent an enumeration type. Note that these DIEs
21154 include all of the information about the enumeration values also. Each
21155 enumerated type name/value is listed as a child of the enumerated type
21159 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
21161 dw_die_ref type_die
= lookup_type_die (type
);
21163 if (type_die
== NULL
)
21165 type_die
= new_die (DW_TAG_enumeration_type
,
21166 scope_die_for (type
, context_die
), type
);
21167 equate_type_number_to_die (type
, type_die
);
21168 add_name_attribute (type_die
, type_tag (type
));
21169 if (dwarf_version
>= 4 || !dwarf_strict
)
21171 if (ENUM_IS_SCOPED (type
))
21172 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
21173 if (ENUM_IS_OPAQUE (type
))
21174 add_AT_flag (type_die
, DW_AT_declaration
, 1);
21177 add_AT_unsigned (type_die
, DW_AT_encoding
,
21178 TYPE_UNSIGNED (type
)
21182 else if (! TYPE_SIZE (type
))
21185 remove_AT (type_die
, DW_AT_declaration
);
21187 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
21188 given enum type is incomplete, do not generate the DW_AT_byte_size
21189 attribute or the DW_AT_element_list attribute. */
21190 if (TYPE_SIZE (type
))
21194 TREE_ASM_WRITTEN (type
) = 1;
21195 add_byte_size_attribute (type_die
, type
);
21196 add_alignment_attribute (type_die
, type
);
21197 if (dwarf_version
>= 3 || !dwarf_strict
)
21199 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
21200 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
21203 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
21205 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
21206 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
21209 /* If the first reference to this type was as the return type of an
21210 inline function, then it may not have a parent. Fix this now. */
21211 if (type_die
->die_parent
== NULL
)
21212 add_child_die (scope_die_for (type
, context_die
), type_die
);
21214 for (link
= TYPE_VALUES (type
);
21215 link
!= NULL
; link
= TREE_CHAIN (link
))
21217 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
21218 tree value
= TREE_VALUE (link
);
21220 add_name_attribute (enum_die
,
21221 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
21223 if (TREE_CODE (value
) == CONST_DECL
)
21224 value
= DECL_INITIAL (value
);
21226 if (simple_type_size_in_bits (TREE_TYPE (value
))
21227 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
21229 /* For constant forms created by add_AT_unsigned DWARF
21230 consumers (GDB, elfutils, etc.) always zero extend
21231 the value. Only when the actual value is negative
21232 do we need to use add_AT_int to generate a constant
21233 form that can represent negative values. */
21234 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
21235 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
21236 add_AT_unsigned (enum_die
, DW_AT_const_value
,
21237 (unsigned HOST_WIDE_INT
) val
);
21239 add_AT_int (enum_die
, DW_AT_const_value
, val
);
21242 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
21243 that here. TODO: This should be re-worked to use correct
21244 signed/unsigned double tags for all cases. */
21245 add_AT_wide (enum_die
, DW_AT_const_value
, value
);
21248 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
21249 if (TYPE_ARTIFICIAL (type
))
21250 add_AT_flag (type_die
, DW_AT_artificial
, 1);
21253 add_AT_flag (type_die
, DW_AT_declaration
, 1);
21255 add_alignment_attribute (type_die
, type
);
21257 add_pubtype (type
, type_die
);
21262 /* Generate a DIE to represent either a real live formal parameter decl or to
21263 represent just the type of some formal parameter position in some function
21266 Note that this routine is a bit unusual because its argument may be a
21267 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
21268 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
21269 node. If it's the former then this function is being called to output a
21270 DIE to represent a formal parameter object (or some inlining thereof). If
21271 it's the latter, then this function is only being called to output a
21272 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
21273 argument type of some subprogram type.
21274 If EMIT_NAME_P is true, name and source coordinate attributes
21278 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
21279 dw_die_ref context_die
)
21281 tree node_or_origin
= node
? node
: origin
;
21282 tree ultimate_origin
;
21283 dw_die_ref parm_die
= NULL
;
21285 if (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)) == tcc_declaration
)
21287 parm_die
= lookup_decl_die (node
);
21289 /* If the contexts differ, we may not be talking about the same
21291 ??? When in LTO the DIE parent is the "abstract" copy and the
21292 context_die is the specification "copy". But this whole block
21293 should eventually be no longer needed. */
21294 if (parm_die
&& parm_die
->die_parent
!= context_die
&& !in_lto_p
)
21296 if (!DECL_ABSTRACT_P (node
))
21298 /* This can happen when creating an inlined instance, in
21299 which case we need to create a new DIE that will get
21300 annotated with DW_AT_abstract_origin. */
21304 gcc_unreachable ();
21307 if (parm_die
&& parm_die
->die_parent
== NULL
)
21309 /* Check that parm_die already has the right attributes that
21310 we would have added below. If any attributes are
21311 missing, fall through to add them. */
21312 if (! DECL_ABSTRACT_P (node_or_origin
)
21313 && !get_AT (parm_die
, DW_AT_location
)
21314 && !get_AT (parm_die
, DW_AT_const_value
))
21315 /* We are missing location info, and are about to add it. */
21319 add_child_die (context_die
, parm_die
);
21325 /* If we have a previously generated DIE, use it, unless this is an
21326 concrete instance (origin != NULL), in which case we need a new
21327 DIE with a corresponding DW_AT_abstract_origin. */
21329 if (parm_die
&& origin
== NULL
)
21330 reusing_die
= true;
21333 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
21334 reusing_die
= false;
21337 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
21339 case tcc_declaration
:
21340 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
21341 if (node
|| ultimate_origin
)
21342 origin
= ultimate_origin
;
21347 if (origin
!= NULL
)
21348 add_abstract_origin_attribute (parm_die
, origin
);
21349 else if (emit_name_p
)
21350 add_name_and_src_coords_attributes (parm_die
, node
);
21352 || (! DECL_ABSTRACT_P (node_or_origin
)
21353 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
21354 decl_function_context
21355 (node_or_origin
))))
21357 tree type
= TREE_TYPE (node_or_origin
);
21358 if (decl_by_reference_p (node_or_origin
))
21359 add_type_attribute (parm_die
, TREE_TYPE (type
),
21361 false, context_die
);
21363 add_type_attribute (parm_die
, type
,
21364 decl_quals (node_or_origin
),
21365 false, context_die
);
21367 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
21368 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
21370 if (node
&& node
!= origin
)
21371 equate_decl_number_to_die (node
, parm_die
);
21372 if (! DECL_ABSTRACT_P (node_or_origin
))
21373 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
21379 /* We were called with some kind of a ..._TYPE node. */
21380 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
21385 gcc_unreachable ();
21391 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
21392 children DW_TAG_formal_parameter DIEs representing the arguments of the
21395 PARM_PACK must be a function parameter pack.
21396 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
21397 must point to the subsequent arguments of the function PACK_ARG belongs to.
21398 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
21399 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
21400 following the last one for which a DIE was generated. */
21403 gen_formal_parameter_pack_die (tree parm_pack
,
21405 dw_die_ref subr_die
,
21409 dw_die_ref parm_pack_die
;
21411 gcc_assert (parm_pack
21412 && lang_hooks
.function_parameter_pack_p (parm_pack
)
21415 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
21416 add_src_coords_attributes (parm_pack_die
, parm_pack
);
21418 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
21420 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
21423 gen_formal_parameter_die (arg
, NULL
,
21424 false /* Don't emit name attribute. */,
21429 return parm_pack_die
;
21432 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
21433 at the end of an (ANSI prototyped) formal parameters list. */
21436 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
21438 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
21441 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
21442 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
21443 parameters as specified in some function type specification (except for
21444 those which appear as part of a function *definition*). */
21447 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
21450 tree formal_type
= NULL
;
21451 tree first_parm_type
;
21454 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
21456 arg
= DECL_ARGUMENTS (function_or_method_type
);
21457 function_or_method_type
= TREE_TYPE (function_or_method_type
);
21462 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
21464 /* Make our first pass over the list of formal parameter types and output a
21465 DW_TAG_formal_parameter DIE for each one. */
21466 for (link
= first_parm_type
; link
; )
21468 dw_die_ref parm_die
;
21470 formal_type
= TREE_VALUE (link
);
21471 if (formal_type
== void_type_node
)
21474 /* Output a (nameless) DIE to represent the formal parameter itself. */
21475 if (!POINTER_BOUNDS_TYPE_P (formal_type
))
21477 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
21478 true /* Emit name attribute. */,
21480 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
21481 && link
== first_parm_type
)
21483 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
21484 if (dwarf_version
>= 3 || !dwarf_strict
)
21485 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
21487 else if (arg
&& DECL_ARTIFICIAL (arg
))
21488 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
21491 link
= TREE_CHAIN (link
);
21493 arg
= DECL_CHAIN (arg
);
21496 /* If this function type has an ellipsis, add a
21497 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
21498 if (formal_type
!= void_type_node
)
21499 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
21501 /* Make our second (and final) pass over the list of formal parameter types
21502 and output DIEs to represent those types (as necessary). */
21503 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
21504 link
&& TREE_VALUE (link
);
21505 link
= TREE_CHAIN (link
))
21506 gen_type_die (TREE_VALUE (link
), context_die
);
21509 /* We want to generate the DIE for TYPE so that we can generate the
21510 die for MEMBER, which has been defined; we will need to refer back
21511 to the member declaration nested within TYPE. If we're trying to
21512 generate minimal debug info for TYPE, processing TYPE won't do the
21513 trick; we need to attach the member declaration by hand. */
21516 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
21518 gen_type_die (type
, context_die
);
21520 /* If we're trying to avoid duplicate debug info, we may not have
21521 emitted the member decl for this function. Emit it now. */
21522 if (TYPE_STUB_DECL (type
)
21523 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
21524 && ! lookup_decl_die (member
))
21526 dw_die_ref type_die
;
21527 gcc_assert (!decl_ultimate_origin (member
));
21529 push_decl_scope (type
);
21530 type_die
= lookup_type_die_strip_naming_typedef (type
);
21531 if (TREE_CODE (member
) == FUNCTION_DECL
)
21532 gen_subprogram_die (member
, type_die
);
21533 else if (TREE_CODE (member
) == FIELD_DECL
)
21535 /* Ignore the nameless fields that are used to skip bits but handle
21536 C++ anonymous unions and structs. */
21537 if (DECL_NAME (member
) != NULL_TREE
21538 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
21539 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
21541 struct vlr_context vlr_ctx
= {
21542 DECL_CONTEXT (member
), /* struct_type */
21543 NULL_TREE
/* variant_part_offset */
21545 gen_type_die (member_declared_type (member
), type_die
);
21546 gen_field_die (member
, &vlr_ctx
, type_die
);
21550 gen_variable_die (member
, NULL_TREE
, type_die
);
21556 /* Forward declare these functions, because they are mutually recursive
21557 with their set_block_* pairing functions. */
21558 static void set_decl_origin_self (tree
);
21560 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
21561 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
21562 that it points to the node itself, thus indicating that the node is its
21563 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
21564 the given node is NULL, recursively descend the decl/block tree which
21565 it is the root of, and for each other ..._DECL or BLOCK node contained
21566 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
21567 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
21568 values to point to themselves. */
21571 set_block_origin_self (tree stmt
)
21573 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
21575 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
21580 for (local_decl
= BLOCK_VARS (stmt
);
21581 local_decl
!= NULL_TREE
;
21582 local_decl
= DECL_CHAIN (local_decl
))
21583 /* Do not recurse on nested functions since the inlining status
21584 of parent and child can be different as per the DWARF spec. */
21585 if (TREE_CODE (local_decl
) != FUNCTION_DECL
21586 && !DECL_EXTERNAL (local_decl
))
21587 set_decl_origin_self (local_decl
);
21593 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
21594 subblock
!= NULL_TREE
;
21595 subblock
= BLOCK_CHAIN (subblock
))
21596 set_block_origin_self (subblock
); /* Recurse. */
21601 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
21602 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
21603 node to so that it points to the node itself, thus indicating that the
21604 node represents its own (abstract) origin. Additionally, if the
21605 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
21606 the decl/block tree of which the given node is the root of, and for
21607 each other ..._DECL or BLOCK node contained therein whose
21608 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
21609 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
21610 point to themselves. */
21613 set_decl_origin_self (tree decl
)
21615 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
21617 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
21618 if (TREE_CODE (decl
) == FUNCTION_DECL
)
21622 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
21623 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
21624 if (DECL_INITIAL (decl
) != NULL_TREE
21625 && DECL_INITIAL (decl
) != error_mark_node
)
21626 set_block_origin_self (DECL_INITIAL (decl
));
21631 /* Mark the early DIE for DECL as the abstract instance. */
21634 dwarf2out_abstract_function (tree decl
)
21636 dw_die_ref old_die
;
21638 /* Make sure we have the actual abstract inline, not a clone. */
21639 decl
= DECL_ORIGIN (decl
);
21641 if (DECL_IGNORED_P (decl
))
21644 old_die
= lookup_decl_die (decl
);
21645 /* With early debug we always have an old DIE unless we are in LTO
21646 and the user did not compile but only link with debug. */
21647 if (in_lto_p
&& ! old_die
)
21649 gcc_assert (old_die
!= NULL
);
21650 if (get_AT (old_die
, DW_AT_inline
)
21651 || get_AT (old_die
, DW_AT_abstract_origin
))
21652 /* We've already generated the abstract instance. */
21655 /* Go ahead and put DW_AT_inline on the DIE. */
21656 if (DECL_DECLARED_INLINE_P (decl
))
21658 if (cgraph_function_possibly_inlined_p (decl
))
21659 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_inlined
);
21661 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
21665 if (cgraph_function_possibly_inlined_p (decl
))
21666 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_inlined
);
21668 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_not_inlined
);
21671 if (DECL_DECLARED_INLINE_P (decl
)
21672 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
21673 add_AT_flag (old_die
, DW_AT_artificial
, 1);
21675 set_decl_origin_self (decl
);
21678 /* Helper function of premark_used_types() which gets called through
21681 Marks the DIE of a given type in *SLOT as perennial, so it never gets
21682 marked as unused by prune_unused_types. */
21685 premark_used_types_helper (tree
const &type
, void *)
21689 die
= lookup_type_die (type
);
21691 die
->die_perennial_p
= 1;
21695 /* Helper function of premark_types_used_by_global_vars which gets called
21696 through htab_traverse.
21698 Marks the DIE of a given type in *SLOT as perennial, so it never gets
21699 marked as unused by prune_unused_types. The DIE of the type is marked
21700 only if the global variable using the type will actually be emitted. */
21703 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
21706 struct types_used_by_vars_entry
*entry
;
21709 entry
= (struct types_used_by_vars_entry
*) *slot
;
21710 gcc_assert (entry
->type
!= NULL
21711 && entry
->var_decl
!= NULL
);
21712 die
= lookup_type_die (entry
->type
);
21715 /* Ask cgraph if the global variable really is to be emitted.
21716 If yes, then we'll keep the DIE of ENTRY->TYPE. */
21717 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
21718 if (node
&& node
->definition
)
21720 die
->die_perennial_p
= 1;
21721 /* Keep the parent DIEs as well. */
21722 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
21723 die
->die_perennial_p
= 1;
21729 /* Mark all members of used_types_hash as perennial. */
21732 premark_used_types (struct function
*fun
)
21734 if (fun
&& fun
->used_types_hash
)
21735 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
21738 /* Mark all members of types_used_by_vars_entry as perennial. */
21741 premark_types_used_by_global_vars (void)
21743 if (types_used_by_vars_hash
)
21744 types_used_by_vars_hash
21745 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
21748 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
21749 for CA_LOC call arg loc node. */
21752 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
21753 struct call_arg_loc_node
*ca_loc
)
21755 dw_die_ref stmt_die
= NULL
, die
;
21756 tree block
= ca_loc
->block
;
21759 && block
!= DECL_INITIAL (decl
)
21760 && TREE_CODE (block
) == BLOCK
)
21762 stmt_die
= BLOCK_DIE (block
);
21765 block
= BLOCK_SUPERCONTEXT (block
);
21767 if (stmt_die
== NULL
)
21768 stmt_die
= subr_die
;
21769 die
= new_die (dwarf_TAG (DW_TAG_call_site
), stmt_die
, NULL_TREE
);
21770 add_AT_lbl_id (die
, dwarf_AT (DW_AT_call_return_pc
), ca_loc
->label
);
21771 if (ca_loc
->tail_call_p
)
21772 add_AT_flag (die
, dwarf_AT (DW_AT_call_tail_call
), 1);
21773 if (ca_loc
->symbol_ref
)
21775 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
21777 add_AT_die_ref (die
, dwarf_AT (DW_AT_call_origin
), tdie
);
21779 add_AT_addr (die
, dwarf_AT (DW_AT_call_origin
), ca_loc
->symbol_ref
,
21785 /* Generate a DIE to represent a declared function (either file-scope or
21789 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
21791 tree origin
= decl_ultimate_origin (decl
);
21792 dw_die_ref subr_die
;
21793 dw_die_ref old_die
= lookup_decl_die (decl
);
21795 /* This function gets called multiple times for different stages of
21796 the debug process. For example, for func() in this code:
21800 void func() { ... }
21803 ...we get called 4 times. Twice in early debug and twice in
21809 1. Once while generating func() within the namespace. This is
21810 the declaration. The declaration bit below is set, as the
21811 context is the namespace.
21813 A new DIE will be generated with DW_AT_declaration set.
21815 2. Once for func() itself. This is the specification. The
21816 declaration bit below is clear as the context is the CU.
21818 We will use the cached DIE from (1) to create a new DIE with
21819 DW_AT_specification pointing to the declaration in (1).
21821 Late debug via rest_of_handle_final()
21822 -------------------------------------
21824 3. Once generating func() within the namespace. This is also the
21825 declaration, as in (1), but this time we will early exit below
21826 as we have a cached DIE and a declaration needs no additional
21827 annotations (no locations), as the source declaration line
21830 4. Once for func() itself. As in (2), this is the specification,
21831 but this time we will re-use the cached DIE, and just annotate
21832 it with the location information that should now be available.
21834 For something without namespaces, but with abstract instances, we
21835 are also called a multiple times:
21840 Base (); // constructor declaration (1)
21843 Base::Base () { } // constructor specification (2)
21848 1. Once for the Base() constructor by virtue of it being a
21849 member of the Base class. This is done via
21850 rest_of_type_compilation.
21852 This is a declaration, so a new DIE will be created with
21855 2. Once for the Base() constructor definition, but this time
21856 while generating the abstract instance of the base
21857 constructor (__base_ctor) which is being generated via early
21858 debug of reachable functions.
21860 Even though we have a cached version of the declaration (1),
21861 we will create a DW_AT_specification of the declaration DIE
21864 3. Once for the __base_ctor itself, but this time, we generate
21865 an DW_AT_abstract_origin version of the DW_AT_specification in
21868 Late debug via rest_of_handle_final
21869 -----------------------------------
21871 4. One final time for the __base_ctor (which will have a cached
21872 DIE with DW_AT_abstract_origin created in (3). This time,
21873 we will just annotate the location information now
21876 int declaration
= (current_function_decl
!= decl
21877 || class_or_namespace_scope_p (context_die
));
21879 /* Now that the C++ front end lazily declares artificial member fns, we
21880 might need to retrofit the declaration into its class. */
21881 if (!declaration
&& !origin
&& !old_die
21882 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
21883 && !class_or_namespace_scope_p (context_die
)
21884 && debug_info_level
> DINFO_LEVEL_TERSE
)
21885 old_die
= force_decl_die (decl
);
21887 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
21888 if (origin
!= NULL
)
21890 gcc_assert (!declaration
|| local_scope_p (context_die
));
21892 /* Fixup die_parent for the abstract instance of a nested
21893 inline function. */
21894 if (old_die
&& old_die
->die_parent
== NULL
)
21895 add_child_die (context_die
, old_die
);
21897 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
21899 /* If we have a DW_AT_abstract_origin we have a working
21901 subr_die
= old_die
;
21905 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
21906 add_abstract_origin_attribute (subr_die
, origin
);
21907 /* This is where the actual code for a cloned function is.
21908 Let's emit linkage name attribute for it. This helps
21909 debuggers to e.g, set breakpoints into
21910 constructors/destructors when the user asks "break
21912 add_linkage_name (subr_die
, decl
);
21915 /* A cached copy, possibly from early dwarf generation. Reuse as
21916 much as possible. */
21919 /* A declaration that has been previously dumped needs no
21920 additional information. */
21924 if (!get_AT_flag (old_die
, DW_AT_declaration
)
21925 /* We can have a normal definition following an inline one in the
21926 case of redefinition of GNU C extern inlines.
21927 It seems reasonable to use AT_specification in this case. */
21928 && !get_AT (old_die
, DW_AT_inline
))
21930 /* Detect and ignore this case, where we are trying to output
21931 something we have already output. */
21932 if (get_AT (old_die
, DW_AT_low_pc
)
21933 || get_AT (old_die
, DW_AT_ranges
))
21936 /* If we have no location information, this must be a
21937 partially generated DIE from early dwarf generation.
21938 Fall through and generate it. */
21941 /* If the definition comes from the same place as the declaration,
21942 maybe use the old DIE. We always want the DIE for this function
21943 that has the *_pc attributes to be under comp_unit_die so the
21944 debugger can find it. We also need to do this for abstract
21945 instances of inlines, since the spec requires the out-of-line copy
21946 to have the same parent. For local class methods, this doesn't
21947 apply; we just use the old DIE. */
21948 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
21949 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
21950 if ((is_cu_die (old_die
->die_parent
)
21951 /* This condition fixes the inconsistency/ICE with the
21952 following Fortran test (or some derivative thereof) while
21953 building libgfortran:
21957 logical function funky (FLAG)
21962 || (old_die
->die_parent
21963 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
21964 || context_die
== NULL
)
21965 && (DECL_ARTIFICIAL (decl
)
21966 /* The location attributes may be in the abstract origin
21967 which in the case of LTO might be not available to
21969 || get_AT (old_die
, DW_AT_abstract_origin
)
21970 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
21971 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
21972 == (unsigned) s
.line
)
21973 && (!debug_column_info
21975 || (get_AT_unsigned (old_die
, DW_AT_decl_column
)
21976 == (unsigned) s
.column
)))))
21978 subr_die
= old_die
;
21980 /* Clear out the declaration attribute, but leave the
21981 parameters so they can be augmented with location
21982 information later. Unless this was a declaration, in
21983 which case, wipe out the nameless parameters and recreate
21984 them further down. */
21985 if (remove_AT (subr_die
, DW_AT_declaration
))
21988 remove_AT (subr_die
, DW_AT_object_pointer
);
21989 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
21992 /* Make a specification pointing to the previously built
21996 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
21997 add_AT_specification (subr_die
, old_die
);
21998 add_pubname (decl
, subr_die
);
21999 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
22000 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
22001 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
22002 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
22003 if (debug_column_info
22005 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22006 != (unsigned) s
.column
))
22007 add_AT_unsigned (subr_die
, DW_AT_decl_column
, s
.column
);
22009 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
22010 emit the real type on the definition die. */
22011 if (is_cxx () && debug_info_level
> DINFO_LEVEL_TERSE
)
22013 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
22014 if (die
== auto_die
|| die
== decltype_auto_die
)
22015 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22016 TYPE_UNQUALIFIED
, false, context_die
);
22019 /* When we process the method declaration, we haven't seen
22020 the out-of-class defaulted definition yet, so we have to
22022 if ((dwarf_version
>= 5 || ! dwarf_strict
)
22023 && !get_AT (subr_die
, DW_AT_defaulted
))
22026 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22028 if (defaulted
!= -1)
22030 /* Other values must have been handled before. */
22031 gcc_assert (defaulted
== DW_DEFAULTED_out_of_class
);
22032 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22037 /* Create a fresh DIE for anything else. */
22040 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22042 if (TREE_PUBLIC (decl
))
22043 add_AT_flag (subr_die
, DW_AT_external
, 1);
22045 add_name_and_src_coords_attributes (subr_die
, decl
);
22046 add_pubname (decl
, subr_die
);
22047 if (debug_info_level
> DINFO_LEVEL_TERSE
)
22049 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
22050 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22051 TYPE_UNQUALIFIED
, false, context_die
);
22054 add_pure_or_virtual_attribute (subr_die
, decl
);
22055 if (DECL_ARTIFICIAL (decl
))
22056 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
22058 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
22059 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
22061 add_alignment_attribute (subr_die
, decl
);
22063 add_accessibility_attribute (subr_die
, decl
);
22066 /* Unless we have an existing non-declaration DIE, equate the new
22068 if (!old_die
|| is_declaration_die (old_die
))
22069 equate_decl_number_to_die (decl
, subr_die
);
22073 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
22075 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
22077 /* If this is an explicit function declaration then generate
22078 a DW_AT_explicit attribute. */
22079 if ((dwarf_version
>= 3 || !dwarf_strict
)
22080 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22081 DW_AT_explicit
) == 1)
22082 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
22084 /* If this is a C++11 deleted special function member then generate
22085 a DW_AT_deleted attribute. */
22086 if ((dwarf_version
>= 5 || !dwarf_strict
)
22087 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22088 DW_AT_deleted
) == 1)
22089 add_AT_flag (subr_die
, DW_AT_deleted
, 1);
22091 /* If this is a C++11 defaulted special function member then
22092 generate a DW_AT_defaulted attribute. */
22093 if (dwarf_version
>= 5 || !dwarf_strict
)
22096 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22098 if (defaulted
!= -1)
22099 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22102 /* If this is a C++11 non-static member function with & ref-qualifier
22103 then generate a DW_AT_reference attribute. */
22104 if ((dwarf_version
>= 5 || !dwarf_strict
)
22105 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22106 DW_AT_reference
) == 1)
22107 add_AT_flag (subr_die
, DW_AT_reference
, 1);
22109 /* If this is a C++11 non-static member function with &&
22110 ref-qualifier then generate a DW_AT_reference attribute. */
22111 if ((dwarf_version
>= 5 || !dwarf_strict
)
22112 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22113 DW_AT_rvalue_reference
)
22115 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
22118 /* For non DECL_EXTERNALs, if range information is available, fill
22119 the DIE with it. */
22120 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
22122 HOST_WIDE_INT cfa_fb_offset
;
22124 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
22126 if (!crtl
->has_bb_partition
)
22128 dw_fde_ref fde
= fun
->fde
;
22129 if (fde
->dw_fde_begin
)
22131 /* We have already generated the labels. */
22132 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
22133 fde
->dw_fde_end
, false);
22137 /* Create start/end labels and add the range. */
22138 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
22139 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
22140 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
22141 current_function_funcdef_no
);
22142 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
22143 current_function_funcdef_no
);
22144 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
22148 #if VMS_DEBUGGING_INFO
22149 /* HP OpenVMS Industry Standard 64: DWARF Extensions
22150 Section 2.3 Prologue and Epilogue Attributes:
22151 When a breakpoint is set on entry to a function, it is generally
22152 desirable for execution to be suspended, not on the very first
22153 instruction of the function, but rather at a point after the
22154 function's frame has been set up, after any language defined local
22155 declaration processing has been completed, and before execution of
22156 the first statement of the function begins. Debuggers generally
22157 cannot properly determine where this point is. Similarly for a
22158 breakpoint set on exit from a function. The prologue and epilogue
22159 attributes allow a compiler to communicate the location(s) to use. */
22162 if (fde
->dw_fde_vms_end_prologue
)
22163 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
22164 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
22166 if (fde
->dw_fde_vms_begin_epilogue
)
22167 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
22168 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
22175 /* Generate pubnames entries for the split function code ranges. */
22176 dw_fde_ref fde
= fun
->fde
;
22178 if (fde
->dw_fde_second_begin
)
22180 if (dwarf_version
>= 3 || !dwarf_strict
)
22182 /* We should use ranges for non-contiguous code section
22183 addresses. Use the actual code range for the initial
22184 section, since the HOT/COLD labels might precede an
22185 alignment offset. */
22186 bool range_list_added
= false;
22187 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
22188 fde
->dw_fde_end
, &range_list_added
,
22190 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
22191 fde
->dw_fde_second_end
,
22192 &range_list_added
, false);
22193 if (range_list_added
)
22198 /* There is no real support in DW2 for this .. so we make
22199 a work-around. First, emit the pub name for the segment
22200 containing the function label. Then make and emit a
22201 simplified subprogram DIE for the second segment with the
22202 name pre-fixed by __hot/cold_sect_of_. We use the same
22203 linkage name for the second die so that gdb will find both
22204 sections when given "b foo". */
22205 const char *name
= NULL
;
22206 tree decl_name
= DECL_NAME (decl
);
22207 dw_die_ref seg_die
;
22209 /* Do the 'primary' section. */
22210 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
22211 fde
->dw_fde_end
, false);
22213 /* Build a minimal DIE for the secondary section. */
22214 seg_die
= new_die (DW_TAG_subprogram
,
22215 subr_die
->die_parent
, decl
);
22217 if (TREE_PUBLIC (decl
))
22218 add_AT_flag (seg_die
, DW_AT_external
, 1);
22220 if (decl_name
!= NULL
22221 && IDENTIFIER_POINTER (decl_name
) != NULL
)
22223 name
= dwarf2_name (decl
, 1);
22224 if (! DECL_ARTIFICIAL (decl
))
22225 add_src_coords_attributes (seg_die
, decl
);
22227 add_linkage_name (seg_die
, decl
);
22229 gcc_assert (name
!= NULL
);
22230 add_pure_or_virtual_attribute (seg_die
, decl
);
22231 if (DECL_ARTIFICIAL (decl
))
22232 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
22234 name
= concat ("__second_sect_of_", name
, NULL
);
22235 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
22236 fde
->dw_fde_second_end
, false);
22237 add_name_attribute (seg_die
, name
);
22238 if (want_pubnames ())
22239 add_pubname_string (name
, seg_die
);
22243 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
22247 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
22249 /* We define the "frame base" as the function's CFA. This is more
22250 convenient for several reasons: (1) It's stable across the prologue
22251 and epilogue, which makes it better than just a frame pointer,
22252 (2) With dwarf3, there exists a one-byte encoding that allows us
22253 to reference the .debug_frame data by proxy, but failing that,
22254 (3) We can at least reuse the code inspection and interpretation
22255 code that determines the CFA position at various points in the
22257 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
22259 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
22260 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
22264 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
22265 if (list
->dw_loc_next
)
22266 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
22268 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
22271 /* Compute a displacement from the "steady-state frame pointer" to
22272 the CFA. The former is what all stack slots and argument slots
22273 will reference in the rtl; the latter is what we've told the
22274 debugger about. We'll need to adjust all frame_base references
22275 by this displacement. */
22276 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
22278 if (fun
->static_chain_decl
)
22280 /* DWARF requires here a location expression that computes the
22281 address of the enclosing subprogram's frame base. The machinery
22282 in tree-nested.c is supposed to store this specific address in the
22283 last field of the FRAME record. */
22284 const tree frame_type
22285 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
22286 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
22289 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
22290 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
22291 fb_expr
, fb_decl
, NULL_TREE
);
22293 add_AT_location_description (subr_die
, DW_AT_static_link
,
22294 loc_list_from_tree (fb_expr
, 0, NULL
));
22297 resolve_variable_values ();
22300 /* Generate child dies for template paramaters. */
22301 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
22302 gen_generic_params_dies (decl
);
22304 /* Now output descriptions of the arguments for this function. This gets
22305 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
22306 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
22307 `...' at the end of the formal parameter list. In order to find out if
22308 there was a trailing ellipsis or not, we must instead look at the type
22309 associated with the FUNCTION_DECL. This will be a node of type
22310 FUNCTION_TYPE. If the chain of type nodes hanging off of this
22311 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
22312 an ellipsis at the end. */
22314 /* In the case where we are describing a mere function declaration, all we
22315 need to do here (and all we *can* do here) is to describe the *types* of
22316 its formal parameters. */
22317 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
22319 else if (declaration
)
22320 gen_formal_types_die (decl
, subr_die
);
22323 /* Generate DIEs to represent all known formal parameters. */
22324 tree parm
= DECL_ARGUMENTS (decl
);
22325 tree generic_decl
= early_dwarf
22326 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
22327 tree generic_decl_parm
= generic_decl
22328 ? DECL_ARGUMENTS (generic_decl
)
22331 /* Now we want to walk the list of parameters of the function and
22332 emit their relevant DIEs.
22334 We consider the case of DECL being an instance of a generic function
22335 as well as it being a normal function.
22337 If DECL is an instance of a generic function we walk the
22338 parameters of the generic function declaration _and_ the parameters of
22339 DECL itself. This is useful because we want to emit specific DIEs for
22340 function parameter packs and those are declared as part of the
22341 generic function declaration. In that particular case,
22342 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
22343 That DIE has children DIEs representing the set of arguments
22344 of the pack. Note that the set of pack arguments can be empty.
22345 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
22348 Otherwise, we just consider the parameters of DECL. */
22349 while (generic_decl_parm
|| parm
)
22351 if (generic_decl_parm
22352 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
22353 gen_formal_parameter_pack_die (generic_decl_parm
,
22356 else if (parm
&& !POINTER_BOUNDS_P (parm
))
22358 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
22361 && parm
== DECL_ARGUMENTS (decl
)
22362 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
22364 && (dwarf_version
>= 3 || !dwarf_strict
))
22365 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
22367 parm
= DECL_CHAIN (parm
);
22370 parm
= DECL_CHAIN (parm
);
22372 if (generic_decl_parm
)
22373 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
22376 /* Decide whether we need an unspecified_parameters DIE at the end.
22377 There are 2 more cases to do this for: 1) the ansi ... declaration -
22378 this is detectable when the end of the arg list is not a
22379 void_type_node 2) an unprototyped function declaration (not a
22380 definition). This just means that we have no info about the
22381 parameters at all. */
22384 if (prototype_p (TREE_TYPE (decl
)))
22386 /* This is the prototyped case, check for.... */
22387 if (stdarg_p (TREE_TYPE (decl
)))
22388 gen_unspecified_parameters_die (decl
, subr_die
);
22390 else if (DECL_INITIAL (decl
) == NULL_TREE
)
22391 gen_unspecified_parameters_die (decl
, subr_die
);
22395 if (subr_die
!= old_die
)
22396 /* Add the calling convention attribute if requested. */
22397 add_calling_convention_attribute (subr_die
, decl
);
22399 /* Output Dwarf info for all of the stuff within the body of the function
22400 (if it has one - it may be just a declaration).
22402 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
22403 a function. This BLOCK actually represents the outermost binding contour
22404 for the function, i.e. the contour in which the function's formal
22405 parameters and labels get declared. Curiously, it appears that the front
22406 end doesn't actually put the PARM_DECL nodes for the current function onto
22407 the BLOCK_VARS list for this outer scope, but are strung off of the
22408 DECL_ARGUMENTS list for the function instead.
22410 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
22411 the LABEL_DECL nodes for the function however, and we output DWARF info
22412 for those in decls_for_scope. Just within the `outer_scope' there will be
22413 a BLOCK node representing the function's outermost pair of curly braces,
22414 and any blocks used for the base and member initializers of a C++
22415 constructor function. */
22416 tree outer_scope
= DECL_INITIAL (decl
);
22417 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
22419 int call_site_note_count
= 0;
22420 int tail_call_site_note_count
= 0;
22422 /* Emit a DW_TAG_variable DIE for a named return value. */
22423 if (DECL_NAME (DECL_RESULT (decl
)))
22424 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
22426 /* The first time through decls_for_scope we will generate the
22427 DIEs for the locals. The second time, we fill in the
22429 decls_for_scope (outer_scope
, subr_die
);
22431 if (call_arg_locations
&& (!dwarf_strict
|| dwarf_version
>= 5))
22433 struct call_arg_loc_node
*ca_loc
;
22434 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
22436 dw_die_ref die
= NULL
;
22437 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
22440 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
22441 ? NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
)
22443 arg
; arg
= next_arg
)
22445 dw_loc_descr_ref reg
, val
;
22446 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
22447 dw_die_ref cdie
, tdie
= NULL
;
22449 next_arg
= XEXP (arg
, 1);
22450 if (REG_P (XEXP (XEXP (arg
, 0), 0))
22452 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
22453 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
22454 && REGNO (XEXP (XEXP (arg
, 0), 0))
22455 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
22456 next_arg
= XEXP (next_arg
, 1);
22457 if (mode
== VOIDmode
)
22459 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
22460 if (mode
== VOIDmode
)
22461 mode
= GET_MODE (XEXP (arg
, 0));
22463 if (mode
== VOIDmode
|| mode
== BLKmode
)
22465 /* Get dynamic information about call target only if we
22466 have no static information: we cannot generate both
22467 DW_AT_call_origin and DW_AT_call_target
22469 if (ca_loc
->symbol_ref
== NULL_RTX
)
22471 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
22473 tloc
= XEXP (XEXP (arg
, 0), 1);
22476 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
22477 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
22479 tlocc
= XEXP (XEXP (arg
, 0), 1);
22484 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
22485 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
22486 VAR_INIT_STATUS_INITIALIZED
);
22487 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
22489 rtx mem
= XEXP (XEXP (arg
, 0), 0);
22490 reg
= mem_loc_descriptor (XEXP (mem
, 0),
22491 get_address_mode (mem
),
22493 VAR_INIT_STATUS_INITIALIZED
);
22495 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
22496 == DEBUG_PARAMETER_REF
)
22499 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
22500 tdie
= lookup_decl_die (tdecl
);
22507 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
22508 != DEBUG_PARAMETER_REF
)
22510 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
22512 VAR_INIT_STATUS_INITIALIZED
);
22516 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
22517 cdie
= new_die (dwarf_TAG (DW_TAG_call_site_parameter
), die
,
22520 add_AT_loc (cdie
, DW_AT_location
, reg
);
22521 else if (tdie
!= NULL
)
22522 add_AT_die_ref (cdie
, dwarf_AT (DW_AT_call_parameter
),
22524 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_value
), val
);
22525 if (next_arg
!= XEXP (arg
, 1))
22527 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
22528 if (mode
== VOIDmode
)
22529 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
22530 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
22533 VAR_INIT_STATUS_INITIALIZED
);
22535 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_data_value
),
22540 && (ca_loc
->symbol_ref
|| tloc
))
22541 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
22542 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
22544 dw_loc_descr_ref tval
= NULL
;
22546 if (tloc
!= NULL_RTX
)
22547 tval
= mem_loc_descriptor (tloc
,
22548 GET_MODE (tloc
) == VOIDmode
22549 ? Pmode
: GET_MODE (tloc
),
22551 VAR_INIT_STATUS_INITIALIZED
);
22553 add_AT_loc (die
, dwarf_AT (DW_AT_call_target
), tval
);
22554 else if (tlocc
!= NULL_RTX
)
22556 tval
= mem_loc_descriptor (tlocc
,
22557 GET_MODE (tlocc
) == VOIDmode
22558 ? Pmode
: GET_MODE (tlocc
),
22560 VAR_INIT_STATUS_INITIALIZED
);
22563 dwarf_AT (DW_AT_call_target_clobbered
),
22569 call_site_note_count
++;
22570 if (ca_loc
->tail_call_p
)
22571 tail_call_site_note_count
++;
22575 call_arg_locations
= NULL
;
22576 call_arg_loc_last
= NULL
;
22577 if (tail_call_site_count
>= 0
22578 && tail_call_site_count
== tail_call_site_note_count
22579 && (!dwarf_strict
|| dwarf_version
>= 5))
22581 if (call_site_count
>= 0
22582 && call_site_count
== call_site_note_count
)
22583 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_calls
), 1);
22585 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_tail_calls
), 1);
22587 call_site_count
= -1;
22588 tail_call_site_count
= -1;
22591 /* Mark used types after we have created DIEs for the functions scopes. */
22592 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
22595 /* Returns a hash value for X (which really is a die_struct). */
22598 block_die_hasher::hash (die_struct
*d
)
22600 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
22603 /* Return nonzero if decl_id and die_parent of die_struct X is the same
22604 as decl_id and die_parent of die_struct Y. */
22607 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
22609 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
22612 /* Return TRUE if DECL, which may have been previously generated as
22613 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
22614 true if decl (or its origin) is either an extern declaration or a
22615 class/namespace scoped declaration.
22617 The declare_in_namespace support causes us to get two DIEs for one
22618 variable, both of which are declarations. We want to avoid
22619 considering one to be a specification, so we must test for
22620 DECLARATION and DW_AT_declaration. */
22622 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
22624 return (old_die
&& TREE_STATIC (decl
) && !declaration
22625 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
22628 /* Return true if DECL is a local static. */
22631 local_function_static (tree decl
)
22633 gcc_assert (VAR_P (decl
));
22634 return TREE_STATIC (decl
)
22635 && DECL_CONTEXT (decl
)
22636 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
22639 /* Generate a DIE to represent a declared data object.
22640 Either DECL or ORIGIN must be non-null. */
22643 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
22645 HOST_WIDE_INT off
= 0;
22647 tree decl_or_origin
= decl
? decl
: origin
;
22648 tree ultimate_origin
;
22649 dw_die_ref var_die
;
22650 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
22651 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
22652 || class_or_namespace_scope_p (context_die
));
22653 bool specialization_p
= false;
22654 bool no_linkage_name
= false;
22656 /* While C++ inline static data members have definitions inside of the
22657 class, force the first DIE to be a declaration, then let gen_member_die
22658 reparent it to the class context and call gen_variable_die again
22659 to create the outside of the class DIE for the definition. */
22663 && DECL_CONTEXT (decl
)
22664 && TYPE_P (DECL_CONTEXT (decl
))
22665 && lang_hooks
.decls
.decl_dwarf_attribute (decl
, DW_AT_inline
) != -1)
22667 declaration
= true;
22668 if (dwarf_version
< 5)
22669 no_linkage_name
= true;
22672 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
22673 if (decl
|| ultimate_origin
)
22674 origin
= ultimate_origin
;
22675 com_decl
= fortran_common (decl_or_origin
, &off
);
22677 /* Symbol in common gets emitted as a child of the common block, in the form
22678 of a data member. */
22681 dw_die_ref com_die
;
22682 dw_loc_list_ref loc
= NULL
;
22683 die_node com_die_arg
;
22685 var_die
= lookup_decl_die (decl_or_origin
);
22688 if (! early_dwarf
&& get_AT (var_die
, DW_AT_location
) == NULL
)
22690 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
22695 /* Optimize the common case. */
22696 if (single_element_loc_list_p (loc
)
22697 && loc
->expr
->dw_loc_opc
== DW_OP_addr
22698 && loc
->expr
->dw_loc_next
== NULL
22699 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
22702 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
22703 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
22704 = plus_constant (GET_MODE (x
), x
, off
);
22707 loc_list_plus_const (loc
, off
);
22709 add_AT_location_description (var_die
, DW_AT_location
, loc
);
22710 remove_AT (var_die
, DW_AT_declaration
);
22716 if (common_block_die_table
== NULL
)
22717 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
22719 com_die_arg
.decl_id
= DECL_UID (com_decl
);
22720 com_die_arg
.die_parent
= context_die
;
22721 com_die
= common_block_die_table
->find (&com_die_arg
);
22723 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
22724 if (com_die
== NULL
)
22727 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
22730 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
22731 add_name_and_src_coords_attributes (com_die
, com_decl
);
22734 add_AT_location_description (com_die
, DW_AT_location
, loc
);
22735 /* Avoid sharing the same loc descriptor between
22736 DW_TAG_common_block and DW_TAG_variable. */
22737 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
22739 else if (DECL_EXTERNAL (decl_or_origin
))
22740 add_AT_flag (com_die
, DW_AT_declaration
, 1);
22741 if (want_pubnames ())
22742 add_pubname_string (cnam
, com_die
); /* ??? needed? */
22743 com_die
->decl_id
= DECL_UID (com_decl
);
22744 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
22747 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
22749 add_AT_location_description (com_die
, DW_AT_location
, loc
);
22750 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
22751 remove_AT (com_die
, DW_AT_declaration
);
22753 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
22754 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
22755 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
22756 decl_quals (decl_or_origin
), false,
22758 add_alignment_attribute (var_die
, decl
);
22759 add_AT_flag (var_die
, DW_AT_external
, 1);
22764 /* Optimize the common case. */
22765 if (single_element_loc_list_p (loc
)
22766 && loc
->expr
->dw_loc_opc
== DW_OP_addr
22767 && loc
->expr
->dw_loc_next
== NULL
22768 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
22770 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
22771 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
22772 = plus_constant (GET_MODE (x
), x
, off
);
22775 loc_list_plus_const (loc
, off
);
22777 add_AT_location_description (var_die
, DW_AT_location
, loc
);
22779 else if (DECL_EXTERNAL (decl_or_origin
))
22780 add_AT_flag (var_die
, DW_AT_declaration
, 1);
22782 equate_decl_number_to_die (decl
, var_die
);
22790 /* A declaration that has been previously dumped, needs no
22791 further annotations, since it doesn't need location on
22792 the second pass. */
22795 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
22796 && !get_AT (old_die
, DW_AT_specification
))
22798 /* Fall-thru so we can make a new variable die along with a
22799 DW_AT_specification. */
22801 else if (origin
&& old_die
->die_parent
!= context_die
)
22803 /* If we will be creating an inlined instance, we need a
22804 new DIE that will get annotated with
22805 DW_AT_abstract_origin. Clear things so we can get a
22807 gcc_assert (!DECL_ABSTRACT_P (decl
));
22812 /* If a DIE was dumped early, it still needs location info.
22813 Skip to where we fill the location bits. */
22816 /* ??? In LTRANS we cannot annotate early created variably
22817 modified type DIEs without copying them and adjusting all
22818 references to them. Thus we dumped them again, also add a
22819 reference to them. */
22820 tree type
= TREE_TYPE (decl_or_origin
);
22822 && variably_modified_type_p
22823 (type
, decl_function_context (decl_or_origin
)))
22825 if (decl_by_reference_p (decl_or_origin
))
22826 add_type_attribute (var_die
, TREE_TYPE (type
),
22827 TYPE_UNQUALIFIED
, false, context_die
);
22829 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
22830 false, context_die
);
22833 goto gen_variable_die_location
;
22837 /* For static data members, the declaration in the class is supposed
22838 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
22839 also in DWARF2; the specification should still be DW_TAG_variable
22840 referencing the DW_TAG_member DIE. */
22841 if (declaration
&& class_scope_p (context_die
) && dwarf_version
< 5)
22842 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
22844 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
22846 if (origin
!= NULL
)
22847 add_abstract_origin_attribute (var_die
, origin
);
22849 /* Loop unrolling can create multiple blocks that refer to the same
22850 static variable, so we must test for the DW_AT_declaration flag.
22852 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
22853 copy decls and set the DECL_ABSTRACT_P flag on them instead of
22856 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
22857 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
22859 /* This is a definition of a C++ class level static. */
22860 add_AT_specification (var_die
, old_die
);
22861 specialization_p
= true;
22862 if (DECL_NAME (decl
))
22864 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
22865 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
22867 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
22868 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
22870 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
22871 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
22873 if (debug_column_info
22875 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22876 != (unsigned) s
.column
))
22877 add_AT_unsigned (var_die
, DW_AT_decl_column
, s
.column
);
22879 if (old_die
->die_tag
== DW_TAG_member
)
22880 add_linkage_name (var_die
, decl
);
22884 add_name_and_src_coords_attributes (var_die
, decl
, no_linkage_name
);
22886 if ((origin
== NULL
&& !specialization_p
)
22888 && !DECL_ABSTRACT_P (decl_or_origin
)
22889 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
22890 decl_function_context
22891 (decl_or_origin
))))
22893 tree type
= TREE_TYPE (decl_or_origin
);
22895 if (decl_by_reference_p (decl_or_origin
))
22896 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
22899 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
22903 if (origin
== NULL
&& !specialization_p
)
22905 if (TREE_PUBLIC (decl
))
22906 add_AT_flag (var_die
, DW_AT_external
, 1);
22908 if (DECL_ARTIFICIAL (decl
))
22909 add_AT_flag (var_die
, DW_AT_artificial
, 1);
22911 add_alignment_attribute (var_die
, decl
);
22913 add_accessibility_attribute (var_die
, decl
);
22917 add_AT_flag (var_die
, DW_AT_declaration
, 1);
22919 if (decl
&& (DECL_ABSTRACT_P (decl
)
22920 || !old_die
|| is_declaration_die (old_die
)))
22921 equate_decl_number_to_die (decl
, var_die
);
22923 gen_variable_die_location
:
22925 && (! DECL_ABSTRACT_P (decl_or_origin
)
22926 /* Local static vars are shared between all clones/inlines,
22927 so emit DW_AT_location on the abstract DIE if DECL_RTL is
22929 || (VAR_P (decl_or_origin
)
22930 && TREE_STATIC (decl_or_origin
)
22931 && DECL_RTL_SET_P (decl_or_origin
))))
22934 add_pubname (decl_or_origin
, var_die
);
22936 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
22940 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
22942 if ((dwarf_version
>= 4 || !dwarf_strict
)
22943 && lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
22944 DW_AT_const_expr
) == 1
22945 && !get_AT (var_die
, DW_AT_const_expr
)
22946 && !specialization_p
)
22947 add_AT_flag (var_die
, DW_AT_const_expr
, 1);
22951 int inl
= lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
22954 && !get_AT (var_die
, DW_AT_inline
)
22955 && !specialization_p
)
22956 add_AT_unsigned (var_die
, DW_AT_inline
, inl
);
22960 /* Generate a DIE to represent a named constant. */
22963 gen_const_die (tree decl
, dw_die_ref context_die
)
22965 dw_die_ref const_die
;
22966 tree type
= TREE_TYPE (decl
);
22968 const_die
= lookup_decl_die (decl
);
22972 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
22973 equate_decl_number_to_die (decl
, const_die
);
22974 add_name_and_src_coords_attributes (const_die
, decl
);
22975 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
22976 if (TREE_PUBLIC (decl
))
22977 add_AT_flag (const_die
, DW_AT_external
, 1);
22978 if (DECL_ARTIFICIAL (decl
))
22979 add_AT_flag (const_die
, DW_AT_artificial
, 1);
22980 tree_add_const_value_attribute_for_decl (const_die
, decl
);
22983 /* Generate a DIE to represent a label identifier. */
22986 gen_label_die (tree decl
, dw_die_ref context_die
)
22988 tree origin
= decl_ultimate_origin (decl
);
22989 dw_die_ref lbl_die
= lookup_decl_die (decl
);
22991 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
22995 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
22996 equate_decl_number_to_die (decl
, lbl_die
);
22998 if (origin
!= NULL
)
22999 add_abstract_origin_attribute (lbl_die
, origin
);
23001 add_name_and_src_coords_attributes (lbl_die
, decl
);
23004 if (DECL_ABSTRACT_P (decl
))
23005 equate_decl_number_to_die (decl
, lbl_die
);
23006 else if (! early_dwarf
)
23008 insn
= DECL_RTL_IF_SET (decl
);
23010 /* Deleted labels are programmer specified labels which have been
23011 eliminated because of various optimizations. We still emit them
23012 here so that it is possible to put breakpoints on them. */
23016 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
23018 /* When optimization is enabled (via -O) some parts of the compiler
23019 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
23020 represent source-level labels which were explicitly declared by
23021 the user. This really shouldn't be happening though, so catch
23022 it if it ever does happen. */
23023 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
23025 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
23026 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23030 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
23031 && CODE_LABEL_NUMBER (insn
) != -1)
23033 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
23034 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23039 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
23040 attributes to the DIE for a block STMT, to describe where the inlined
23041 function was called from. This is similar to add_src_coords_attributes. */
23044 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
23046 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
23048 if (dwarf_version
>= 3 || !dwarf_strict
)
23050 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
23051 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
23052 if (debug_column_info
&& s
.column
)
23053 add_AT_unsigned (die
, DW_AT_call_column
, s
.column
);
23058 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
23059 Add low_pc and high_pc attributes to the DIE for a block STMT. */
23062 add_high_low_attributes (tree stmt
, dw_die_ref die
)
23064 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23066 if (BLOCK_FRAGMENT_CHAIN (stmt
)
23067 && (dwarf_version
>= 3 || !dwarf_strict
))
23069 tree chain
, superblock
= NULL_TREE
;
23071 dw_attr_node
*attr
= NULL
;
23073 if (inlined_function_outer_scope_p (stmt
))
23075 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
23076 BLOCK_NUMBER (stmt
));
23077 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
23080 /* Optimize duplicate .debug_ranges lists or even tails of
23081 lists. If this BLOCK has same ranges as its supercontext,
23082 lookup DW_AT_ranges attribute in the supercontext (and
23083 recursively so), verify that the ranges_table contains the
23084 right values and use it instead of adding a new .debug_range. */
23085 for (chain
= stmt
, pdie
= die
;
23086 BLOCK_SAME_RANGE (chain
);
23087 chain
= BLOCK_SUPERCONTEXT (chain
))
23089 dw_attr_node
*new_attr
;
23091 pdie
= pdie
->die_parent
;
23094 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
23096 new_attr
= get_AT (pdie
, DW_AT_ranges
);
23097 if (new_attr
== NULL
23098 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
23101 superblock
= BLOCK_SUPERCONTEXT (chain
);
23104 && ((*ranges_table
)[attr
->dw_attr_val
.v
.val_offset
].num
23105 == BLOCK_NUMBER (superblock
))
23106 && BLOCK_FRAGMENT_CHAIN (superblock
))
23108 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
;
23109 unsigned long supercnt
= 0, thiscnt
= 0;
23110 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
23111 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
23114 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
].num
23115 == BLOCK_NUMBER (chain
));
23117 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
+ 1].num
== 0);
23118 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
23119 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
23121 gcc_assert (supercnt
>= thiscnt
);
23122 add_AT_range_list (die
, DW_AT_ranges
, off
+ supercnt
- thiscnt
,
23124 note_rnglist_head (off
+ supercnt
- thiscnt
);
23128 unsigned int offset
= add_ranges (stmt
, true);
23129 add_AT_range_list (die
, DW_AT_ranges
, offset
, false);
23130 note_rnglist_head (offset
);
23132 bool prev_in_cold
= BLOCK_IN_COLD_SECTION_P (stmt
);
23133 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
23136 add_ranges (chain
, prev_in_cold
!= BLOCK_IN_COLD_SECTION_P (chain
));
23137 prev_in_cold
= BLOCK_IN_COLD_SECTION_P (chain
);
23138 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
23145 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
23146 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
23147 BLOCK_NUMBER (stmt
));
23148 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
23149 BLOCK_NUMBER (stmt
));
23150 add_AT_low_high_pc (die
, label
, label_high
, false);
23154 /* Generate a DIE for a lexical block. */
23157 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
23159 dw_die_ref old_die
= BLOCK_DIE (stmt
);
23160 dw_die_ref stmt_die
= NULL
;
23163 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
23164 BLOCK_DIE (stmt
) = stmt_die
;
23167 if (BLOCK_ABSTRACT (stmt
))
23171 /* This must have been generated early and it won't even
23172 need location information since it's a DW_AT_inline
23175 for (dw_die_ref c
= context_die
; c
; c
= c
->die_parent
)
23176 if (c
->die_tag
== DW_TAG_inlined_subroutine
23177 || c
->die_tag
== DW_TAG_subprogram
)
23179 gcc_assert (get_AT (c
, DW_AT_inline
));
23185 else if (BLOCK_ABSTRACT_ORIGIN (stmt
))
23187 /* If this is an inlined instance, create a new lexical die for
23188 anything below to attach DW_AT_abstract_origin to. */
23191 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
23192 BLOCK_DIE (stmt
) = stmt_die
;
23196 tree origin
= block_ultimate_origin (stmt
);
23197 if (origin
!= NULL_TREE
&& origin
!= stmt
)
23198 add_abstract_origin_attribute (stmt_die
, origin
);
23202 stmt_die
= old_die
;
23204 /* A non abstract block whose blocks have already been reordered
23205 should have the instruction range for this block. If so, set the
23206 high/low attributes. */
23207 if (!early_dwarf
&& !BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
23209 gcc_assert (stmt_die
);
23210 add_high_low_attributes (stmt
, stmt_die
);
23213 decls_for_scope (stmt
, stmt_die
);
23216 /* Generate a DIE for an inlined subprogram. */
23219 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
23223 /* The instance of function that is effectively being inlined shall not
23225 gcc_assert (! BLOCK_ABSTRACT (stmt
));
23227 decl
= block_ultimate_origin (stmt
);
23229 /* Make sure any inlined functions are known to be inlineable. */
23230 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
23231 || cgraph_function_possibly_inlined_p (decl
));
23233 if (! BLOCK_ABSTRACT (stmt
))
23235 dw_die_ref subr_die
23236 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
23238 if (call_arg_locations
)
23239 BLOCK_DIE (stmt
) = subr_die
;
23240 add_abstract_origin_attribute (subr_die
, decl
);
23241 if (TREE_ASM_WRITTEN (stmt
))
23242 add_high_low_attributes (stmt
, subr_die
);
23243 add_call_src_coords_attributes (stmt
, subr_die
);
23245 decls_for_scope (stmt
, subr_die
);
23249 /* Generate a DIE for a field in a record, or structure. CTX is required: see
23250 the comment for VLR_CONTEXT. */
23253 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
23255 dw_die_ref decl_die
;
23257 if (TREE_TYPE (decl
) == error_mark_node
)
23260 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
23261 add_name_and_src_coords_attributes (decl_die
, decl
);
23262 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
23263 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
23266 if (DECL_BIT_FIELD_TYPE (decl
))
23268 add_byte_size_attribute (decl_die
, decl
);
23269 add_bit_size_attribute (decl_die
, decl
);
23270 add_bit_offset_attribute (decl_die
, decl
, ctx
);
23273 add_alignment_attribute (decl_die
, decl
);
23275 /* If we have a variant part offset, then we are supposed to process a member
23276 of a QUAL_UNION_TYPE, which is how we represent variant parts in
23278 gcc_assert (ctx
->variant_part_offset
== NULL_TREE
23279 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != QUAL_UNION_TYPE
);
23280 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
23281 add_data_member_location_attribute (decl_die
, decl
, ctx
);
23283 if (DECL_ARTIFICIAL (decl
))
23284 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
23286 add_accessibility_attribute (decl_die
, decl
);
23288 /* Equate decl number to die, so that we can look up this decl later on. */
23289 equate_decl_number_to_die (decl
, decl_die
);
23292 /* Generate a DIE for a pointer to a member type. TYPE can be an
23293 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
23294 pointer to member function. */
23297 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
23299 if (lookup_type_die (type
))
23302 dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type
,
23303 scope_die_for (type
, context_die
), type
);
23305 equate_type_number_to_die (type
, ptr_die
);
23306 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
23307 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
23308 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
23310 add_alignment_attribute (ptr_die
, type
);
23312 if (TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
23313 && TREE_CODE (TREE_TYPE (type
)) != METHOD_TYPE
)
23315 dw_loc_descr_ref op
= new_loc_descr (DW_OP_plus
, 0, 0);
23316 add_AT_loc (ptr_die
, DW_AT_use_location
, op
);
23320 static char *producer_string
;
23322 /* Return a heap allocated producer string including command line options
23323 if -grecord-gcc-switches. */
23326 gen_producer_string (void)
23329 auto_vec
<const char *> switches
;
23330 const char *language_string
= lang_hooks
.name
;
23331 char *producer
, *tail
;
23333 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
23334 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
23336 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
23337 switch (save_decoded_options
[j
].opt_index
)
23344 case OPT_auxbase_strip
:
23353 case OPT_SPECIAL_unknown
:
23354 case OPT_SPECIAL_ignore
:
23355 case OPT_SPECIAL_program_name
:
23356 case OPT_SPECIAL_input_file
:
23357 case OPT_grecord_gcc_switches
:
23358 case OPT_gno_record_gcc_switches
:
23359 case OPT__output_pch_
:
23360 case OPT_fdiagnostics_show_location_
:
23361 case OPT_fdiagnostics_show_option
:
23362 case OPT_fdiagnostics_show_caret
:
23363 case OPT_fdiagnostics_color_
:
23364 case OPT_fverbose_asm
:
23366 case OPT__sysroot_
:
23368 case OPT_nostdinc__
:
23369 case OPT_fpreprocessed
:
23370 case OPT_fltrans_output_list_
:
23371 case OPT_fresolution_
:
23372 case OPT_fdebug_prefix_map_
:
23373 /* Ignore these. */
23376 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
23377 & CL_NO_DWARF_RECORD
)
23379 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
23381 switch (save_decoded_options
[j
].canonical_option
[0][1])
23388 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
23395 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
23396 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
23400 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
23402 sprintf (tail
, "%s %s", language_string
, version_string
);
23405 FOR_EACH_VEC_ELT (switches
, j
, p
)
23409 memcpy (tail
+ 1, p
, len
);
23417 /* Given a C and/or C++ language/version string return the "highest".
23418 C++ is assumed to be "higher" than C in this case. Used for merging
23419 LTO translation unit languages. */
23420 static const char *
23421 highest_c_language (const char *lang1
, const char *lang2
)
23423 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
23424 return "GNU C++14";
23425 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
23426 return "GNU C++11";
23427 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
23428 return "GNU C++98";
23430 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
23432 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
23434 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
23437 gcc_unreachable ();
23441 /* Generate the DIE for the compilation unit. */
23444 gen_compile_unit_die (const char *filename
)
23447 const char *language_string
= lang_hooks
.name
;
23450 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
23454 add_name_attribute (die
, filename
);
23455 /* Don't add cwd for <built-in>. */
23456 if (filename
[0] != '<')
23457 add_comp_dir_attribute (die
);
23460 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
23462 /* If our producer is LTO try to figure out a common language to use
23463 from the global list of translation units. */
23464 if (strcmp (language_string
, "GNU GIMPLE") == 0)
23468 const char *common_lang
= NULL
;
23470 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
23472 if (!TRANSLATION_UNIT_LANGUAGE (t
))
23475 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
23476 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
23478 else if (strncmp (common_lang
, "GNU C", 5) == 0
23479 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
23480 /* Mixing C and C++ is ok, use C++ in that case. */
23481 common_lang
= highest_c_language (common_lang
,
23482 TRANSLATION_UNIT_LANGUAGE (t
));
23485 /* Fall back to C. */
23486 common_lang
= NULL
;
23492 language_string
= common_lang
;
23495 language
= DW_LANG_C
;
23496 if (strncmp (language_string
, "GNU C", 5) == 0
23497 && ISDIGIT (language_string
[5]))
23499 language
= DW_LANG_C89
;
23500 if (dwarf_version
>= 3 || !dwarf_strict
)
23502 if (strcmp (language_string
, "GNU C89") != 0)
23503 language
= DW_LANG_C99
;
23505 if (dwarf_version
>= 5 /* || !dwarf_strict */)
23506 if (strcmp (language_string
, "GNU C11") == 0)
23507 language
= DW_LANG_C11
;
23510 else if (strncmp (language_string
, "GNU C++", 7) == 0)
23512 language
= DW_LANG_C_plus_plus
;
23513 if (dwarf_version
>= 5 /* || !dwarf_strict */)
23515 if (strcmp (language_string
, "GNU C++11") == 0)
23516 language
= DW_LANG_C_plus_plus_11
;
23517 else if (strcmp (language_string
, "GNU C++14") == 0)
23518 language
= DW_LANG_C_plus_plus_14
;
23521 else if (strcmp (language_string
, "GNU F77") == 0)
23522 language
= DW_LANG_Fortran77
;
23523 else if (dwarf_version
>= 3 || !dwarf_strict
)
23525 if (strcmp (language_string
, "GNU Ada") == 0)
23526 language
= DW_LANG_Ada95
;
23527 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
23529 language
= DW_LANG_Fortran95
;
23530 if (dwarf_version
>= 5 /* || !dwarf_strict */)
23532 if (strcmp (language_string
, "GNU Fortran2003") == 0)
23533 language
= DW_LANG_Fortran03
;
23534 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
23535 language
= DW_LANG_Fortran08
;
23538 else if (strcmp (language_string
, "GNU Objective-C") == 0)
23539 language
= DW_LANG_ObjC
;
23540 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
23541 language
= DW_LANG_ObjC_plus_plus
;
23542 else if (dwarf_version
>= 5 || !dwarf_strict
)
23544 if (strcmp (language_string
, "GNU Go") == 0)
23545 language
= DW_LANG_Go
;
23548 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
23549 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
23550 language
= DW_LANG_Fortran90
;
23552 add_AT_unsigned (die
, DW_AT_language
, language
);
23556 case DW_LANG_Fortran77
:
23557 case DW_LANG_Fortran90
:
23558 case DW_LANG_Fortran95
:
23559 case DW_LANG_Fortran03
:
23560 case DW_LANG_Fortran08
:
23561 /* Fortran has case insensitive identifiers and the front-end
23562 lowercases everything. */
23563 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
23566 /* The default DW_ID_case_sensitive doesn't need to be specified. */
23572 /* Generate the DIE for a base class. */
23575 gen_inheritance_die (tree binfo
, tree access
, tree type
,
23576 dw_die_ref context_die
)
23578 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
23579 struct vlr_context ctx
= { type
, NULL
};
23581 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
23583 add_data_member_location_attribute (die
, binfo
, &ctx
);
23585 if (BINFO_VIRTUAL_P (binfo
))
23586 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
23588 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
23589 children, otherwise the default is DW_ACCESS_public. In DWARF2
23590 the default has always been DW_ACCESS_private. */
23591 if (access
== access_public_node
)
23593 if (dwarf_version
== 2
23594 || context_die
->die_tag
== DW_TAG_class_type
)
23595 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
23597 else if (access
== access_protected_node
)
23598 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
23599 else if (dwarf_version
> 2
23600 && context_die
->die_tag
!= DW_TAG_class_type
)
23601 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
23604 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
23607 is_variant_part (tree decl
)
23609 return (TREE_CODE (decl
) == FIELD_DECL
23610 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
23613 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
23614 return the FIELD_DECL. Return NULL_TREE otherwise. */
23617 analyze_discr_in_predicate (tree operand
, tree struct_type
)
23619 bool continue_stripping
= true;
23620 while (continue_stripping
)
23621 switch (TREE_CODE (operand
))
23624 operand
= TREE_OPERAND (operand
, 0);
23627 continue_stripping
= false;
23631 /* Match field access to members of struct_type only. */
23632 if (TREE_CODE (operand
) == COMPONENT_REF
23633 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
23634 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
23635 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
23636 return TREE_OPERAND (operand
, 1);
23641 /* Check that SRC is a constant integer that can be represented as a native
23642 integer constant (either signed or unsigned). If so, store it into DEST and
23643 return true. Return false otherwise. */
23646 get_discr_value (tree src
, dw_discr_value
*dest
)
23648 tree discr_type
= TREE_TYPE (src
);
23650 if (lang_hooks
.types
.get_debug_type
)
23652 tree debug_type
= lang_hooks
.types
.get_debug_type (discr_type
);
23653 if (debug_type
!= NULL
)
23654 discr_type
= debug_type
;
23657 if (TREE_CODE (src
) != INTEGER_CST
|| !INTEGRAL_TYPE_P (discr_type
))
23660 /* Signedness can vary between the original type and the debug type. This
23661 can happen for character types in Ada for instance: the character type
23662 used for code generation can be signed, to be compatible with the C one,
23663 but from a debugger point of view, it must be unsigned. */
23664 bool is_orig_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
23665 bool is_debug_unsigned
= TYPE_UNSIGNED (discr_type
);
23667 if (is_orig_unsigned
!= is_debug_unsigned
)
23668 src
= fold_convert (discr_type
, src
);
23670 if (!(is_debug_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
23673 dest
->pos
= is_debug_unsigned
;
23674 if (is_debug_unsigned
)
23675 dest
->v
.uval
= tree_to_uhwi (src
);
23677 dest
->v
.sval
= tree_to_shwi (src
);
23682 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
23683 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
23684 store NULL_TREE in DISCR_DECL. Otherwise:
23686 - store the discriminant field in STRUCT_TYPE that controls the variant
23687 part to *DISCR_DECL
23689 - put in *DISCR_LISTS_P an array where for each variant, the item
23690 represents the corresponding matching list of discriminant values.
23692 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
23695 Note that when the array is allocated (i.e. when the analysis is
23696 successful), it is up to the caller to free the array. */
23699 analyze_variants_discr (tree variant_part_decl
,
23702 dw_discr_list_ref
**discr_lists_p
,
23703 unsigned *discr_lists_length
)
23705 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
23707 dw_discr_list_ref
*discr_lists
;
23710 /* Compute how many variants there are in this variant part. */
23711 *discr_lists_length
= 0;
23712 for (variant
= TYPE_FIELDS (variant_part_type
);
23713 variant
!= NULL_TREE
;
23714 variant
= DECL_CHAIN (variant
))
23715 ++*discr_lists_length
;
23717 *discr_decl
= NULL_TREE
;
23719 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
23720 sizeof (**discr_lists_p
));
23721 discr_lists
= *discr_lists_p
;
23723 /* And then analyze all variants to extract discriminant information for all
23724 of them. This analysis is conservative: as soon as we detect something we
23725 do not support, abort everything and pretend we found nothing. */
23726 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
23727 variant
!= NULL_TREE
;
23728 variant
= DECL_CHAIN (variant
), ++i
)
23730 tree match_expr
= DECL_QUALIFIER (variant
);
23732 /* Now, try to analyze the predicate and deduce a discriminant for
23734 if (match_expr
== boolean_true_node
)
23735 /* Typically happens for the default variant: it matches all cases that
23736 previous variants rejected. Don't output any matching value for
23740 /* The following loop tries to iterate over each discriminant
23741 possibility: single values or ranges. */
23742 while (match_expr
!= NULL_TREE
)
23744 tree next_round_match_expr
;
23745 tree candidate_discr
= NULL_TREE
;
23746 dw_discr_list_ref new_node
= NULL
;
23748 /* Possibilities are matched one after the other by nested
23749 TRUTH_ORIF_EXPR expressions. Process the current possibility and
23750 continue with the rest at next iteration. */
23751 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
23753 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
23754 match_expr
= TREE_OPERAND (match_expr
, 1);
23757 next_round_match_expr
= NULL_TREE
;
23759 if (match_expr
== boolean_false_node
)
23760 /* This sub-expression matches nothing: just wait for the next
23764 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
23766 /* We are matching: <discr_field> == <integer_cst>
23767 This sub-expression matches a single value. */
23768 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
23771 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
23774 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
23775 if (!get_discr_value (integer_cst
,
23776 &new_node
->dw_discr_lower_bound
))
23778 new_node
->dw_discr_range
= false;
23781 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
23783 /* We are matching:
23784 <discr_field> > <integer_cst>
23785 && <discr_field> < <integer_cst>.
23786 This sub-expression matches the range of values between the
23787 two matched integer constants. Note that comparisons can be
23788 inclusive or exclusive. */
23789 tree candidate_discr_1
, candidate_discr_2
;
23790 tree lower_cst
, upper_cst
;
23791 bool lower_cst_included
, upper_cst_included
;
23792 tree lower_op
= TREE_OPERAND (match_expr
, 0);
23793 tree upper_op
= TREE_OPERAND (match_expr
, 1);
23795 /* When the comparison is exclusive, the integer constant is not
23796 the discriminant range bound we are looking for: we will have
23797 to increment or decrement it. */
23798 if (TREE_CODE (lower_op
) == GE_EXPR
)
23799 lower_cst_included
= true;
23800 else if (TREE_CODE (lower_op
) == GT_EXPR
)
23801 lower_cst_included
= false;
23805 if (TREE_CODE (upper_op
) == LE_EXPR
)
23806 upper_cst_included
= true;
23807 else if (TREE_CODE (upper_op
) == LT_EXPR
)
23808 upper_cst_included
= false;
23812 /* Extract the discriminant from the first operand and check it
23813 is consistant with the same analysis in the second
23816 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
23819 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
23821 if (candidate_discr_1
== candidate_discr_2
)
23822 candidate_discr
= candidate_discr_1
;
23826 /* Extract bounds from both. */
23827 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
23828 lower_cst
= TREE_OPERAND (lower_op
, 1);
23829 upper_cst
= TREE_OPERAND (upper_op
, 1);
23831 if (!lower_cst_included
)
23833 = fold_build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
), lower_cst
,
23834 build_int_cst (TREE_TYPE (lower_cst
), 1));
23835 if (!upper_cst_included
)
23837 = fold_build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
), upper_cst
,
23838 build_int_cst (TREE_TYPE (upper_cst
), 1));
23840 if (!get_discr_value (lower_cst
,
23841 &new_node
->dw_discr_lower_bound
)
23842 || !get_discr_value (upper_cst
,
23843 &new_node
->dw_discr_upper_bound
))
23846 new_node
->dw_discr_range
= true;
23850 /* Unsupported sub-expression: we cannot determine the set of
23851 matching discriminant values. Abort everything. */
23854 /* If the discriminant info is not consistant with what we saw so
23855 far, consider the analysis failed and abort everything. */
23856 if (candidate_discr
== NULL_TREE
23857 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
23860 *discr_decl
= candidate_discr
;
23862 if (new_node
!= NULL
)
23864 new_node
->dw_discr_next
= discr_lists
[i
];
23865 discr_lists
[i
] = new_node
;
23867 match_expr
= next_round_match_expr
;
23871 /* If we reach this point, we could match everything we were interested
23876 /* Clean all data structure and return no result. */
23877 free (*discr_lists_p
);
23878 *discr_lists_p
= NULL
;
23879 *discr_decl
= NULL_TREE
;
23882 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
23883 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
23886 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
23887 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
23888 this type, which are record types, represent the available variants and each
23889 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
23890 values are inferred from these attributes.
23892 In trees, the offsets for the fields inside these sub-records are relative
23893 to the variant part itself, whereas the corresponding DIEs should have
23894 offset attributes that are relative to the embedding record base address.
23895 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
23896 must be an expression that computes the offset of the variant part to
23897 describe in DWARF. */
23900 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
23901 dw_die_ref context_die
)
23903 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
23904 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
23905 struct loc_descr_context ctx
= {
23906 vlr_ctx
->struct_type
, /* context_type */
23907 NULL_TREE
, /* base_decl */
23909 false, /* placeholder_arg */
23910 false /* placeholder_seen */
23913 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
23914 NULL_TREE if there is no such field. */
23915 tree discr_decl
= NULL_TREE
;
23916 dw_discr_list_ref
*discr_lists
;
23917 unsigned discr_lists_length
= 0;
23920 dw_die_ref dwarf_proc_die
= NULL
;
23921 dw_die_ref variant_part_die
23922 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
23924 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
23926 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
23927 &discr_decl
, &discr_lists
, &discr_lists_length
);
23929 if (discr_decl
!= NULL_TREE
)
23931 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
23934 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
23936 /* We have no DIE for the discriminant, so just discard all
23937 discrimimant information in the output. */
23938 discr_decl
= NULL_TREE
;
23941 /* If the offset for this variant part is more complex than a constant,
23942 create a DWARF procedure for it so that we will not have to generate DWARF
23943 expressions for it for each member. */
23944 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
23945 && (dwarf_version
>= 3 || !dwarf_strict
))
23947 const tree dwarf_proc_fndecl
23948 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
23949 build_function_type (TREE_TYPE (variant_part_offset
),
23951 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
23952 const dw_loc_descr_ref dwarf_proc_body
23953 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
23955 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
23956 dwarf_proc_fndecl
, context_die
);
23957 if (dwarf_proc_die
!= NULL
)
23958 variant_part_offset
= dwarf_proc_call
;
23961 /* Output DIEs for all variants. */
23963 for (tree variant
= TYPE_FIELDS (variant_part_type
);
23964 variant
!= NULL_TREE
;
23965 variant
= DECL_CHAIN (variant
), ++i
)
23967 tree variant_type
= TREE_TYPE (variant
);
23968 dw_die_ref variant_die
;
23970 /* All variants (i.e. members of a variant part) are supposed to be
23971 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
23972 under these records. */
23973 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
23975 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
23976 equate_decl_number_to_die (variant
, variant_die
);
23978 /* Output discriminant values this variant matches, if any. */
23979 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
23980 /* In the case we have discriminant information at all, this is
23981 probably the default variant: as the standard says, don't
23982 output any discriminant value/list attribute. */
23984 else if (discr_lists
[i
]->dw_discr_next
== NULL
23985 && !discr_lists
[i
]->dw_discr_range
)
23986 /* If there is only one accepted value, don't bother outputting a
23988 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
23990 add_discr_list (variant_die
, discr_lists
[i
]);
23992 for (tree member
= TYPE_FIELDS (variant_type
);
23993 member
!= NULL_TREE
;
23994 member
= DECL_CHAIN (member
))
23996 struct vlr_context vlr_sub_ctx
= {
23997 vlr_ctx
->struct_type
, /* struct_type */
23998 NULL
/* variant_part_offset */
24000 if (is_variant_part (member
))
24002 /* All offsets for fields inside variant parts are relative to
24003 the top-level embedding RECORD_TYPE's base address. On the
24004 other hand, offsets in GCC's types are relative to the
24005 nested-most variant part. So we have to sum offsets each time
24008 vlr_sub_ctx
.variant_part_offset
24009 = fold_build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
24010 variant_part_offset
, byte_position (member
));
24011 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
24015 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
24016 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
24021 free (discr_lists
);
24024 /* Generate a DIE for a class member. */
24027 gen_member_die (tree type
, dw_die_ref context_die
)
24030 tree binfo
= TYPE_BINFO (type
);
24032 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
24034 /* If this is not an incomplete type, output descriptions of each of its
24035 members. Note that as we output the DIEs necessary to represent the
24036 members of this record or union type, we will also be trying to output
24037 DIEs to represent the *types* of those members. However the `type'
24038 function (above) will specifically avoid generating type DIEs for member
24039 types *within* the list of member DIEs for this (containing) type except
24040 for those types (of members) which are explicitly marked as also being
24041 members of this (containing) type themselves. The g++ front- end can
24042 force any given type to be treated as a member of some other (containing)
24043 type by setting the TYPE_CONTEXT of the given (member) type to point to
24044 the TREE node representing the appropriate (containing) type. */
24046 /* First output info about the base classes. */
24049 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
24053 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
24054 gen_inheritance_die (base
,
24055 (accesses
? (*accesses
)[i
] : access_public_node
),
24060 /* Now output info about the data members and type members. */
24061 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
24063 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
24064 bool static_inline_p
24065 = (TREE_STATIC (member
)
24066 && (lang_hooks
.decls
.decl_dwarf_attribute (member
, DW_AT_inline
)
24069 /* Ignore clones. */
24070 if (DECL_ABSTRACT_ORIGIN (member
))
24073 /* If we thought we were generating minimal debug info for TYPE
24074 and then changed our minds, some of the member declarations
24075 may have already been defined. Don't define them again, but
24076 do put them in the right order. */
24078 if (dw_die_ref child
= lookup_decl_die (member
))
24080 /* Handle inline static data members, which only have in-class
24082 dw_die_ref ref
= NULL
;
24083 if (child
->die_tag
== DW_TAG_variable
24084 && child
->die_parent
== comp_unit_die ())
24086 ref
= get_AT_ref (child
, DW_AT_specification
);
24087 /* For C++17 inline static data members followed by redundant
24088 out of class redeclaration, we might get here with
24089 child being the DIE created for the out of class
24090 redeclaration and with its DW_AT_specification being
24091 the DIE created for in-class definition. We want to
24092 reparent the latter, and don't want to create another
24093 DIE with DW_AT_specification in that case, because
24094 we already have one. */
24097 && ref
->die_tag
== DW_TAG_variable
24098 && ref
->die_parent
== comp_unit_die ()
24099 && get_AT (ref
, DW_AT_specification
) == NULL
)
24103 static_inline_p
= false;
24107 if (child
->die_tag
== DW_TAG_variable
24108 && child
->die_parent
== comp_unit_die ()
24111 reparent_child (child
, context_die
);
24112 if (dwarf_version
< 5)
24113 child
->die_tag
= DW_TAG_member
;
24116 splice_child_die (context_die
, child
);
24119 /* Do not generate standard DWARF for variant parts if we are generating
24120 the corresponding GNAT encodings: DIEs generated for both would
24121 conflict in our mappings. */
24122 else if (is_variant_part (member
)
24123 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
)
24125 vlr_ctx
.variant_part_offset
= byte_position (member
);
24126 gen_variant_part (member
, &vlr_ctx
, context_die
);
24130 vlr_ctx
.variant_part_offset
= NULL_TREE
;
24131 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
24134 /* For C++ inline static data members emit immediately a DW_TAG_variable
24135 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
24136 DW_AT_specification. */
24137 if (static_inline_p
)
24139 int old_extern
= DECL_EXTERNAL (member
);
24140 DECL_EXTERNAL (member
) = 0;
24141 gen_decl_die (member
, NULL
, NULL
, comp_unit_die ());
24142 DECL_EXTERNAL (member
) = old_extern
;
24147 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
24148 is set, we pretend that the type was never defined, so we only get the
24149 member DIEs needed by later specification DIEs. */
24152 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
24153 enum debug_info_usage usage
)
24155 if (TREE_ASM_WRITTEN (type
))
24157 /* Fill in the bound of variable-length fields in late dwarf if
24158 still incomplete. */
24159 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
24160 for (tree member
= TYPE_FIELDS (type
);
24162 member
= DECL_CHAIN (member
))
24163 fill_variable_array_bounds (TREE_TYPE (member
));
24167 dw_die_ref type_die
= lookup_type_die (type
);
24168 dw_die_ref scope_die
= 0;
24170 int complete
= (TYPE_SIZE (type
)
24171 && (! TYPE_STUB_DECL (type
)
24172 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
24173 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
24174 complete
= complete
&& should_emit_struct_debug (type
, usage
);
24176 if (type_die
&& ! complete
)
24179 if (TYPE_CONTEXT (type
) != NULL_TREE
24180 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
24181 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
24184 scope_die
= scope_die_for (type
, context_die
);
24186 /* Generate child dies for template paramaters. */
24187 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
24188 schedule_generic_params_dies_gen (type
);
24190 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
24191 /* First occurrence of type or toplevel definition of nested class. */
24193 dw_die_ref old_die
= type_die
;
24195 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
24196 ? record_type_tag (type
) : DW_TAG_union_type
,
24198 equate_type_number_to_die (type
, type_die
);
24200 add_AT_specification (type_die
, old_die
);
24202 add_name_attribute (type_die
, type_tag (type
));
24205 remove_AT (type_die
, DW_AT_declaration
);
24207 /* If this type has been completed, then give it a byte_size attribute and
24208 then give a list of members. */
24209 if (complete
&& !ns_decl
)
24211 /* Prevent infinite recursion in cases where the type of some member of
24212 this type is expressed in terms of this type itself. */
24213 TREE_ASM_WRITTEN (type
) = 1;
24214 add_byte_size_attribute (type_die
, type
);
24215 add_alignment_attribute (type_die
, type
);
24216 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
24218 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
24219 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
24222 /* If the first reference to this type was as the return type of an
24223 inline function, then it may not have a parent. Fix this now. */
24224 if (type_die
->die_parent
== NULL
)
24225 add_child_die (scope_die
, type_die
);
24227 push_decl_scope (type
);
24228 gen_member_die (type
, type_die
);
24231 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
24232 if (TYPE_ARTIFICIAL (type
))
24233 add_AT_flag (type_die
, DW_AT_artificial
, 1);
24235 /* GNU extension: Record what type our vtable lives in. */
24236 if (TYPE_VFIELD (type
))
24238 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
24240 gen_type_die (vtype
, context_die
);
24241 add_AT_die_ref (type_die
, DW_AT_containing_type
,
24242 lookup_type_die (vtype
));
24247 add_AT_flag (type_die
, DW_AT_declaration
, 1);
24249 /* We don't need to do this for function-local types. */
24250 if (TYPE_STUB_DECL (type
)
24251 && ! decl_function_context (TYPE_STUB_DECL (type
)))
24252 vec_safe_push (incomplete_types
, type
);
24255 if (get_AT (type_die
, DW_AT_name
))
24256 add_pubtype (type
, type_die
);
24259 /* Generate a DIE for a subroutine _type_. */
24262 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
24264 tree return_type
= TREE_TYPE (type
);
24265 dw_die_ref subr_die
24266 = new_die (DW_TAG_subroutine_type
,
24267 scope_die_for (type
, context_die
), type
);
24269 equate_type_number_to_die (type
, subr_die
);
24270 add_prototyped_attribute (subr_die
, type
);
24271 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
24273 add_alignment_attribute (subr_die
, type
);
24274 gen_formal_types_die (type
, subr_die
);
24276 if (get_AT (subr_die
, DW_AT_name
))
24277 add_pubtype (type
, subr_die
);
24278 if ((dwarf_version
>= 5 || !dwarf_strict
)
24279 && lang_hooks
.types
.type_dwarf_attribute (type
, DW_AT_reference
) != -1)
24280 add_AT_flag (subr_die
, DW_AT_reference
, 1);
24281 if ((dwarf_version
>= 5 || !dwarf_strict
)
24282 && lang_hooks
.types
.type_dwarf_attribute (type
,
24283 DW_AT_rvalue_reference
) != -1)
24284 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
24287 /* Generate a DIE for a type definition. */
24290 gen_typedef_die (tree decl
, dw_die_ref context_die
)
24292 dw_die_ref type_die
;
24295 if (TREE_ASM_WRITTEN (decl
))
24297 if (DECL_ORIGINAL_TYPE (decl
))
24298 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
24302 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
24303 checks in process_scope_var and modified_type_die), this should be called
24304 only for original types. */
24305 gcc_assert (decl_ultimate_origin (decl
) == NULL
24306 || decl_ultimate_origin (decl
) == decl
);
24308 TREE_ASM_WRITTEN (decl
) = 1;
24309 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
24311 add_name_and_src_coords_attributes (type_die
, decl
);
24312 if (DECL_ORIGINAL_TYPE (decl
))
24314 type
= DECL_ORIGINAL_TYPE (decl
);
24315 if (type
== error_mark_node
)
24318 gcc_assert (type
!= TREE_TYPE (decl
));
24319 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
24323 type
= TREE_TYPE (decl
);
24324 if (type
== error_mark_node
)
24327 if (is_naming_typedef_decl (TYPE_NAME (type
)))
24329 /* Here, we are in the case of decl being a typedef naming
24330 an anonymous type, e.g:
24331 typedef struct {...} foo;
24332 In that case TREE_TYPE (decl) is not a typedef variant
24333 type and TYPE_NAME of the anonymous type is set to the
24334 TYPE_DECL of the typedef. This construct is emitted by
24337 TYPE is the anonymous struct named by the typedef
24338 DECL. As we need the DW_AT_type attribute of the
24339 DW_TAG_typedef to point to the DIE of TYPE, let's
24340 generate that DIE right away. add_type_attribute
24341 called below will then pick (via lookup_type_die) that
24342 anonymous struct DIE. */
24343 if (!TREE_ASM_WRITTEN (type
))
24344 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
24346 /* This is a GNU Extension. We are adding a
24347 DW_AT_linkage_name attribute to the DIE of the
24348 anonymous struct TYPE. The value of that attribute
24349 is the name of the typedef decl naming the anonymous
24350 struct. This greatly eases the work of consumers of
24351 this debug info. */
24352 add_linkage_name_raw (lookup_type_die (type
), decl
);
24356 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
24359 if (is_naming_typedef_decl (decl
))
24360 /* We want that all subsequent calls to lookup_type_die with
24361 TYPE in argument yield the DW_TAG_typedef we have just
24363 equate_type_number_to_die (type
, type_die
);
24365 add_alignment_attribute (type_die
, TREE_TYPE (decl
));
24367 add_accessibility_attribute (type_die
, decl
);
24369 if (DECL_ABSTRACT_P (decl
))
24370 equate_decl_number_to_die (decl
, type_die
);
24372 if (get_AT (type_die
, DW_AT_name
))
24373 add_pubtype (decl
, type_die
);
24376 /* Generate a DIE for a struct, class, enum or union type. */
24379 gen_tagged_type_die (tree type
,
24380 dw_die_ref context_die
,
24381 enum debug_info_usage usage
)
24385 if (type
== NULL_TREE
24386 || !is_tagged_type (type
))
24389 if (TREE_ASM_WRITTEN (type
))
24391 /* If this is a nested type whose containing class hasn't been written
24392 out yet, writing it out will cover this one, too. This does not apply
24393 to instantiations of member class templates; they need to be added to
24394 the containing class as they are generated. FIXME: This hurts the
24395 idea of combining type decls from multiple TUs, since we can't predict
24396 what set of template instantiations we'll get. */
24397 else if (TYPE_CONTEXT (type
)
24398 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
24399 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
24401 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
24403 if (TREE_ASM_WRITTEN (type
))
24406 /* If that failed, attach ourselves to the stub. */
24407 push_decl_scope (TYPE_CONTEXT (type
));
24408 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
24411 else if (TYPE_CONTEXT (type
) != NULL_TREE
24412 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
24414 /* If this type is local to a function that hasn't been written
24415 out yet, use a NULL context for now; it will be fixed up in
24416 decls_for_scope. */
24417 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
24418 /* A declaration DIE doesn't count; nested types need to go in the
24420 if (context_die
&& is_declaration_die (context_die
))
24421 context_die
= NULL
;
24426 context_die
= declare_in_namespace (type
, context_die
);
24430 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
24432 /* This might have been written out by the call to
24433 declare_in_namespace. */
24434 if (!TREE_ASM_WRITTEN (type
))
24435 gen_enumeration_type_die (type
, context_die
);
24438 gen_struct_or_union_type_die (type
, context_die
, usage
);
24443 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
24444 it up if it is ever completed. gen_*_type_die will set it for us
24445 when appropriate. */
24448 /* Generate a type description DIE. */
24451 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
24452 enum debug_info_usage usage
)
24454 struct array_descr_info info
;
24456 if (type
== NULL_TREE
|| type
== error_mark_node
)
24459 if (flag_checking
&& type
)
24460 verify_type (type
);
24462 if (TYPE_NAME (type
) != NULL_TREE
24463 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
24464 && is_redundant_typedef (TYPE_NAME (type
))
24465 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
24466 /* The DECL of this type is a typedef we don't want to emit debug
24467 info for but we want debug info for its underlying typedef.
24468 This can happen for e.g, the injected-class-name of a C++
24470 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
24472 /* If TYPE is a typedef type variant, let's generate debug info
24473 for the parent typedef which TYPE is a type of. */
24474 if (typedef_variant_p (type
))
24476 if (TREE_ASM_WRITTEN (type
))
24479 tree name
= TYPE_NAME (type
);
24480 tree origin
= decl_ultimate_origin (name
);
24481 if (origin
!= NULL
&& origin
!= name
)
24483 gen_decl_die (origin
, NULL
, NULL
, context_die
);
24487 /* Prevent broken recursion; we can't hand off to the same type. */
24488 gcc_assert (DECL_ORIGINAL_TYPE (name
) != type
);
24490 /* Give typedefs the right scope. */
24491 context_die
= scope_die_for (type
, context_die
);
24493 TREE_ASM_WRITTEN (type
) = 1;
24495 gen_decl_die (name
, NULL
, NULL
, context_die
);
24499 /* If type is an anonymous tagged type named by a typedef, let's
24500 generate debug info for the typedef. */
24501 if (is_naming_typedef_decl (TYPE_NAME (type
)))
24503 /* Use the DIE of the containing namespace as the parent DIE of
24504 the type description DIE we want to generate. */
24505 if (DECL_CONTEXT (TYPE_NAME (type
))
24506 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
24507 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
24509 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
24513 if (lang_hooks
.types
.get_debug_type
)
24515 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
24517 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
24519 gen_type_die_with_usage (debug_type
, context_die
, usage
);
24524 /* We are going to output a DIE to represent the unqualified version
24525 of this type (i.e. without any const or volatile qualifiers) so
24526 get the main variant (i.e. the unqualified version) of this type
24527 now. (Vectors and arrays are special because the debugging info is in the
24528 cloned type itself. Similarly function/method types can contain extra
24529 ref-qualification). */
24530 if (TREE_CODE (type
) == FUNCTION_TYPE
24531 || TREE_CODE (type
) == METHOD_TYPE
)
24533 /* For function/method types, can't use type_main_variant here,
24534 because that can have different ref-qualifiers for C++,
24535 but try to canonicalize. */
24536 tree main
= TYPE_MAIN_VARIANT (type
);
24537 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
24538 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
24539 && check_base_type (t
, main
)
24540 && check_lang_type (t
, type
))
24546 else if (TREE_CODE (type
) != VECTOR_TYPE
24547 && TREE_CODE (type
) != ARRAY_TYPE
)
24548 type
= type_main_variant (type
);
24550 /* If this is an array type with hidden descriptor, handle it first. */
24551 if (!TREE_ASM_WRITTEN (type
)
24552 && lang_hooks
.types
.get_array_descr_info
)
24554 memset (&info
, 0, sizeof (info
));
24555 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
24557 /* Fortran sometimes emits array types with no dimension. */
24558 gcc_assert (info
.ndimensions
>= 0
24559 && (info
.ndimensions
24560 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
24561 gen_descr_array_type_die (type
, &info
, context_die
);
24562 TREE_ASM_WRITTEN (type
) = 1;
24567 if (TREE_ASM_WRITTEN (type
))
24569 /* Variable-length types may be incomplete even if
24570 TREE_ASM_WRITTEN. For such types, fall through to
24571 gen_array_type_die() and possibly fill in
24572 DW_AT_{upper,lower}_bound attributes. */
24573 if ((TREE_CODE (type
) != ARRAY_TYPE
24574 && TREE_CODE (type
) != RECORD_TYPE
24575 && TREE_CODE (type
) != UNION_TYPE
24576 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
24577 || !variably_modified_type_p (type
, NULL
))
24581 switch (TREE_CODE (type
))
24587 case REFERENCE_TYPE
:
24588 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
24589 ensures that the gen_type_die recursion will terminate even if the
24590 type is recursive. Recursive types are possible in Ada. */
24591 /* ??? We could perhaps do this for all types before the switch
24593 TREE_ASM_WRITTEN (type
) = 1;
24595 /* For these types, all that is required is that we output a DIE (or a
24596 set of DIEs) to represent the "basis" type. */
24597 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
24598 DINFO_USAGE_IND_USE
);
24602 /* This code is used for C++ pointer-to-data-member types.
24603 Output a description of the relevant class type. */
24604 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
24605 DINFO_USAGE_IND_USE
);
24607 /* Output a description of the type of the object pointed to. */
24608 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
24609 DINFO_USAGE_IND_USE
);
24611 /* Now output a DIE to represent this pointer-to-data-member type
24613 gen_ptr_to_mbr_type_die (type
, context_die
);
24616 case FUNCTION_TYPE
:
24617 /* Force out return type (in case it wasn't forced out already). */
24618 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
24619 DINFO_USAGE_DIR_USE
);
24620 gen_subroutine_type_die (type
, context_die
);
24624 /* Force out return type (in case it wasn't forced out already). */
24625 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
24626 DINFO_USAGE_DIR_USE
);
24627 gen_subroutine_type_die (type
, context_die
);
24632 gen_array_type_die (type
, context_die
);
24635 case ENUMERAL_TYPE
:
24638 case QUAL_UNION_TYPE
:
24639 gen_tagged_type_die (type
, context_die
, usage
);
24645 case FIXED_POINT_TYPE
:
24648 case POINTER_BOUNDS_TYPE
:
24649 /* No DIEs needed for fundamental types. */
24654 /* Just use DW_TAG_unspecified_type. */
24656 dw_die_ref type_die
= lookup_type_die (type
);
24657 if (type_die
== NULL
)
24659 tree name
= TYPE_IDENTIFIER (type
);
24660 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
24662 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
24663 equate_type_number_to_die (type
, type_die
);
24669 if (is_cxx_auto (type
))
24671 tree name
= TYPE_IDENTIFIER (type
);
24672 dw_die_ref
*die
= (name
== get_identifier ("auto")
24673 ? &auto_die
: &decltype_auto_die
);
24676 *die
= new_die (DW_TAG_unspecified_type
,
24677 comp_unit_die (), NULL_TREE
);
24678 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
24680 equate_type_number_to_die (type
, *die
);
24683 gcc_unreachable ();
24686 TREE_ASM_WRITTEN (type
) = 1;
24690 gen_type_die (tree type
, dw_die_ref context_die
)
24692 if (type
!= error_mark_node
)
24694 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
24697 dw_die_ref die
= lookup_type_die (type
);
24704 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
24705 things which are local to the given block. */
24708 gen_block_die (tree stmt
, dw_die_ref context_die
)
24710 int must_output_die
= 0;
24713 /* Ignore blocks that are NULL. */
24714 if (stmt
== NULL_TREE
)
24717 inlined_func
= inlined_function_outer_scope_p (stmt
);
24719 /* If the block is one fragment of a non-contiguous block, do not
24720 process the variables, since they will have been done by the
24721 origin block. Do process subblocks. */
24722 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
24726 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
24727 gen_block_die (sub
, context_die
);
24732 /* Determine if we need to output any Dwarf DIEs at all to represent this
24735 /* The outer scopes for inlinings *must* always be represented. We
24736 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
24737 must_output_die
= 1;
24740 /* Determine if this block directly contains any "significant"
24741 local declarations which we will need to output DIEs for. */
24742 if (debug_info_level
> DINFO_LEVEL_TERSE
)
24743 /* We are not in terse mode so *any* local declaration counts
24744 as being a "significant" one. */
24745 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
24746 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
24747 && (TREE_USED (stmt
)
24748 || TREE_ASM_WRITTEN (stmt
)
24749 || BLOCK_ABSTRACT (stmt
)));
24750 else if ((TREE_USED (stmt
)
24751 || TREE_ASM_WRITTEN (stmt
)
24752 || BLOCK_ABSTRACT (stmt
))
24753 && !dwarf2out_ignore_block (stmt
))
24754 must_output_die
= 1;
24757 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
24758 DIE for any block which contains no significant local declarations at
24759 all. Rather, in such cases we just call `decls_for_scope' so that any
24760 needed Dwarf info for any sub-blocks will get properly generated. Note
24761 that in terse mode, our definition of what constitutes a "significant"
24762 local declaration gets restricted to include only inlined function
24763 instances and local (nested) function definitions. */
24764 if (must_output_die
)
24768 /* If STMT block is abstract, that means we have been called
24769 indirectly from dwarf2out_abstract_function.
24770 That function rightfully marks the descendent blocks (of
24771 the abstract function it is dealing with) as being abstract,
24772 precisely to prevent us from emitting any
24773 DW_TAG_inlined_subroutine DIE as a descendent
24774 of an abstract function instance. So in that case, we should
24775 not call gen_inlined_subroutine_die.
24777 Later though, when cgraph asks dwarf2out to emit info
24778 for the concrete instance of the function decl into which
24779 the concrete instance of STMT got inlined, the later will lead
24780 to the generation of a DW_TAG_inlined_subroutine DIE. */
24781 if (! BLOCK_ABSTRACT (stmt
))
24782 gen_inlined_subroutine_die (stmt
, context_die
);
24785 gen_lexical_block_die (stmt
, context_die
);
24788 decls_for_scope (stmt
, context_die
);
24791 /* Process variable DECL (or variable with origin ORIGIN) within
24792 block STMT and add it to CONTEXT_DIE. */
24794 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
24797 tree decl_or_origin
= decl
? decl
: origin
;
24799 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
24800 die
= lookup_decl_die (decl_or_origin
);
24801 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
)
24803 if (TYPE_DECL_IS_STUB (decl_or_origin
))
24804 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
24806 die
= lookup_decl_die (decl_or_origin
);
24807 /* Avoid re-creating the DIE late if it was optimized as unused early. */
24808 if (! die
&& ! early_dwarf
)
24814 /* Avoid creating DIEs for local typedefs and concrete static variables that
24815 will only be pruned later. */
24816 if ((origin
|| decl_ultimate_origin (decl
))
24817 && (TREE_CODE (decl_or_origin
) == TYPE_DECL
24818 || (VAR_P (decl_or_origin
) && TREE_STATIC (decl_or_origin
))))
24820 origin
= decl_ultimate_origin (decl_or_origin
);
24821 if (decl
&& VAR_P (decl
) && die
!= NULL
)
24823 die
= lookup_decl_die (origin
);
24825 equate_decl_number_to_die (decl
, die
);
24830 if (die
!= NULL
&& die
->die_parent
== NULL
)
24831 add_child_die (context_die
, die
);
24832 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
24835 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
24836 stmt
, context_die
);
24840 if (decl
&& DECL_P (decl
))
24842 die
= lookup_decl_die (decl
);
24844 /* Early created DIEs do not have a parent as the decls refer
24845 to the function as DECL_CONTEXT rather than the BLOCK. */
24846 if (die
&& die
->die_parent
== NULL
)
24848 gcc_assert (in_lto_p
);
24849 add_child_die (context_die
, die
);
24853 gen_decl_die (decl
, origin
, NULL
, context_die
);
24857 /* Generate all of the decls declared within a given scope and (recursively)
24858 all of its sub-blocks. */
24861 decls_for_scope (tree stmt
, dw_die_ref context_die
)
24867 /* Ignore NULL blocks. */
24868 if (stmt
== NULL_TREE
)
24871 /* Output the DIEs to represent all of the data objects and typedefs
24872 declared directly within this block but not within any nested
24873 sub-blocks. Also, nested function and tag DIEs have been
24874 generated with a parent of NULL; fix that up now. We don't
24875 have to do this if we're at -g1. */
24876 if (debug_info_level
> DINFO_LEVEL_TERSE
)
24878 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
24879 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
24880 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
24881 origin - avoid doing this twice as we have no good way to see
24882 if we've done it once already. */
24884 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
24886 decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
24887 if (decl
== current_function_decl
)
24888 /* Ignore declarations of the current function, while they
24889 are declarations, gen_subprogram_die would treat them
24890 as definitions again, because they are equal to
24891 current_function_decl and endlessly recurse. */;
24892 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
24893 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
24895 process_scope_var (stmt
, NULL_TREE
, decl
, context_die
);
24899 /* Even if we're at -g1, we need to process the subblocks in order to get
24900 inlined call information. */
24902 /* Output the DIEs to represent all sub-blocks (and the items declared
24903 therein) of this block. */
24904 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
24906 subblocks
= BLOCK_CHAIN (subblocks
))
24907 gen_block_die (subblocks
, context_die
);
24910 /* Is this a typedef we can avoid emitting? */
24913 is_redundant_typedef (const_tree decl
)
24915 if (TYPE_DECL_IS_STUB (decl
))
24918 if (DECL_ARTIFICIAL (decl
)
24919 && DECL_CONTEXT (decl
)
24920 && is_tagged_type (DECL_CONTEXT (decl
))
24921 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
24922 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
24923 /* Also ignore the artificial member typedef for the class name. */
24929 /* Return TRUE if TYPE is a typedef that names a type for linkage
24930 purposes. This kind of typedefs is produced by the C++ FE for
24933 typedef struct {...} foo;
24935 In that case, there is no typedef variant type produced for foo.
24936 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
24940 is_naming_typedef_decl (const_tree decl
)
24942 if (decl
== NULL_TREE
24943 || TREE_CODE (decl
) != TYPE_DECL
24944 || DECL_NAMELESS (decl
)
24945 || !is_tagged_type (TREE_TYPE (decl
))
24946 || DECL_IS_BUILTIN (decl
)
24947 || is_redundant_typedef (decl
)
24948 /* It looks like Ada produces TYPE_DECLs that are very similar
24949 to C++ naming typedefs but that have different
24950 semantics. Let's be specific to c++ for now. */
24954 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
24955 && TYPE_NAME (TREE_TYPE (decl
)) == decl
24956 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
24957 != TYPE_NAME (TREE_TYPE (decl
))));
24960 /* Looks up the DIE for a context. */
24962 static inline dw_die_ref
24963 lookup_context_die (tree context
)
24967 /* Find die that represents this context. */
24968 if (TYPE_P (context
))
24970 context
= TYPE_MAIN_VARIANT (context
);
24971 dw_die_ref ctx
= lookup_type_die (context
);
24974 return strip_naming_typedef (context
, ctx
);
24977 return lookup_decl_die (context
);
24979 return comp_unit_die ();
24982 /* Returns the DIE for a context. */
24984 static inline dw_die_ref
24985 get_context_die (tree context
)
24989 /* Find die that represents this context. */
24990 if (TYPE_P (context
))
24992 context
= TYPE_MAIN_VARIANT (context
);
24993 return strip_naming_typedef (context
, force_type_die (context
));
24996 return force_decl_die (context
);
24998 return comp_unit_die ();
25001 /* Returns the DIE for decl. A DIE will always be returned. */
25004 force_decl_die (tree decl
)
25006 dw_die_ref decl_die
;
25007 unsigned saved_external_flag
;
25008 tree save_fn
= NULL_TREE
;
25009 decl_die
= lookup_decl_die (decl
);
25012 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
25014 decl_die
= lookup_decl_die (decl
);
25018 switch (TREE_CODE (decl
))
25020 case FUNCTION_DECL
:
25021 /* Clear current_function_decl, so that gen_subprogram_die thinks
25022 that this is a declaration. At this point, we just want to force
25023 declaration die. */
25024 save_fn
= current_function_decl
;
25025 current_function_decl
= NULL_TREE
;
25026 gen_subprogram_die (decl
, context_die
);
25027 current_function_decl
= save_fn
;
25031 /* Set external flag to force declaration die. Restore it after
25032 gen_decl_die() call. */
25033 saved_external_flag
= DECL_EXTERNAL (decl
);
25034 DECL_EXTERNAL (decl
) = 1;
25035 gen_decl_die (decl
, NULL
, NULL
, context_die
);
25036 DECL_EXTERNAL (decl
) = saved_external_flag
;
25039 case NAMESPACE_DECL
:
25040 if (dwarf_version
>= 3 || !dwarf_strict
)
25041 dwarf2out_decl (decl
);
25043 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
25044 decl_die
= comp_unit_die ();
25047 case TRANSLATION_UNIT_DECL
:
25048 decl_die
= comp_unit_die ();
25052 gcc_unreachable ();
25055 /* We should be able to find the DIE now. */
25057 decl_die
= lookup_decl_die (decl
);
25058 gcc_assert (decl_die
);
25064 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
25065 always returned. */
25068 force_type_die (tree type
)
25070 dw_die_ref type_die
;
25072 type_die
= lookup_type_die (type
);
25075 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
25077 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
25078 false, context_die
);
25079 gcc_assert (type_die
);
25084 /* Force out any required namespaces to be able to output DECL,
25085 and return the new context_die for it, if it's changed. */
25088 setup_namespace_context (tree thing
, dw_die_ref context_die
)
25090 tree context
= (DECL_P (thing
)
25091 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
25092 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
25093 /* Force out the namespace. */
25094 context_die
= force_decl_die (context
);
25096 return context_die
;
25099 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
25100 type) within its namespace, if appropriate.
25102 For compatibility with older debuggers, namespace DIEs only contain
25103 declarations; all definitions are emitted at CU scope, with
25104 DW_AT_specification pointing to the declaration (like with class
25108 declare_in_namespace (tree thing
, dw_die_ref context_die
)
25110 dw_die_ref ns_context
;
25112 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25113 return context_die
;
25115 /* External declarations in the local scope only need to be emitted
25116 once, not once in the namespace and once in the scope.
25118 This avoids declaring the `extern' below in the
25119 namespace DIE as well as in the innermost scope:
25132 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
25133 return context_die
;
25135 /* If this decl is from an inlined function, then don't try to emit it in its
25136 namespace, as we will get confused. It would have already been emitted
25137 when the abstract instance of the inline function was emitted anyways. */
25138 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
25139 return context_die
;
25141 ns_context
= setup_namespace_context (thing
, context_die
);
25143 if (ns_context
!= context_die
)
25147 if (DECL_P (thing
))
25148 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
25150 gen_type_die (thing
, ns_context
);
25152 return context_die
;
25155 /* Generate a DIE for a namespace or namespace alias. */
25158 gen_namespace_die (tree decl
, dw_die_ref context_die
)
25160 dw_die_ref namespace_die
;
25162 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
25163 they are an alias of. */
25164 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
25166 /* Output a real namespace or module. */
25167 context_die
= setup_namespace_context (decl
, comp_unit_die ());
25168 namespace_die
= new_die (is_fortran ()
25169 ? DW_TAG_module
: DW_TAG_namespace
,
25170 context_die
, decl
);
25171 /* For Fortran modules defined in different CU don't add src coords. */
25172 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
25174 const char *name
= dwarf2_name (decl
, 0);
25176 add_name_attribute (namespace_die
, name
);
25179 add_name_and_src_coords_attributes (namespace_die
, decl
);
25180 if (DECL_EXTERNAL (decl
))
25181 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
25182 equate_decl_number_to_die (decl
, namespace_die
);
25186 /* Output a namespace alias. */
25188 /* Force out the namespace we are an alias of, if necessary. */
25189 dw_die_ref origin_die
25190 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
25192 if (DECL_FILE_SCOPE_P (decl
)
25193 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
25194 context_die
= setup_namespace_context (decl
, comp_unit_die ());
25195 /* Now create the namespace alias DIE. */
25196 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
25197 add_name_and_src_coords_attributes (namespace_die
, decl
);
25198 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
25199 equate_decl_number_to_die (decl
, namespace_die
);
25201 if ((dwarf_version
>= 5 || !dwarf_strict
)
25202 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
25203 DW_AT_export_symbols
) == 1)
25204 add_AT_flag (namespace_die
, DW_AT_export_symbols
, 1);
25206 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
25207 if (want_pubnames ())
25208 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
25211 /* Generate Dwarf debug information for a decl described by DECL.
25212 The return value is currently only meaningful for PARM_DECLs,
25213 for all other decls it returns NULL.
25215 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
25216 It can be NULL otherwise. */
25219 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
25220 dw_die_ref context_die
)
25222 tree decl_or_origin
= decl
? decl
: origin
;
25223 tree class_origin
= NULL
, ultimate_origin
;
25225 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
25228 /* Ignore pointer bounds decls. */
25229 if (DECL_P (decl_or_origin
)
25230 && TREE_TYPE (decl_or_origin
)
25231 && POINTER_BOUNDS_P (decl_or_origin
))
25234 switch (TREE_CODE (decl_or_origin
))
25240 if (!is_fortran () && !is_ada ())
25242 /* The individual enumerators of an enum type get output when we output
25243 the Dwarf representation of the relevant enum type itself. */
25247 /* Emit its type. */
25248 gen_type_die (TREE_TYPE (decl
), context_die
);
25250 /* And its containing namespace. */
25251 context_die
= declare_in_namespace (decl
, context_die
);
25253 gen_const_die (decl
, context_die
);
25256 case FUNCTION_DECL
:
25259 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
25260 on local redeclarations of global functions. That seems broken. */
25261 if (current_function_decl
!= decl
)
25262 /* This is only a declaration. */;
25265 /* We should have abstract copies already and should not generate
25266 stray type DIEs in late LTO dumping. */
25270 /* If we're emitting a clone, emit info for the abstract instance. */
25271 else if (origin
|| DECL_ORIGIN (decl
) != decl
)
25272 dwarf2out_abstract_function (origin
25273 ? DECL_ORIGIN (origin
)
25274 : DECL_ABSTRACT_ORIGIN (decl
));
25276 /* If we're emitting a possibly inlined function emit it as
25277 abstract instance. */
25278 else if (cgraph_function_possibly_inlined_p (decl
)
25279 && ! DECL_ABSTRACT_P (decl
)
25280 && ! class_or_namespace_scope_p (context_die
)
25281 /* dwarf2out_abstract_function won't emit a die if this is just
25282 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
25283 that case, because that works only if we have a die. */
25284 && DECL_INITIAL (decl
) != NULL_TREE
)
25285 dwarf2out_abstract_function (decl
);
25287 /* Otherwise we're emitting the primary DIE for this decl. */
25288 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
25290 /* Before we describe the FUNCTION_DECL itself, make sure that we
25291 have its containing type. */
25293 origin
= decl_class_context (decl
);
25294 if (origin
!= NULL_TREE
)
25295 gen_type_die (origin
, context_die
);
25297 /* And its return type. */
25298 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
25300 /* And its virtual context. */
25301 if (DECL_VINDEX (decl
) != NULL_TREE
)
25302 gen_type_die (DECL_CONTEXT (decl
), context_die
);
25304 /* Make sure we have a member DIE for decl. */
25305 if (origin
!= NULL_TREE
)
25306 gen_type_die_for_member (origin
, decl
, context_die
);
25308 /* And its containing namespace. */
25309 context_die
= declare_in_namespace (decl
, context_die
);
25312 /* Now output a DIE to represent the function itself. */
25314 gen_subprogram_die (decl
, context_die
);
25318 /* If we are in terse mode, don't generate any DIEs to represent any
25319 actual typedefs. */
25320 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25323 /* In the special case of a TYPE_DECL node representing the declaration
25324 of some type tag, if the given TYPE_DECL is marked as having been
25325 instantiated from some other (original) TYPE_DECL node (e.g. one which
25326 was generated within the original definition of an inline function) we
25327 used to generate a special (abbreviated) DW_TAG_structure_type,
25328 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
25329 should be actually referencing those DIEs, as variable DIEs with that
25330 type would be emitted already in the abstract origin, so it was always
25331 removed during unused type prunning. Don't add anything in this
25333 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
25336 if (is_redundant_typedef (decl
))
25337 gen_type_die (TREE_TYPE (decl
), context_die
);
25339 /* Output a DIE to represent the typedef itself. */
25340 gen_typedef_die (decl
, context_die
);
25344 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
25345 gen_label_die (decl
, context_die
);
25350 /* If we are in terse mode, don't generate any DIEs to represent any
25351 variable declarations or definitions. */
25352 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25355 /* Avoid generating stray type DIEs during late dwarf dumping.
25356 All types have been dumped early. */
25358 /* ??? But in LTRANS we cannot annotate early created variably
25359 modified type DIEs without copying them and adjusting all
25360 references to them. Dump them again as happens for inlining
25361 which copies both the decl and the types. */
25362 /* ??? And even non-LTO needs to re-visit type DIEs to fill
25363 in VLA bound information for example. */
25364 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
25365 current_function_decl
)))
25367 /* Output any DIEs that are needed to specify the type of this data
25369 if (decl_by_reference_p (decl_or_origin
))
25370 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
25372 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
25377 /* And its containing type. */
25378 class_origin
= decl_class_context (decl_or_origin
);
25379 if (class_origin
!= NULL_TREE
)
25380 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
25382 /* And its containing namespace. */
25383 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
25386 /* Now output the DIE to represent the data object itself. This gets
25387 complicated because of the possibility that the VAR_DECL really
25388 represents an inlined instance of a formal parameter for an inline
25390 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
25391 if (ultimate_origin
!= NULL_TREE
25392 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
25393 gen_formal_parameter_die (decl
, origin
,
25394 true /* Emit name attribute. */,
25397 gen_variable_die (decl
, origin
, context_die
);
25401 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
25402 /* Ignore the nameless fields that are used to skip bits but handle C++
25403 anonymous unions and structs. */
25404 if (DECL_NAME (decl
) != NULL_TREE
25405 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
25406 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
25408 gen_type_die (member_declared_type (decl
), context_die
);
25409 gen_field_die (decl
, ctx
, context_die
);
25414 /* Avoid generating stray type DIEs during late dwarf dumping.
25415 All types have been dumped early. */
25417 /* ??? But in LTRANS we cannot annotate early created variably
25418 modified type DIEs without copying them and adjusting all
25419 references to them. Dump them again as happens for inlining
25420 which copies both the decl and the types. */
25421 /* ??? And even non-LTO needs to re-visit type DIEs to fill
25422 in VLA bound information for example. */
25423 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
25424 current_function_decl
)))
25426 if (DECL_BY_REFERENCE (decl_or_origin
))
25427 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
25429 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
25431 return gen_formal_parameter_die (decl
, origin
,
25432 true /* Emit name attribute. */,
25435 case NAMESPACE_DECL
:
25436 if (dwarf_version
>= 3 || !dwarf_strict
)
25437 gen_namespace_die (decl
, context_die
);
25440 case IMPORTED_DECL
:
25441 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
25442 DECL_CONTEXT (decl
), context_die
);
25445 case NAMELIST_DECL
:
25446 gen_namelist_decl (DECL_NAME (decl
), context_die
,
25447 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
25451 /* Probably some frontend-internal decl. Assume we don't care. */
25452 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
25459 /* Output initial debug information for global DECL. Called at the
25460 end of the parsing process.
25462 This is the initial debug generation process. As such, the DIEs
25463 generated may be incomplete. A later debug generation pass
25464 (dwarf2out_late_global_decl) will augment the information generated
25465 in this pass (e.g., with complete location info). */
25468 dwarf2out_early_global_decl (tree decl
)
25472 /* gen_decl_die() will set DECL_ABSTRACT because
25473 cgraph_function_possibly_inlined_p() returns true. This is in
25474 turn will cause DW_AT_inline attributes to be set.
25476 This happens because at early dwarf generation, there is no
25477 cgraph information, causing cgraph_function_possibly_inlined_p()
25478 to return true. Trick cgraph_function_possibly_inlined_p()
25479 while we generate dwarf early. */
25480 bool save
= symtab
->global_info_ready
;
25481 symtab
->global_info_ready
= true;
25483 /* We don't handle TYPE_DECLs. If required, they'll be reached via
25484 other DECLs and they can point to template types or other things
25485 that dwarf2out can't handle when done via dwarf2out_decl. */
25486 if (TREE_CODE (decl
) != TYPE_DECL
25487 && TREE_CODE (decl
) != PARM_DECL
)
25489 tree save_fndecl
= current_function_decl
;
25490 if (TREE_CODE (decl
) == FUNCTION_DECL
)
25492 /* For nested functions, make sure we have DIEs for the parents first
25493 so that all nested DIEs are generated at the proper scope in the
25495 tree context
= decl_function_context (decl
);
25496 if (context
!= NULL
&& lookup_decl_die (context
) == NULL
)
25498 current_function_decl
= context
;
25499 dwarf2out_decl (context
);
25502 /* Emit an abstract origin of a function first. This happens
25503 with C++ constructor clones for example and makes
25504 dwarf2out_abstract_function happy which requires the early
25505 DIE of the abstract instance to be present. */
25506 tree origin
= DECL_ABSTRACT_ORIGIN (decl
);
25507 dw_die_ref origin_die
;
25509 /* Do not emit the DIE multiple times but make sure to
25510 process it fully here in case we just saw a declaration. */
25511 && ((origin_die
= lookup_decl_die (origin
)) == NULL
25512 || is_declaration_die (origin_die
)))
25514 current_function_decl
= origin
;
25515 dwarf2out_decl (origin
);
25518 current_function_decl
= decl
;
25520 dwarf2out_decl (decl
);
25521 if (TREE_CODE (decl
) == FUNCTION_DECL
)
25522 current_function_decl
= save_fndecl
;
25524 symtab
->global_info_ready
= save
;
25527 /* Output debug information for global decl DECL. Called from
25528 toplev.c after compilation proper has finished. */
25531 dwarf2out_late_global_decl (tree decl
)
25533 /* Fill-in any location information we were unable to determine
25534 on the first pass. */
25535 if (VAR_P (decl
) && !POINTER_BOUNDS_P (decl
))
25537 dw_die_ref die
= lookup_decl_die (decl
);
25539 /* We may have to generate early debug late for LTO in case debug
25540 was not enabled at compile-time or the target doesn't support
25541 the LTO early debug scheme. */
25542 if (! die
&& in_lto_p
)
25544 dwarf2out_decl (decl
);
25545 die
= lookup_decl_die (decl
);
25550 /* We get called via the symtab code invoking late_global_decl
25551 for symbols that are optimized out. Do not add locations
25552 for those, except if they have a DECL_VALUE_EXPR, in which case
25553 they are relevant for debuggers. */
25554 varpool_node
*node
= varpool_node::get (decl
);
25555 if ((! node
|| ! node
->definition
) && ! DECL_HAS_VALUE_EXPR_P (decl
))
25556 tree_add_const_value_attribute_for_decl (die
, decl
);
25558 add_location_or_const_value_attribute (die
, decl
, false);
25563 /* Output debug information for type decl DECL. Called from toplev.c
25564 and from language front ends (to record built-in types). */
25566 dwarf2out_type_decl (tree decl
, int local
)
25571 dwarf2out_decl (decl
);
25575 /* Output debug information for imported module or decl DECL.
25576 NAME is non-NULL name in the lexical block if the decl has been renamed.
25577 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
25578 that DECL belongs to.
25579 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
25581 dwarf2out_imported_module_or_decl_1 (tree decl
,
25583 tree lexical_block
,
25584 dw_die_ref lexical_block_die
)
25586 expanded_location xloc
;
25587 dw_die_ref imported_die
= NULL
;
25588 dw_die_ref at_import_die
;
25590 if (TREE_CODE (decl
) == IMPORTED_DECL
)
25592 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
25593 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
25597 xloc
= expand_location (input_location
);
25599 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
25601 at_import_die
= force_type_die (TREE_TYPE (decl
));
25602 /* For namespace N { typedef void T; } using N::T; base_type_die
25603 returns NULL, but DW_TAG_imported_declaration requires
25604 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
25605 if (!at_import_die
)
25607 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
25608 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
25609 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
25610 gcc_assert (at_import_die
);
25615 at_import_die
= lookup_decl_die (decl
);
25616 if (!at_import_die
)
25618 /* If we're trying to avoid duplicate debug info, we may not have
25619 emitted the member decl for this field. Emit it now. */
25620 if (TREE_CODE (decl
) == FIELD_DECL
)
25622 tree type
= DECL_CONTEXT (decl
);
25624 if (TYPE_CONTEXT (type
)
25625 && TYPE_P (TYPE_CONTEXT (type
))
25626 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
25627 DINFO_USAGE_DIR_USE
))
25629 gen_type_die_for_member (type
, decl
,
25630 get_context_die (TYPE_CONTEXT (type
)));
25632 if (TREE_CODE (decl
) == NAMELIST_DECL
)
25633 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
25634 get_context_die (DECL_CONTEXT (decl
)),
25637 at_import_die
= force_decl_die (decl
);
25641 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
25643 if (dwarf_version
>= 3 || !dwarf_strict
)
25644 imported_die
= new_die (DW_TAG_imported_module
,
25651 imported_die
= new_die (DW_TAG_imported_declaration
,
25655 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
25656 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
25657 if (debug_column_info
&& xloc
.column
)
25658 add_AT_unsigned (imported_die
, DW_AT_decl_column
, xloc
.column
);
25660 add_AT_string (imported_die
, DW_AT_name
,
25661 IDENTIFIER_POINTER (name
));
25662 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
25665 /* Output debug information for imported module or decl DECL.
25666 NAME is non-NULL name in context if the decl has been renamed.
25667 CHILD is true if decl is one of the renamed decls as part of
25668 importing whole module.
25669 IMPLICIT is set if this hook is called for an implicit import
25670 such as inline namespace. */
25673 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
25674 bool child
, bool implicit
)
25676 /* dw_die_ref at_import_die; */
25677 dw_die_ref scope_die
;
25679 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25684 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
25685 should be enough, for DWARF4 and older even if we emit as extension
25686 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
25687 for the benefit of consumers unaware of DW_AT_export_symbols. */
25689 && dwarf_version
>= 5
25690 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
25691 DW_AT_export_symbols
) == 1)
25696 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
25697 We need decl DIE for reference and scope die. First, get DIE for the decl
25700 /* Get the scope die for decl context. Use comp_unit_die for global module
25701 or decl. If die is not found for non globals, force new die. */
25703 && TYPE_P (context
)
25704 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
25707 scope_die
= get_context_die (context
);
25711 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
25712 there is nothing we can do, here. */
25713 if (dwarf_version
< 3 && dwarf_strict
)
25716 gcc_assert (scope_die
->die_child
);
25717 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
25718 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
25719 scope_die
= scope_die
->die_child
;
25722 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
25723 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
25726 /* Output debug information for namelists. */
25729 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
25731 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
25735 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25738 gcc_assert (scope_die
!= NULL
);
25739 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
25740 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
25742 /* If there are no item_decls, we have a nondefining namelist, e.g.
25743 with USE association; hence, set DW_AT_declaration. */
25744 if (item_decls
== NULL_TREE
)
25746 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
25750 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
25752 nml_item_ref_die
= lookup_decl_die (value
);
25753 if (!nml_item_ref_die
)
25754 nml_item_ref_die
= force_decl_die (value
);
25756 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
25757 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
25763 /* Write the debugging output for DECL and return the DIE. */
25766 dwarf2out_decl (tree decl
)
25768 dw_die_ref context_die
= comp_unit_die ();
25770 switch (TREE_CODE (decl
))
25775 case FUNCTION_DECL
:
25776 /* If we're a nested function, initially use a parent of NULL; if we're
25777 a plain function, this will be fixed up in decls_for_scope. If
25778 we're a method, it will be ignored, since we already have a DIE. */
25779 if (decl_function_context (decl
)
25780 /* But if we're in terse mode, we don't care about scope. */
25781 && debug_info_level
> DINFO_LEVEL_TERSE
)
25782 context_die
= NULL
;
25786 /* For local statics lookup proper context die. */
25787 if (local_function_static (decl
))
25788 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
25790 /* If we are in terse mode, don't generate any DIEs to represent any
25791 variable declarations or definitions. */
25792 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25797 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25799 if (!is_fortran () && !is_ada ())
25801 if (TREE_STATIC (decl
) && decl_function_context (decl
))
25802 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
25805 case NAMESPACE_DECL
:
25806 case IMPORTED_DECL
:
25807 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25809 if (lookup_decl_die (decl
) != NULL
)
25814 /* Don't emit stubs for types unless they are needed by other DIEs. */
25815 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
25818 /* Don't bother trying to generate any DIEs to represent any of the
25819 normal built-in types for the language we are compiling. */
25820 if (DECL_IS_BUILTIN (decl
))
25823 /* If we are in terse mode, don't generate any DIEs for types. */
25824 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25827 /* If we're a function-scope tag, initially use a parent of NULL;
25828 this will be fixed up in decls_for_scope. */
25829 if (decl_function_context (decl
))
25830 context_die
= NULL
;
25834 case NAMELIST_DECL
:
25841 gen_decl_die (decl
, NULL
, NULL
, context_die
);
25845 dw_die_ref die
= lookup_decl_die (decl
);
25851 /* Write the debugging output for DECL. */
25854 dwarf2out_function_decl (tree decl
)
25856 dwarf2out_decl (decl
);
25857 call_arg_locations
= NULL
;
25858 call_arg_loc_last
= NULL
;
25859 call_site_count
= -1;
25860 tail_call_site_count
= -1;
25861 decl_loc_table
->empty ();
25862 cached_dw_loc_list_table
->empty ();
25865 /* Output a marker (i.e. a label) for the beginning of the generated code for
25866 a lexical block. */
25869 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
25870 unsigned int blocknum
)
25872 switch_to_section (current_function_section ());
25873 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
25876 /* Output a marker (i.e. a label) for the end of the generated code for a
25880 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
25882 switch_to_section (current_function_section ());
25883 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
25886 /* Returns nonzero if it is appropriate not to emit any debugging
25887 information for BLOCK, because it doesn't contain any instructions.
25889 Don't allow this for blocks with nested functions or local classes
25890 as we would end up with orphans, and in the presence of scheduling
25891 we may end up calling them anyway. */
25894 dwarf2out_ignore_block (const_tree block
)
25899 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
25900 if (TREE_CODE (decl
) == FUNCTION_DECL
25901 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
25903 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
25905 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
25906 if (TREE_CODE (decl
) == FUNCTION_DECL
25907 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
25914 /* Hash table routines for file_hash. */
25917 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
25919 return filename_cmp (p1
->filename
, p2
) == 0;
25923 dwarf_file_hasher::hash (dwarf_file_data
*p
)
25925 return htab_hash_string (p
->filename
);
25928 /* Lookup FILE_NAME (in the list of filenames that we know about here in
25929 dwarf2out.c) and return its "index". The index of each (known) filename is
25930 just a unique number which is associated with only that one filename. We
25931 need such numbers for the sake of generating labels (in the .debug_sfnames
25932 section) and references to those files numbers (in the .debug_srcinfo
25933 and .debug_macinfo sections). If the filename given as an argument is not
25934 found in our current list, add it to the list and assign it the next
25935 available unique index number. */
25937 static struct dwarf_file_data
*
25938 lookup_filename (const char *file_name
)
25940 struct dwarf_file_data
* created
;
25945 dwarf_file_data
**slot
25946 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
25951 created
= ggc_alloc
<dwarf_file_data
> ();
25952 created
->filename
= file_name
;
25953 created
->emitted_number
= 0;
25958 /* If the assembler will construct the file table, then translate the compiler
25959 internal file table number into the assembler file table number, and emit
25960 a .file directive if we haven't already emitted one yet. The file table
25961 numbers are different because we prune debug info for unused variables and
25962 types, which may include filenames. */
25965 maybe_emit_file (struct dwarf_file_data
* fd
)
25967 if (! fd
->emitted_number
)
25969 if (last_emitted_file
)
25970 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
25972 fd
->emitted_number
= 1;
25973 last_emitted_file
= fd
;
25975 if (DWARF2_ASM_LINE_DEBUG_INFO
)
25977 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
25978 output_quoted_string (asm_out_file
,
25979 remap_debug_filename (fd
->filename
));
25980 fputc ('\n', asm_out_file
);
25984 return fd
->emitted_number
;
25987 /* Schedule generation of a DW_AT_const_value attribute to DIE.
25988 That generation should happen after function debug info has been
25989 generated. The value of the attribute is the constant value of ARG. */
25992 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
25994 die_arg_entry entry
;
25999 gcc_assert (early_dwarf
);
26001 if (!tmpl_value_parm_die_table
)
26002 vec_alloc (tmpl_value_parm_die_table
, 32);
26006 vec_safe_push (tmpl_value_parm_die_table
, entry
);
26009 /* Return TRUE if T is an instance of generic type, FALSE
26013 generic_type_p (tree t
)
26015 if (t
== NULL_TREE
|| !TYPE_P (t
))
26017 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
26020 /* Schedule the generation of the generic parameter dies for the
26021 instance of generic type T. The proper generation itself is later
26022 done by gen_scheduled_generic_parms_dies. */
26025 schedule_generic_params_dies_gen (tree t
)
26027 if (!generic_type_p (t
))
26030 gcc_assert (early_dwarf
);
26032 if (!generic_type_instances
)
26033 vec_alloc (generic_type_instances
, 256);
26035 vec_safe_push (generic_type_instances
, t
);
26038 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
26039 by append_entry_to_tmpl_value_parm_die_table. This function must
26040 be called after function DIEs have been generated. */
26043 gen_remaining_tmpl_value_param_die_attribute (void)
26045 if (tmpl_value_parm_die_table
)
26050 /* We do this in two phases - first get the cases we can
26051 handle during early-finish, preserving those we cannot
26052 (containing symbolic constants where we don't yet know
26053 whether we are going to output the referenced symbols).
26054 For those we try again at late-finish. */
26056 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
26058 if (!e
->die
->removed
26059 && !tree_add_const_value_attribute (e
->die
, e
->arg
))
26061 dw_loc_descr_ref loc
= NULL
;
26063 && (dwarf_version
>= 5 || !dwarf_strict
))
26064 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
26066 add_AT_loc (e
->die
, DW_AT_location
, loc
);
26068 (*tmpl_value_parm_die_table
)[j
++] = *e
;
26071 tmpl_value_parm_die_table
->truncate (j
);
26075 /* Generate generic parameters DIEs for instances of generic types
26076 that have been previously scheduled by
26077 schedule_generic_params_dies_gen. This function must be called
26078 after all the types of the CU have been laid out. */
26081 gen_scheduled_generic_parms_dies (void)
26086 if (!generic_type_instances
)
26089 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
26090 if (COMPLETE_TYPE_P (t
))
26091 gen_generic_params_dies (t
);
26093 generic_type_instances
= NULL
;
26097 /* Replace DW_AT_name for the decl with name. */
26100 dwarf2out_set_name (tree decl
, tree name
)
26103 dw_attr_node
*attr
;
26106 die
= TYPE_SYMTAB_DIE (decl
);
26110 dname
= dwarf2_name (name
, 0);
26114 attr
= get_AT (die
, DW_AT_name
);
26117 struct indirect_string_node
*node
;
26119 node
= find_AT_string (dname
);
26120 /* replace the string. */
26121 attr
->dw_attr_val
.v
.val_str
= node
;
26125 add_name_attribute (die
, dname
);
26128 /* True if before or during processing of the first function being emitted. */
26129 static bool in_first_function_p
= true;
26130 /* True if loc_note during dwarf2out_var_location call might still be
26131 before first real instruction at address equal to .Ltext0. */
26132 static bool maybe_at_text_label_p
= true;
26133 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
26134 static unsigned int first_loclabel_num_not_at_text_label
;
26136 /* Called by the final INSN scan whenever we see a var location. We
26137 use it to drop labels in the right places, and throw the location in
26138 our lookup table. */
26141 dwarf2out_var_location (rtx_insn
*loc_note
)
26143 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
26144 struct var_loc_node
*newloc
;
26145 rtx_insn
*next_real
, *next_note
;
26146 rtx_insn
*call_insn
= NULL
;
26147 static const char *last_label
;
26148 static const char *last_postcall_label
;
26149 static bool last_in_cold_section_p
;
26150 static rtx_insn
*expected_next_loc_note
;
26154 if (!NOTE_P (loc_note
))
26156 if (CALL_P (loc_note
))
26159 if (SIBLING_CALL_P (loc_note
))
26160 tail_call_site_count
++;
26161 if (optimize
== 0 && !flag_var_tracking
)
26163 /* When the var-tracking pass is not running, there is no note
26164 for indirect calls whose target is compile-time known. In this
26165 case, process such calls specifically so that we generate call
26166 sites for them anyway. */
26167 rtx x
= PATTERN (loc_note
);
26168 if (GET_CODE (x
) == PARALLEL
)
26169 x
= XVECEXP (x
, 0, 0);
26170 if (GET_CODE (x
) == SET
)
26172 if (GET_CODE (x
) == CALL
)
26175 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
26176 || !SYMBOL_REF_DECL (XEXP (x
, 0))
26177 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
26180 call_insn
= loc_note
;
26184 next_real
= next_real_insn (call_insn
);
26186 cached_next_real_insn
= NULL
;
26194 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
26195 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
26198 /* Optimize processing a large consecutive sequence of location
26199 notes so we don't spend too much time in next_real_insn. If the
26200 next insn is another location note, remember the next_real_insn
26201 calculation for next time. */
26202 next_real
= cached_next_real_insn
;
26205 if (expected_next_loc_note
!= loc_note
)
26209 next_note
= NEXT_INSN (loc_note
);
26211 || next_note
->deleted ()
26212 || ! NOTE_P (next_note
)
26213 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
26214 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
26218 next_real
= next_real_insn (loc_note
);
26222 expected_next_loc_note
= next_note
;
26223 cached_next_real_insn
= next_real
;
26226 cached_next_real_insn
= NULL
;
26228 /* If there are no instructions which would be affected by this note,
26229 don't do anything. */
26231 && next_real
== NULL_RTX
26232 && !NOTE_DURING_CALL_P (loc_note
))
26237 if (next_real
== NULL_RTX
)
26238 next_real
= get_last_insn ();
26240 /* If there were any real insns between note we processed last time
26241 and this note (or if it is the first note), clear
26242 last_{,postcall_}label so that they are not reused this time. */
26243 if (last_var_location_insn
== NULL_RTX
26244 || last_var_location_insn
!= next_real
26245 || last_in_cold_section_p
!= in_cold_section_p
)
26248 last_postcall_label
= NULL
;
26253 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
26254 newloc
= add_var_loc_to_decl (decl
, loc_note
,
26255 NOTE_DURING_CALL_P (loc_note
)
26256 ? last_postcall_label
: last_label
);
26257 if (newloc
== NULL
)
26266 /* If there were no real insns between note we processed last time
26267 and this note, use the label we emitted last time. Otherwise
26268 create a new label and emit it. */
26269 if (last_label
== NULL
)
26271 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
26272 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
26274 last_label
= ggc_strdup (loclabel
);
26275 /* See if loclabel might be equal to .Ltext0. If yes,
26276 bump first_loclabel_num_not_at_text_label. */
26277 if (!have_multiple_function_sections
26278 && in_first_function_p
26279 && maybe_at_text_label_p
)
26281 static rtx_insn
*last_start
;
26283 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
26284 if (insn
== last_start
)
26286 else if (!NONDEBUG_INSN_P (insn
))
26290 rtx body
= PATTERN (insn
);
26291 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
26293 /* Inline asm could occupy zero bytes. */
26294 else if (GET_CODE (body
) == ASM_INPUT
26295 || asm_noperands (body
) >= 0)
26297 #ifdef HAVE_attr_length
26298 else if (get_attr_min_length (insn
) == 0)
26303 /* Assume insn has non-zero length. */
26304 maybe_at_text_label_p
= false;
26308 if (maybe_at_text_label_p
)
26310 last_start
= loc_note
;
26311 first_loclabel_num_not_at_text_label
= loclabel_num
;
26316 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
26317 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
26321 struct call_arg_loc_node
*ca_loc
26322 = ggc_cleared_alloc
<call_arg_loc_node
> ();
26324 = loc_note
!= NULL_RTX
? prev_real_insn (loc_note
) : call_insn
;
26326 ca_loc
->call_arg_loc_note
= loc_note
;
26327 ca_loc
->next
= NULL
;
26328 ca_loc
->label
= last_label
;
26331 || (NONJUMP_INSN_P (prev
)
26332 && GET_CODE (PATTERN (prev
)) == SEQUENCE
26333 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
26334 if (!CALL_P (prev
))
26335 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
26336 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
26338 /* Look for a SYMBOL_REF in the "prev" instruction. */
26339 rtx x
= get_call_rtx_from (PATTERN (prev
));
26342 /* Try to get the call symbol, if any. */
26343 if (MEM_P (XEXP (x
, 0)))
26345 /* First, look for a memory access to a symbol_ref. */
26346 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
26347 && SYMBOL_REF_DECL (XEXP (x
, 0))
26348 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
26349 ca_loc
->symbol_ref
= XEXP (x
, 0);
26350 /* Otherwise, look at a compile-time known user-level function
26354 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
26355 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
26358 ca_loc
->block
= insn_scope (prev
);
26359 if (call_arg_locations
)
26360 call_arg_loc_last
->next
= ca_loc
;
26362 call_arg_locations
= ca_loc
;
26363 call_arg_loc_last
= ca_loc
;
26365 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
26366 newloc
->label
= last_label
;
26369 if (!last_postcall_label
)
26371 sprintf (loclabel
, "%s-1", last_label
);
26372 last_postcall_label
= ggc_strdup (loclabel
);
26374 newloc
->label
= last_postcall_label
;
26377 last_var_location_insn
= next_real
;
26378 last_in_cold_section_p
= in_cold_section_p
;
26381 /* Called from finalize_size_functions for size functions so that their body
26382 can be encoded in the debug info to describe the layout of variable-length
26386 dwarf2out_size_function (tree decl
)
26388 function_to_dwarf_procedure (decl
);
26391 /* Note in one location list that text section has changed. */
26394 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
26396 var_loc_list
*list
= *slot
;
26398 list
->last_before_switch
26399 = list
->last
->next
? list
->last
->next
: list
->last
;
26403 /* Note in all location lists that text section has changed. */
26406 var_location_switch_text_section (void)
26408 if (decl_loc_table
== NULL
)
26411 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
26414 /* Create a new line number table. */
26416 static dw_line_info_table
*
26417 new_line_info_table (void)
26419 dw_line_info_table
*table
;
26421 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
26422 table
->file_num
= 1;
26423 table
->line_num
= 1;
26424 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
26429 /* Lookup the "current" table into which we emit line info, so
26430 that we don't have to do it for every source line. */
26433 set_cur_line_info_table (section
*sec
)
26435 dw_line_info_table
*table
;
26437 if (sec
== text_section
)
26438 table
= text_section_line_info
;
26439 else if (sec
== cold_text_section
)
26441 table
= cold_text_section_line_info
;
26444 cold_text_section_line_info
= table
= new_line_info_table ();
26445 table
->end_label
= cold_end_label
;
26450 const char *end_label
;
26452 if (crtl
->has_bb_partition
)
26454 if (in_cold_section_p
)
26455 end_label
= crtl
->subsections
.cold_section_end_label
;
26457 end_label
= crtl
->subsections
.hot_section_end_label
;
26461 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
26462 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
26463 current_function_funcdef_no
);
26464 end_label
= ggc_strdup (label
);
26467 table
= new_line_info_table ();
26468 table
->end_label
= end_label
;
26470 vec_safe_push (separate_line_info
, table
);
26473 if (DWARF2_ASM_LINE_DEBUG_INFO
)
26474 table
->is_stmt
= (cur_line_info_table
26475 ? cur_line_info_table
->is_stmt
26476 : DWARF_LINE_DEFAULT_IS_STMT_START
);
26477 cur_line_info_table
= table
;
26481 /* We need to reset the locations at the beginning of each
26482 function. We can't do this in the end_function hook, because the
26483 declarations that use the locations won't have been output when
26484 that hook is called. Also compute have_multiple_function_sections here. */
26487 dwarf2out_begin_function (tree fun
)
26489 section
*sec
= function_section (fun
);
26491 if (sec
!= text_section
)
26492 have_multiple_function_sections
= true;
26494 if (crtl
->has_bb_partition
&& !cold_text_section
)
26496 gcc_assert (current_function_decl
== fun
);
26497 cold_text_section
= unlikely_text_section ();
26498 switch_to_section (cold_text_section
);
26499 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
26500 switch_to_section (sec
);
26503 dwarf2out_note_section_used ();
26504 call_site_count
= 0;
26505 tail_call_site_count
= 0;
26507 set_cur_line_info_table (sec
);
26510 /* Helper function of dwarf2out_end_function, called only after emitting
26511 the very first function into assembly. Check if some .debug_loc range
26512 might end with a .LVL* label that could be equal to .Ltext0.
26513 In that case we must force using absolute addresses in .debug_loc ranges,
26514 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
26515 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
26517 Set have_multiple_function_sections to true in that case and
26518 terminate htab traversal. */
26521 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
26523 var_loc_list
*entry
= *slot
;
26524 struct var_loc_node
*node
;
26526 node
= entry
->first
;
26527 if (node
&& node
->next
&& node
->next
->label
)
26530 const char *label
= node
->next
->label
;
26531 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
26533 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
26535 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
26536 if (strcmp (label
, loclabel
) == 0)
26538 have_multiple_function_sections
= true;
26546 /* Hook called after emitting a function into assembly.
26547 This does something only for the very first function emitted. */
26550 dwarf2out_end_function (unsigned int)
26552 if (in_first_function_p
26553 && !have_multiple_function_sections
26554 && first_loclabel_num_not_at_text_label
26556 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
26557 in_first_function_p
= false;
26558 maybe_at_text_label_p
= false;
26561 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
26562 front-ends register a translation unit even before dwarf2out_init is
26564 static tree main_translation_unit
= NULL_TREE
;
26566 /* Hook called by front-ends after they built their main translation unit.
26567 Associate comp_unit_die to UNIT. */
26570 dwarf2out_register_main_translation_unit (tree unit
)
26572 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
26573 && main_translation_unit
== NULL_TREE
);
26574 main_translation_unit
= unit
;
26575 /* If dwarf2out_init has not been called yet, it will perform the association
26576 itself looking at main_translation_unit. */
26577 if (decl_die_table
!= NULL
)
26578 equate_decl_number_to_die (unit
, comp_unit_die ());
26581 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
26584 push_dw_line_info_entry (dw_line_info_table
*table
,
26585 enum dw_line_info_opcode opcode
, unsigned int val
)
26587 dw_line_info_entry e
;
26590 vec_safe_push (table
->entries
, e
);
26593 /* Output a label to mark the beginning of a source code line entry
26594 and record information relating to this source line, in
26595 'line_info_table' for later output of the .debug_line section. */
26596 /* ??? The discriminator parameter ought to be unsigned. */
26599 dwarf2out_source_line (unsigned int line
, unsigned int column
,
26600 const char *filename
,
26601 int discriminator
, bool is_stmt
)
26603 unsigned int file_num
;
26604 dw_line_info_table
*table
;
26606 if (debug_info_level
< DINFO_LEVEL_TERSE
|| line
== 0)
26609 /* The discriminator column was added in dwarf4. Simplify the below
26610 by simply removing it if we're not supposed to output it. */
26611 if (dwarf_version
< 4 && dwarf_strict
)
26614 if (!debug_column_info
)
26617 table
= cur_line_info_table
;
26618 file_num
= maybe_emit_file (lookup_filename (filename
));
26620 /* ??? TODO: Elide duplicate line number entries. Traditionally,
26621 the debugger has used the second (possibly duplicate) line number
26622 at the beginning of the function to mark the end of the prologue.
26623 We could eliminate any other duplicates within the function. For
26624 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
26625 that second line number entry. */
26626 /* Recall that this end-of-prologue indication is *not* the same thing
26627 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
26628 to which the hook corresponds, follows the last insn that was
26629 emitted by gen_prologue. What we need is to precede the first insn
26630 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
26631 insn that corresponds to something the user wrote. These may be
26632 very different locations once scheduling is enabled. */
26634 if (0 && file_num
== table
->file_num
26635 && line
== table
->line_num
26636 && column
== table
->column_num
26637 && discriminator
== table
->discrim_num
26638 && is_stmt
== table
->is_stmt
)
26641 switch_to_section (current_function_section ());
26643 /* If requested, emit something human-readable. */
26644 if (flag_debug_asm
)
26646 if (debug_column_info
)
26647 fprintf (asm_out_file
, "\t%s %s:%d:%d\n", ASM_COMMENT_START
,
26648 filename
, line
, column
);
26650 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
26654 if (DWARF2_ASM_LINE_DEBUG_INFO
)
26656 /* Emit the .loc directive understood by GNU as. */
26657 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
26658 file_num, line, is_stmt, discriminator */
26659 fputs ("\t.loc ", asm_out_file
);
26660 fprint_ul (asm_out_file
, file_num
);
26661 putc (' ', asm_out_file
);
26662 fprint_ul (asm_out_file
, line
);
26663 putc (' ', asm_out_file
);
26664 if (debug_column_info
)
26665 fprint_ul (asm_out_file
, column
);
26667 putc ('0', asm_out_file
);
26669 if (is_stmt
!= table
->is_stmt
)
26671 fputs (" is_stmt ", asm_out_file
);
26672 putc (is_stmt
? '1' : '0', asm_out_file
);
26674 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
26676 gcc_assert (discriminator
> 0);
26677 fputs (" discriminator ", asm_out_file
);
26678 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
26680 putc ('\n', asm_out_file
);
26684 unsigned int label_num
= ++line_info_label_num
;
26686 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
26688 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
26689 if (file_num
!= table
->file_num
)
26690 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
26691 if (discriminator
!= table
->discrim_num
)
26692 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
26693 if (is_stmt
!= table
->is_stmt
)
26694 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
26695 push_dw_line_info_entry (table
, LI_set_line
, line
);
26696 if (debug_column_info
)
26697 push_dw_line_info_entry (table
, LI_set_column
, column
);
26700 table
->file_num
= file_num
;
26701 table
->line_num
= line
;
26702 table
->column_num
= column
;
26703 table
->discrim_num
= discriminator
;
26704 table
->is_stmt
= is_stmt
;
26705 table
->in_use
= true;
26708 /* Record the beginning of a new source file. */
26711 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
26713 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
26716 e
.code
= DW_MACINFO_start_file
;
26718 e
.info
= ggc_strdup (filename
);
26719 vec_safe_push (macinfo_table
, e
);
26723 /* Record the end of a source file. */
26726 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
26728 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
26731 e
.code
= DW_MACINFO_end_file
;
26734 vec_safe_push (macinfo_table
, e
);
26738 /* Called from debug_define in toplev.c. The `buffer' parameter contains
26739 the tail part of the directive line, i.e. the part which is past the
26740 initial whitespace, #, whitespace, directive-name, whitespace part. */
26743 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
26744 const char *buffer ATTRIBUTE_UNUSED
)
26746 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
26749 /* Insert a dummy first entry to be able to optimize the whole
26750 predefined macro block using DW_MACRO_import. */
26751 if (macinfo_table
->is_empty () && lineno
<= 1)
26756 vec_safe_push (macinfo_table
, e
);
26758 e
.code
= DW_MACINFO_define
;
26760 e
.info
= ggc_strdup (buffer
);
26761 vec_safe_push (macinfo_table
, e
);
26765 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
26766 the tail part of the directive line, i.e. the part which is past the
26767 initial whitespace, #, whitespace, directive-name, whitespace part. */
26770 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
26771 const char *buffer ATTRIBUTE_UNUSED
)
26773 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
26776 /* Insert a dummy first entry to be able to optimize the whole
26777 predefined macro block using DW_MACRO_import. */
26778 if (macinfo_table
->is_empty () && lineno
<= 1)
26783 vec_safe_push (macinfo_table
, e
);
26785 e
.code
= DW_MACINFO_undef
;
26787 e
.info
= ggc_strdup (buffer
);
26788 vec_safe_push (macinfo_table
, e
);
26792 /* Helpers to manipulate hash table of CUs. */
26794 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
26796 static inline hashval_t
hash (const macinfo_entry
*);
26797 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
26801 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
26803 return htab_hash_string (entry
->info
);
26807 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
26808 const macinfo_entry
*entry2
)
26810 return !strcmp (entry1
->info
, entry2
->info
);
26813 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
26815 /* Output a single .debug_macinfo entry. */
26818 output_macinfo_op (macinfo_entry
*ref
)
26822 struct indirect_string_node
*node
;
26823 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
26824 struct dwarf_file_data
*fd
;
26828 case DW_MACINFO_start_file
:
26829 fd
= lookup_filename (ref
->info
);
26830 file_num
= maybe_emit_file (fd
);
26831 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
26832 dw2_asm_output_data_uleb128 (ref
->lineno
,
26833 "Included from line number %lu",
26834 (unsigned long) ref
->lineno
);
26835 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
26837 case DW_MACINFO_end_file
:
26838 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
26840 case DW_MACINFO_define
:
26841 case DW_MACINFO_undef
:
26842 len
= strlen (ref
->info
) + 1;
26844 && len
> DWARF_OFFSET_SIZE
26845 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
26846 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
26848 ref
->code
= ref
->code
== DW_MACINFO_define
26849 ? DW_MACRO_define_strp
: DW_MACRO_undef_strp
;
26850 output_macinfo_op (ref
);
26853 dw2_asm_output_data (1, ref
->code
,
26854 ref
->code
== DW_MACINFO_define
26855 ? "Define macro" : "Undefine macro");
26856 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
26857 (unsigned long) ref
->lineno
);
26858 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
26860 case DW_MACRO_define_strp
:
26861 case DW_MACRO_undef_strp
:
26862 node
= find_AT_string (ref
->info
);
26864 && (node
->form
== DW_FORM_strp
26865 || node
->form
== DW_FORM_GNU_str_index
));
26866 dw2_asm_output_data (1, ref
->code
,
26867 ref
->code
== DW_MACRO_define_strp
26868 ? "Define macro strp"
26869 : "Undefine macro strp");
26870 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
26871 (unsigned long) ref
->lineno
);
26872 if (node
->form
== DW_FORM_strp
)
26873 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
26874 debug_str_section
, "The macro: \"%s\"",
26877 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
26880 case DW_MACRO_import
:
26881 dw2_asm_output_data (1, ref
->code
, "Import");
26882 ASM_GENERATE_INTERNAL_LABEL (label
,
26883 DEBUG_MACRO_SECTION_LABEL
,
26884 ref
->lineno
+ macinfo_label_base
);
26885 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
26888 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
26889 ASM_COMMENT_START
, (unsigned long) ref
->code
);
26894 /* Attempt to make a sequence of define/undef macinfo ops shareable with
26895 other compilation unit .debug_macinfo sections. IDX is the first
26896 index of a define/undef, return the number of ops that should be
26897 emitted in a comdat .debug_macinfo section and emit
26898 a DW_MACRO_import entry referencing it.
26899 If the define/undef entry should be emitted normally, return 0. */
26902 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
26903 macinfo_hash_type
**macinfo_htab
)
26905 macinfo_entry
*first
, *second
, *cur
, *inc
;
26906 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
26907 unsigned char checksum
[16];
26908 struct md5_ctx ctx
;
26909 char *grp_name
, *tail
;
26911 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
26912 macinfo_entry
**slot
;
26914 first
= &(*macinfo_table
)[idx
];
26915 second
= &(*macinfo_table
)[idx
+ 1];
26917 /* Optimize only if there are at least two consecutive define/undef ops,
26918 and either all of them are before first DW_MACINFO_start_file
26919 with lineno {0,1} (i.e. predefined macro block), or all of them are
26920 in some included header file. */
26921 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
26923 if (vec_safe_is_empty (files
))
26925 if (first
->lineno
> 1 || second
->lineno
> 1)
26928 else if (first
->lineno
== 0)
26931 /* Find the last define/undef entry that can be grouped together
26932 with first and at the same time compute md5 checksum of their
26933 codes, linenumbers and strings. */
26934 md5_init_ctx (&ctx
);
26935 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
26936 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
26938 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
26942 unsigned char code
= cur
->code
;
26943 md5_process_bytes (&code
, 1, &ctx
);
26944 checksum_uleb128 (cur
->lineno
, &ctx
);
26945 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
26947 md5_finish_ctx (&ctx
, checksum
);
26950 /* From the containing include filename (if any) pick up just
26951 usable characters from its basename. */
26952 if (vec_safe_is_empty (files
))
26955 base
= lbasename (files
->last ().info
);
26956 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
26957 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
26958 encoded_filename_len
++;
26959 /* Count . at the end. */
26960 if (encoded_filename_len
)
26961 encoded_filename_len
++;
26963 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
26964 linebuf_len
= strlen (linebuf
);
26966 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
26967 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
26969 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
26970 tail
= grp_name
+ 4;
26971 if (encoded_filename_len
)
26973 for (i
= 0; base
[i
]; i
++)
26974 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
26978 memcpy (tail
, linebuf
, linebuf_len
);
26979 tail
+= linebuf_len
;
26981 for (i
= 0; i
< 16; i
++)
26982 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
26984 /* Construct a macinfo_entry for DW_MACRO_import
26985 in the empty vector entry before the first define/undef. */
26986 inc
= &(*macinfo_table
)[idx
- 1];
26987 inc
->code
= DW_MACRO_import
;
26989 inc
->info
= ggc_strdup (grp_name
);
26990 if (!*macinfo_htab
)
26991 *macinfo_htab
= new macinfo_hash_type (10);
26992 /* Avoid emitting duplicates. */
26993 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
26998 /* If such an entry has been used before, just emit
26999 a DW_MACRO_import op. */
27001 output_macinfo_op (inc
);
27002 /* And clear all macinfo_entry in the range to avoid emitting them
27003 in the second pass. */
27004 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
27013 inc
->lineno
= (*macinfo_htab
)->elements ();
27014 output_macinfo_op (inc
);
27019 /* Save any strings needed by the macinfo table in the debug str
27020 table. All strings must be collected into the table by the time
27021 index_string is called. */
27024 save_macinfo_strings (void)
27028 macinfo_entry
*ref
;
27030 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
27034 /* Match the logic in output_macinfo_op to decide on
27035 indirect strings. */
27036 case DW_MACINFO_define
:
27037 case DW_MACINFO_undef
:
27038 len
= strlen (ref
->info
) + 1;
27040 && len
> DWARF_OFFSET_SIZE
27041 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
27042 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
27043 set_indirect_string (find_AT_string (ref
->info
));
27045 case DW_MACRO_define_strp
:
27046 case DW_MACRO_undef_strp
:
27047 set_indirect_string (find_AT_string (ref
->info
));
27055 /* Output macinfo section(s). */
27058 output_macinfo (const char *debug_line_label
, bool early_lto_debug
)
27061 unsigned long length
= vec_safe_length (macinfo_table
);
27062 macinfo_entry
*ref
;
27063 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
27064 macinfo_hash_type
*macinfo_htab
= NULL
;
27065 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
27070 /* output_macinfo* uses these interchangeably. */
27071 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_define
27072 && (int) DW_MACINFO_undef
== (int) DW_MACRO_undef
27073 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_start_file
27074 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_end_file
);
27076 /* AIX Assembler inserts the length, so adjust the reference to match the
27077 offset expected by debuggers. */
27078 strcpy (dl_section_ref
, debug_line_label
);
27079 if (XCOFF_DEBUGGING_INFO
)
27080 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
27082 /* For .debug_macro emit the section header. */
27083 if (!dwarf_strict
|| dwarf_version
>= 5)
27085 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
27086 "DWARF macro version number");
27087 if (DWARF_OFFSET_SIZE
== 8)
27088 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
27090 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
27091 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_line_label
,
27092 debug_line_section
, NULL
);
27095 /* In the first loop, it emits the primary .debug_macinfo section
27096 and after each emitted op the macinfo_entry is cleared.
27097 If a longer range of define/undef ops can be optimized using
27098 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
27099 the vector before the first define/undef in the range and the
27100 whole range of define/undef ops is not emitted and kept. */
27101 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
27105 case DW_MACINFO_start_file
:
27106 vec_safe_push (files
, *ref
);
27108 case DW_MACINFO_end_file
:
27109 if (!vec_safe_is_empty (files
))
27112 case DW_MACINFO_define
:
27113 case DW_MACINFO_undef
:
27114 if ((!dwarf_strict
|| dwarf_version
>= 5)
27115 && HAVE_COMDAT_GROUP
27116 && vec_safe_length (files
) != 1
27119 && (*macinfo_table
)[i
- 1].code
== 0)
27121 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
27130 /* A dummy entry may be inserted at the beginning to be able
27131 to optimize the whole block of predefined macros. */
27137 output_macinfo_op (ref
);
27145 /* Save the number of transparent includes so we can adjust the
27146 label number for the fat LTO object DWARF. */
27147 unsigned macinfo_label_base_adj
= macinfo_htab
->elements ();
27149 delete macinfo_htab
;
27150 macinfo_htab
= NULL
;
27152 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
27153 terminate the current chain and switch to a new comdat .debug_macinfo
27154 section and emit the define/undef entries within it. */
27155 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
27160 case DW_MACRO_import
:
27162 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27163 tree comdat_key
= get_identifier (ref
->info
);
27164 /* Terminate the previous .debug_macinfo section. */
27165 dw2_asm_output_data (1, 0, "End compilation unit");
27166 targetm
.asm_out
.named_section (debug_macinfo_section_name
,
27170 ? SECTION_EXCLUDE
: 0),
27172 ASM_GENERATE_INTERNAL_LABEL (label
,
27173 DEBUG_MACRO_SECTION_LABEL
,
27174 ref
->lineno
+ macinfo_label_base
);
27175 ASM_OUTPUT_LABEL (asm_out_file
, label
);
27178 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
27179 "DWARF macro version number");
27180 if (DWARF_OFFSET_SIZE
== 8)
27181 dw2_asm_output_data (1, 1, "Flags: 64-bit");
27183 dw2_asm_output_data (1, 0, "Flags: 32-bit");
27186 case DW_MACINFO_define
:
27187 case DW_MACINFO_undef
:
27188 output_macinfo_op (ref
);
27193 gcc_unreachable ();
27196 macinfo_label_base
+= macinfo_label_base_adj
;
27199 /* Initialize the various sections and labels for dwarf output and prefix
27200 them with PREFIX if non-NULL. */
27203 init_sections_and_labels (bool early_lto_debug
)
27205 /* As we may get called multiple times have a generation count for labels. */
27206 static unsigned generation
= 0;
27208 if (early_lto_debug
)
27210 if (!dwarf_split_debug_info
)
27212 debug_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
27213 SECTION_DEBUG
| SECTION_EXCLUDE
,
27215 debug_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
27216 SECTION_DEBUG
| SECTION_EXCLUDE
,
27218 debug_macinfo_section_name
= ((dwarf_strict
&& dwarf_version
< 5)
27219 ? DEBUG_LTO_MACINFO_SECTION
27220 : DEBUG_LTO_MACRO_SECTION
);
27221 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
27223 | SECTION_EXCLUDE
, NULL
);
27224 /* For macro info we have to refer to a debug_line section, so similar
27225 to split-dwarf emit a skeleton one for early debug. */
27226 debug_skeleton_line_section
27227 = get_section (DEBUG_LTO_LINE_SECTION
,
27228 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27229 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
27230 DEBUG_SKELETON_LINE_SECTION_LABEL
,
27235 /* ??? Which of the following do we need early? */
27236 debug_info_section
= get_section (DEBUG_LTO_DWO_INFO_SECTION
,
27237 SECTION_DEBUG
| SECTION_EXCLUDE
,
27239 debug_abbrev_section
= get_section (DEBUG_LTO_DWO_ABBREV_SECTION
,
27240 SECTION_DEBUG
| SECTION_EXCLUDE
,
27242 debug_skeleton_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
27244 | SECTION_EXCLUDE
, NULL
);
27245 debug_skeleton_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
27247 | SECTION_EXCLUDE
, NULL
);
27248 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
27249 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
27252 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
27253 the main .o, but the skeleton_line goes into the split off dwo. */
27254 debug_skeleton_line_section
27255 = get_section (DEBUG_LTO_LINE_SECTION
,
27256 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27257 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
27258 DEBUG_SKELETON_LINE_SECTION_LABEL
,
27260 debug_str_offsets_section
27261 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION
,
27262 SECTION_DEBUG
| SECTION_EXCLUDE
,
27264 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
27265 DEBUG_SKELETON_INFO_SECTION_LABEL
,
27267 debug_str_dwo_section
= get_section (DEBUG_LTO_STR_DWO_SECTION
,
27268 DEBUG_STR_DWO_SECTION_FLAGS
, NULL
);
27269 debug_macinfo_section_name
27271 ? DEBUG_LTO_DWO_MACINFO_SECTION
: DEBUG_LTO_DWO_MACRO_SECTION
);
27272 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
27273 SECTION_DEBUG
| SECTION_EXCLUDE
,
27276 debug_str_section
= get_section (DEBUG_LTO_STR_SECTION
,
27277 DEBUG_STR_SECTION_FLAGS
27278 | SECTION_EXCLUDE
, NULL
);
27282 if (!dwarf_split_debug_info
)
27284 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
27285 SECTION_DEBUG
, NULL
);
27286 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
27287 SECTION_DEBUG
, NULL
);
27288 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
27289 SECTION_DEBUG
, NULL
);
27290 debug_macinfo_section_name
27291 = dwarf_strict
? DEBUG_MACINFO_SECTION
: DEBUG_MACRO_SECTION
;
27292 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
27293 SECTION_DEBUG
, NULL
);
27297 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
27298 SECTION_DEBUG
| SECTION_EXCLUDE
,
27300 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
27301 SECTION_DEBUG
| SECTION_EXCLUDE
,
27303 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
27304 SECTION_DEBUG
, NULL
);
27305 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
27306 SECTION_DEBUG
, NULL
);
27307 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
27308 SECTION_DEBUG
, NULL
);
27309 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
27310 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
27313 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
27314 stay in the main .o, but the skeleton_line goes into the
27316 debug_skeleton_line_section
27317 = get_section (DEBUG_DWO_LINE_SECTION
,
27318 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27319 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
27320 DEBUG_SKELETON_LINE_SECTION_LABEL
,
27322 debug_str_offsets_section
27323 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION
,
27324 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27325 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
27326 DEBUG_SKELETON_INFO_SECTION_LABEL
,
27328 debug_loc_section
= get_section (DEBUG_DWO_LOC_SECTION
,
27329 SECTION_DEBUG
| SECTION_EXCLUDE
,
27331 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
27332 DEBUG_STR_DWO_SECTION_FLAGS
,
27334 debug_macinfo_section_name
27335 = (dwarf_strict
&& dwarf_version
< 5)
27336 ? DEBUG_DWO_MACINFO_SECTION
: DEBUG_DWO_MACRO_SECTION
;
27337 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
27338 SECTION_DEBUG
| SECTION_EXCLUDE
,
27341 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
27342 SECTION_DEBUG
, NULL
);
27343 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
27344 SECTION_DEBUG
, NULL
);
27345 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
27346 SECTION_DEBUG
, NULL
);
27347 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
27348 SECTION_DEBUG
, NULL
);
27349 debug_str_section
= get_section (DEBUG_STR_SECTION
,
27350 DEBUG_STR_SECTION_FLAGS
, NULL
);
27351 debug_ranges_section
= get_section (dwarf_version
>= 5
27352 ? DEBUG_RNGLISTS_SECTION
27353 : DEBUG_RANGES_SECTION
,
27354 SECTION_DEBUG
, NULL
);
27355 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
27356 SECTION_DEBUG
, NULL
);
27359 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
27360 DEBUG_ABBREV_SECTION_LABEL
, generation
);
27361 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
27362 DEBUG_INFO_SECTION_LABEL
, generation
);
27363 info_section_emitted
= false;
27364 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
27365 DEBUG_LINE_SECTION_LABEL
, generation
);
27366 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
27367 DEBUG_RANGES_SECTION_LABEL
, generation
);
27368 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
27369 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label
,
27370 DEBUG_RANGES_SECTION_LABEL
, 2 + generation
);
27371 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
27372 DEBUG_ADDR_SECTION_LABEL
, generation
);
27373 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
27374 (dwarf_strict
&& dwarf_version
< 5)
27375 ? DEBUG_MACINFO_SECTION_LABEL
27376 : DEBUG_MACRO_SECTION_LABEL
, generation
);
27377 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
,
27383 /* Set up for Dwarf output at the start of compilation. */
27386 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
27388 /* Allocate the file_table. */
27389 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
27391 #ifndef DWARF2_LINENO_DEBUGGING_INFO
27392 /* Allocate the decl_die_table. */
27393 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
27395 /* Allocate the decl_loc_table. */
27396 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
27398 /* Allocate the cached_dw_loc_list_table. */
27399 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
27401 /* Allocate the initial hunk of the decl_scope_table. */
27402 vec_alloc (decl_scope_table
, 256);
27404 /* Allocate the initial hunk of the abbrev_die_table. */
27405 vec_alloc (abbrev_die_table
, 256);
27406 /* Zero-th entry is allocated, but unused. */
27407 abbrev_die_table
->quick_push (NULL
);
27409 /* Allocate the dwarf_proc_stack_usage_map. */
27410 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
27412 /* Allocate the pubtypes and pubnames vectors. */
27413 vec_alloc (pubname_table
, 32);
27414 vec_alloc (pubtype_table
, 32);
27416 vec_alloc (incomplete_types
, 64);
27418 vec_alloc (used_rtx_array
, 32);
27420 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27421 vec_alloc (macinfo_table
, 64);
27424 /* If front-ends already registered a main translation unit but we were not
27425 ready to perform the association, do this now. */
27426 if (main_translation_unit
!= NULL_TREE
)
27427 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
27430 /* Called before compile () starts outputtting functions, variables
27431 and toplevel asms into assembly. */
27434 dwarf2out_assembly_start (void)
27436 #ifndef DWARF2_LINENO_DEBUGGING_INFO
27437 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
27438 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
27439 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
27440 COLD_TEXT_SECTION_LABEL
, 0);
27441 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
27443 switch_to_section (text_section
);
27444 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
27447 /* Make sure the line number table for .text always exists. */
27448 text_section_line_info
= new_line_info_table ();
27449 text_section_line_info
->end_label
= text_end_label
;
27451 #ifdef DWARF2_LINENO_DEBUGGING_INFO
27452 cur_line_info_table
= text_section_line_info
;
27455 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
27456 && dwarf2out_do_cfi_asm ()
27457 && (!(flag_unwind_tables
|| flag_exceptions
)
27458 || targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
))
27459 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
27462 /* A helper function for dwarf2out_finish called through
27463 htab_traverse. Assign a string its index. All strings must be
27464 collected into the table by the time index_string is called,
27465 because the indexing code relies on htab_traverse to traverse nodes
27466 in the same order for each run. */
27469 index_string (indirect_string_node
**h
, unsigned int *index
)
27471 indirect_string_node
*node
= *h
;
27473 find_string_form (node
);
27474 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
27476 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
27477 node
->index
= *index
;
27483 /* A helper function for output_indirect_strings called through
27484 htab_traverse. Output the offset to a string and update the
27488 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
27490 indirect_string_node
*node
= *h
;
27492 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
27494 /* Assert that this node has been assigned an index. */
27495 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
27496 && node
->index
!= NOT_INDEXED
);
27497 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
27498 "indexed string 0x%x: %s", node
->index
, node
->str
);
27499 *offset
+= strlen (node
->str
) + 1;
27504 /* A helper function for dwarf2out_finish called through
27505 htab_traverse. Output the indexed string. */
27508 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
27510 struct indirect_string_node
*node
= *h
;
27512 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
27514 /* Assert that the strings are output in the same order as their
27515 indexes were assigned. */
27516 gcc_assert (*cur_idx
== node
->index
);
27517 assemble_string (node
->str
, strlen (node
->str
) + 1);
27523 /* A helper function for dwarf2out_finish called through
27524 htab_traverse. Emit one queued .debug_str string. */
27527 output_indirect_string (indirect_string_node
**h
, enum dwarf_form form
)
27529 struct indirect_string_node
*node
= *h
;
27531 node
->form
= find_string_form (node
);
27532 if (node
->form
== form
&& node
->refcount
> 0)
27534 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
27535 assemble_string (node
->str
, strlen (node
->str
) + 1);
27541 /* Output the indexed string table. */
27544 output_indirect_strings (void)
27546 switch_to_section (debug_str_section
);
27547 if (!dwarf_split_debug_info
)
27548 debug_str_hash
->traverse
<enum dwarf_form
,
27549 output_indirect_string
> (DW_FORM_strp
);
27552 unsigned int offset
= 0;
27553 unsigned int cur_idx
= 0;
27555 skeleton_debug_str_hash
->traverse
<enum dwarf_form
,
27556 output_indirect_string
> (DW_FORM_strp
);
27558 switch_to_section (debug_str_offsets_section
);
27559 debug_str_hash
->traverse_noresize
27560 <unsigned int *, output_index_string_offset
> (&offset
);
27561 switch_to_section (debug_str_dwo_section
);
27562 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
27567 /* Callback for htab_traverse to assign an index to an entry in the
27568 table, and to write that entry to the .debug_addr section. */
27571 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
27573 addr_table_entry
*entry
= *slot
;
27575 if (entry
->refcount
== 0)
27577 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
27578 || entry
->index
== NOT_INDEXED
);
27582 gcc_assert (entry
->index
== *cur_index
);
27585 switch (entry
->kind
)
27588 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
27589 "0x%x", entry
->index
);
27591 case ate_kind_rtx_dtprel
:
27592 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
27593 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
27596 fputc ('\n', asm_out_file
);
27598 case ate_kind_label
:
27599 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
27600 "0x%x", entry
->index
);
27603 gcc_unreachable ();
27608 /* Produce the .debug_addr section. */
27611 output_addr_table (void)
27613 unsigned int index
= 0;
27614 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
27617 switch_to_section (debug_addr_section
);
27619 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
27622 #if ENABLE_ASSERT_CHECKING
27623 /* Verify that all marks are clear. */
27626 verify_marks_clear (dw_die_ref die
)
27630 gcc_assert (! die
->die_mark
);
27631 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
27633 #endif /* ENABLE_ASSERT_CHECKING */
27635 /* Clear the marks for a die and its children.
27636 Be cool if the mark isn't set. */
27639 prune_unmark_dies (dw_die_ref die
)
27645 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
27648 /* Given LOC that is referenced by a DIE we're marking as used, find all
27649 referenced DWARF procedures it references and mark them as used. */
27652 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
27654 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
27655 switch (loc
->dw_loc_opc
)
27657 case DW_OP_implicit_pointer
:
27658 case DW_OP_convert
:
27659 case DW_OP_reinterpret
:
27660 case DW_OP_GNU_implicit_pointer
:
27661 case DW_OP_GNU_convert
:
27662 case DW_OP_GNU_reinterpret
:
27663 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
27664 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
27666 case DW_OP_GNU_variable_value
:
27667 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
27670 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
27673 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
27674 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
27675 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
27680 case DW_OP_call_ref
:
27681 case DW_OP_const_type
:
27682 case DW_OP_GNU_const_type
:
27683 case DW_OP_GNU_parameter_ref
:
27684 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
27685 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
27687 case DW_OP_regval_type
:
27688 case DW_OP_deref_type
:
27689 case DW_OP_GNU_regval_type
:
27690 case DW_OP_GNU_deref_type
:
27691 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
27692 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
27694 case DW_OP_entry_value
:
27695 case DW_OP_GNU_entry_value
:
27696 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
27697 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
27704 /* Given DIE that we're marking as used, find any other dies
27705 it references as attributes and mark them as used. */
27708 prune_unused_types_walk_attribs (dw_die_ref die
)
27713 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
27715 switch (AT_class (a
))
27717 /* Make sure DWARF procedures referenced by location descriptions will
27719 case dw_val_class_loc
:
27720 prune_unused_types_walk_loc_descr (AT_loc (a
));
27722 case dw_val_class_loc_list
:
27723 for (dw_loc_list_ref list
= AT_loc_list (a
);
27725 list
= list
->dw_loc_next
)
27726 prune_unused_types_walk_loc_descr (list
->expr
);
27729 case dw_val_class_die_ref
:
27730 /* A reference to another DIE.
27731 Make sure that it will get emitted.
27732 If it was broken out into a comdat group, don't follow it. */
27733 if (! AT_ref (a
)->comdat_type_p
27734 || a
->dw_attr
== DW_AT_specification
)
27735 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
27738 case dw_val_class_str
:
27739 /* Set the string's refcount to 0 so that prune_unused_types_mark
27740 accounts properly for it. */
27741 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
27750 /* Mark the generic parameters and arguments children DIEs of DIE. */
27753 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
27757 if (die
== NULL
|| die
->die_child
== NULL
)
27759 c
= die
->die_child
;
27762 if (is_template_parameter (c
))
27763 prune_unused_types_mark (c
, 1);
27765 } while (c
&& c
!= die
->die_child
);
27768 /* Mark DIE as being used. If DOKIDS is true, then walk down
27769 to DIE's children. */
27772 prune_unused_types_mark (dw_die_ref die
, int dokids
)
27776 if (die
->die_mark
== 0)
27778 /* We haven't done this node yet. Mark it as used. */
27780 /* If this is the DIE of a generic type instantiation,
27781 mark the children DIEs that describe its generic parms and
27783 prune_unused_types_mark_generic_parms_dies (die
);
27785 /* We also have to mark its parents as used.
27786 (But we don't want to mark our parent's kids due to this,
27787 unless it is a class.) */
27788 if (die
->die_parent
)
27789 prune_unused_types_mark (die
->die_parent
,
27790 class_scope_p (die
->die_parent
));
27792 /* Mark any referenced nodes. */
27793 prune_unused_types_walk_attribs (die
);
27795 /* If this node is a specification,
27796 also mark the definition, if it exists. */
27797 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
27798 prune_unused_types_mark (die
->die_definition
, 1);
27801 if (dokids
&& die
->die_mark
!= 2)
27803 /* We need to walk the children, but haven't done so yet.
27804 Remember that we've walked the kids. */
27807 /* If this is an array type, we need to make sure our
27808 kids get marked, even if they're types. If we're
27809 breaking out types into comdat sections, do this
27810 for all type definitions. */
27811 if (die
->die_tag
== DW_TAG_array_type
27812 || (use_debug_types
27813 && is_type_die (die
) && ! is_declaration_die (die
)))
27814 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
27816 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
27820 /* For local classes, look if any static member functions were emitted
27821 and if so, mark them. */
27824 prune_unused_types_walk_local_classes (dw_die_ref die
)
27828 if (die
->die_mark
== 2)
27831 switch (die
->die_tag
)
27833 case DW_TAG_structure_type
:
27834 case DW_TAG_union_type
:
27835 case DW_TAG_class_type
:
27838 case DW_TAG_subprogram
:
27839 if (!get_AT_flag (die
, DW_AT_declaration
)
27840 || die
->die_definition
!= NULL
)
27841 prune_unused_types_mark (die
, 1);
27848 /* Mark children. */
27849 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
27852 /* Walk the tree DIE and mark types that we actually use. */
27855 prune_unused_types_walk (dw_die_ref die
)
27859 /* Don't do anything if this node is already marked and
27860 children have been marked as well. */
27861 if (die
->die_mark
== 2)
27864 switch (die
->die_tag
)
27866 case DW_TAG_structure_type
:
27867 case DW_TAG_union_type
:
27868 case DW_TAG_class_type
:
27869 if (die
->die_perennial_p
)
27872 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
27873 if (c
->die_tag
== DW_TAG_subprogram
)
27876 /* Finding used static member functions inside of classes
27877 is needed just for local classes, because for other classes
27878 static member function DIEs with DW_AT_specification
27879 are emitted outside of the DW_TAG_*_type. If we ever change
27880 it, we'd need to call this even for non-local classes. */
27882 prune_unused_types_walk_local_classes (die
);
27884 /* It's a type node --- don't mark it. */
27887 case DW_TAG_const_type
:
27888 case DW_TAG_packed_type
:
27889 case DW_TAG_pointer_type
:
27890 case DW_TAG_reference_type
:
27891 case DW_TAG_rvalue_reference_type
:
27892 case DW_TAG_volatile_type
:
27893 case DW_TAG_typedef
:
27894 case DW_TAG_array_type
:
27895 case DW_TAG_interface_type
:
27896 case DW_TAG_friend
:
27897 case DW_TAG_enumeration_type
:
27898 case DW_TAG_subroutine_type
:
27899 case DW_TAG_string_type
:
27900 case DW_TAG_set_type
:
27901 case DW_TAG_subrange_type
:
27902 case DW_TAG_ptr_to_member_type
:
27903 case DW_TAG_file_type
:
27904 /* Type nodes are useful only when other DIEs reference them --- don't
27908 case DW_TAG_dwarf_procedure
:
27909 /* Likewise for DWARF procedures. */
27911 if (die
->die_perennial_p
)
27917 /* Mark everything else. */
27921 if (die
->die_mark
== 0)
27925 /* Now, mark any dies referenced from here. */
27926 prune_unused_types_walk_attribs (die
);
27931 /* Mark children. */
27932 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
27935 /* Increment the string counts on strings referred to from DIE's
27939 prune_unused_types_update_strings (dw_die_ref die
)
27944 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
27945 if (AT_class (a
) == dw_val_class_str
)
27947 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
27949 /* Avoid unnecessarily putting strings that are used less than
27950 twice in the hash table. */
27952 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
27954 indirect_string_node
**slot
27955 = debug_str_hash
->find_slot_with_hash (s
->str
,
27956 htab_hash_string (s
->str
),
27958 gcc_assert (*slot
== NULL
);
27964 /* Mark DIE and its children as removed. */
27967 mark_removed (dw_die_ref die
)
27970 die
->removed
= true;
27971 FOR_EACH_CHILD (die
, c
, mark_removed (c
));
27974 /* Remove from the tree DIE any dies that aren't marked. */
27977 prune_unused_types_prune (dw_die_ref die
)
27981 gcc_assert (die
->die_mark
);
27982 prune_unused_types_update_strings (die
);
27984 if (! die
->die_child
)
27987 c
= die
->die_child
;
27989 dw_die_ref prev
= c
, next
;
27990 for (c
= c
->die_sib
; ! c
->die_mark
; c
= next
)
27991 if (c
== die
->die_child
)
27993 /* No marked children between 'prev' and the end of the list. */
27995 /* No marked children at all. */
27996 die
->die_child
= NULL
;
27999 prev
->die_sib
= c
->die_sib
;
28000 die
->die_child
= prev
;
28013 if (c
!= prev
->die_sib
)
28015 prune_unused_types_prune (c
);
28016 } while (c
!= die
->die_child
);
28019 /* Remove dies representing declarations that we never use. */
28022 prune_unused_types (void)
28025 limbo_die_node
*node
;
28026 comdat_type_node
*ctnode
;
28027 pubname_entry
*pub
;
28028 dw_die_ref base_type
;
28030 #if ENABLE_ASSERT_CHECKING
28031 /* All the marks should already be clear. */
28032 verify_marks_clear (comp_unit_die ());
28033 for (node
= limbo_die_list
; node
; node
= node
->next
)
28034 verify_marks_clear (node
->die
);
28035 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
28036 verify_marks_clear (ctnode
->root_die
);
28037 #endif /* ENABLE_ASSERT_CHECKING */
28039 /* Mark types that are used in global variables. */
28040 premark_types_used_by_global_vars ();
28042 /* Set the mark on nodes that are actually used. */
28043 prune_unused_types_walk (comp_unit_die ());
28044 for (node
= limbo_die_list
; node
; node
= node
->next
)
28045 prune_unused_types_walk (node
->die
);
28046 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
28048 prune_unused_types_walk (ctnode
->root_die
);
28049 prune_unused_types_mark (ctnode
->type_die
, 1);
28052 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
28053 are unusual in that they are pubnames that are the children of pubtypes.
28054 They should only be marked via their parent DW_TAG_enumeration_type die,
28055 not as roots in themselves. */
28056 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
28057 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
28058 prune_unused_types_mark (pub
->die
, 1);
28059 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
28060 prune_unused_types_mark (base_type
, 1);
28062 /* For -fvar-tracking-assignments, also set the mark on nodes that could be
28063 referenced by DW_TAG_call_site DW_AT_call_origin (i.e. direct call
28065 cgraph_node
*cnode
;
28066 FOR_EACH_FUNCTION (cnode
)
28067 if (cnode
->referred_to_p (false))
28069 dw_die_ref die
= lookup_decl_die (cnode
->decl
);
28070 if (die
== NULL
|| die
->die_mark
)
28072 for (cgraph_edge
*e
= cnode
->callers
; e
; e
= e
->next_caller
)
28073 if (e
->caller
!= cnode
28074 && opt_for_fn (e
->caller
->decl
, flag_var_tracking_assignments
))
28076 prune_unused_types_mark (die
, 1);
28081 if (debug_str_hash
)
28082 debug_str_hash
->empty ();
28083 if (skeleton_debug_str_hash
)
28084 skeleton_debug_str_hash
->empty ();
28085 prune_unused_types_prune (comp_unit_die ());
28086 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
28089 if (!node
->die
->die_mark
)
28090 *pnode
= node
->next
;
28093 prune_unused_types_prune (node
->die
);
28094 pnode
= &node
->next
;
28097 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
28098 prune_unused_types_prune (ctnode
->root_die
);
28100 /* Leave the marks clear. */
28101 prune_unmark_dies (comp_unit_die ());
28102 for (node
= limbo_die_list
; node
; node
= node
->next
)
28103 prune_unmark_dies (node
->die
);
28104 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
28105 prune_unmark_dies (ctnode
->root_die
);
28108 /* Helpers to manipulate hash table of comdat type units. */
28110 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
28112 static inline hashval_t
hash (const comdat_type_node
*);
28113 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
28117 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
28120 memcpy (&h
, type_node
->signature
, sizeof (h
));
28125 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
28126 const comdat_type_node
*type_node_2
)
28128 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
28129 DWARF_TYPE_SIGNATURE_SIZE
));
28132 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
28133 to the location it would have been added, should we know its
28134 DECL_ASSEMBLER_NAME when we added other attributes. This will
28135 probably improve compactness of debug info, removing equivalent
28136 abbrevs, and hide any differences caused by deferring the
28137 computation of the assembler name, triggered by e.g. PCH. */
28140 move_linkage_attr (dw_die_ref die
)
28142 unsigned ix
= vec_safe_length (die
->die_attr
);
28143 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
28145 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
28146 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
28150 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
28152 if (prev
->dw_attr
== DW_AT_decl_line
28153 || prev
->dw_attr
== DW_AT_decl_column
28154 || prev
->dw_attr
== DW_AT_name
)
28158 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
28160 die
->die_attr
->pop ();
28161 die
->die_attr
->quick_insert (ix
, linkage
);
28165 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
28166 referenced from typed stack ops and count how often they are used. */
28169 mark_base_types (dw_loc_descr_ref loc
)
28171 dw_die_ref base_type
= NULL
;
28173 for (; loc
; loc
= loc
->dw_loc_next
)
28175 switch (loc
->dw_loc_opc
)
28177 case DW_OP_regval_type
:
28178 case DW_OP_deref_type
:
28179 case DW_OP_GNU_regval_type
:
28180 case DW_OP_GNU_deref_type
:
28181 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
28183 case DW_OP_convert
:
28184 case DW_OP_reinterpret
:
28185 case DW_OP_GNU_convert
:
28186 case DW_OP_GNU_reinterpret
:
28187 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
28190 case DW_OP_const_type
:
28191 case DW_OP_GNU_const_type
:
28192 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28194 case DW_OP_entry_value
:
28195 case DW_OP_GNU_entry_value
:
28196 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
28201 gcc_assert (base_type
->die_parent
== comp_unit_die ());
28202 if (base_type
->die_mark
)
28203 base_type
->die_mark
++;
28206 base_types
.safe_push (base_type
);
28207 base_type
->die_mark
= 1;
28212 /* Comparison function for sorting marked base types. */
28215 base_type_cmp (const void *x
, const void *y
)
28217 dw_die_ref dx
= *(const dw_die_ref
*) x
;
28218 dw_die_ref dy
= *(const dw_die_ref
*) y
;
28219 unsigned int byte_size1
, byte_size2
;
28220 unsigned int encoding1
, encoding2
;
28221 unsigned int align1
, align2
;
28222 if (dx
->die_mark
> dy
->die_mark
)
28224 if (dx
->die_mark
< dy
->die_mark
)
28226 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
28227 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
28228 if (byte_size1
< byte_size2
)
28230 if (byte_size1
> byte_size2
)
28232 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
28233 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
28234 if (encoding1
< encoding2
)
28236 if (encoding1
> encoding2
)
28238 align1
= get_AT_unsigned (dx
, DW_AT_alignment
);
28239 align2
= get_AT_unsigned (dy
, DW_AT_alignment
);
28240 if (align1
< align2
)
28242 if (align1
> align2
)
28247 /* Move base types marked by mark_base_types as early as possible
28248 in the CU, sorted by decreasing usage count both to make the
28249 uleb128 references as small as possible and to make sure they
28250 will have die_offset already computed by calc_die_sizes when
28251 sizes of typed stack loc ops is computed. */
28254 move_marked_base_types (void)
28257 dw_die_ref base_type
, die
, c
;
28259 if (base_types
.is_empty ())
28262 /* Sort by decreasing usage count, they will be added again in that
28264 base_types
.qsort (base_type_cmp
);
28265 die
= comp_unit_die ();
28266 c
= die
->die_child
;
28269 dw_die_ref prev
= c
;
28271 while (c
->die_mark
)
28273 remove_child_with_prev (c
, prev
);
28274 /* As base types got marked, there must be at least
28275 one node other than DW_TAG_base_type. */
28276 gcc_assert (die
->die_child
!= NULL
);
28280 while (c
!= die
->die_child
);
28281 gcc_assert (die
->die_child
);
28282 c
= die
->die_child
;
28283 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
28285 base_type
->die_mark
= 0;
28286 base_type
->die_sib
= c
->die_sib
;
28287 c
->die_sib
= base_type
;
28292 /* Helper function for resolve_addr, attempt to resolve
28293 one CONST_STRING, return true if successful. Similarly verify that
28294 SYMBOL_REFs refer to variables emitted in the current CU. */
28297 resolve_one_addr (rtx
*addr
)
28301 if (GET_CODE (rtl
) == CONST_STRING
)
28303 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
28304 tree t
= build_string (len
, XSTR (rtl
, 0));
28305 tree tlen
= size_int (len
- 1);
28307 = build_array_type (char_type_node
, build_index_type (tlen
));
28308 rtl
= lookup_constant_def (t
);
28309 if (!rtl
|| !MEM_P (rtl
))
28311 rtl
= XEXP (rtl
, 0);
28312 if (GET_CODE (rtl
) == SYMBOL_REF
28313 && SYMBOL_REF_DECL (rtl
)
28314 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
28316 vec_safe_push (used_rtx_array
, rtl
);
28321 if (GET_CODE (rtl
) == SYMBOL_REF
28322 && SYMBOL_REF_DECL (rtl
))
28324 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
28326 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
28329 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
28333 if (GET_CODE (rtl
) == CONST
)
28335 subrtx_ptr_iterator::array_type array
;
28336 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
28337 if (!resolve_one_addr (*iter
))
28344 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
28345 if possible, and create DW_TAG_dwarf_procedure that can be referenced
28346 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
28349 string_cst_pool_decl (tree t
)
28351 rtx rtl
= output_constant_def (t
, 1);
28352 unsigned char *array
;
28353 dw_loc_descr_ref l
;
28358 if (!rtl
|| !MEM_P (rtl
))
28360 rtl
= XEXP (rtl
, 0);
28361 if (GET_CODE (rtl
) != SYMBOL_REF
28362 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
28365 decl
= SYMBOL_REF_DECL (rtl
);
28366 if (!lookup_decl_die (decl
))
28368 len
= TREE_STRING_LENGTH (t
);
28369 vec_safe_push (used_rtx_array
, rtl
);
28370 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
28371 array
= ggc_vec_alloc
<unsigned char> (len
);
28372 memcpy (array
, TREE_STRING_POINTER (t
), len
);
28373 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
28374 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
28375 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
28376 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
28377 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
28378 add_AT_loc (ref
, DW_AT_location
, l
);
28379 equate_decl_number_to_die (decl
, ref
);
28384 /* Helper function of resolve_addr_in_expr. LOC is
28385 a DW_OP_addr followed by DW_OP_stack_value, either at the start
28386 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
28387 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
28388 with DW_OP_implicit_pointer if possible
28389 and return true, if unsuccessful, return false. */
28392 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
28394 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
28395 HOST_WIDE_INT offset
= 0;
28396 dw_die_ref ref
= NULL
;
28399 if (GET_CODE (rtl
) == CONST
28400 && GET_CODE (XEXP (rtl
, 0)) == PLUS
28401 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
28403 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
28404 rtl
= XEXP (XEXP (rtl
, 0), 0);
28406 if (GET_CODE (rtl
) == CONST_STRING
)
28408 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
28409 tree t
= build_string (len
, XSTR (rtl
, 0));
28410 tree tlen
= size_int (len
- 1);
28413 = build_array_type (char_type_node
, build_index_type (tlen
));
28414 rtl
= string_cst_pool_decl (t
);
28418 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
28420 decl
= SYMBOL_REF_DECL (rtl
);
28421 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
28423 ref
= lookup_decl_die (decl
);
28424 if (ref
&& (get_AT (ref
, DW_AT_location
)
28425 || get_AT (ref
, DW_AT_const_value
)))
28427 loc
->dw_loc_opc
= dwarf_OP (DW_OP_implicit_pointer
);
28428 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28429 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
28430 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28431 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28432 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
28433 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
28441 /* Helper function for resolve_addr, handle one location
28442 expression, return false if at least one CONST_STRING or SYMBOL_REF in
28443 the location list couldn't be resolved. */
28446 resolve_addr_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
28448 dw_loc_descr_ref keep
= NULL
;
28449 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
28450 switch (loc
->dw_loc_opc
)
28453 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
28456 || prev
->dw_loc_opc
== DW_OP_piece
28457 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
28458 && loc
->dw_loc_next
28459 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
28460 && (!dwarf_strict
|| dwarf_version
>= 5)
28461 && optimize_one_addr_into_implicit_ptr (loc
))
28466 case DW_OP_GNU_addr_index
:
28467 case DW_OP_GNU_const_index
:
28468 if (loc
->dw_loc_opc
== DW_OP_GNU_addr_index
28469 || (loc
->dw_loc_opc
== DW_OP_GNU_const_index
&& loc
->dtprel
))
28471 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
28472 if (!resolve_one_addr (&rtl
))
28474 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
28475 loc
->dw_loc_oprnd1
.val_entry
28476 = add_addr_table_entry (rtl
, ate_kind_rtx
);
28479 case DW_OP_const4u
:
28480 case DW_OP_const8u
:
28482 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
28485 case DW_OP_plus_uconst
:
28486 if (size_of_loc_descr (loc
)
28487 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
28489 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
28491 dw_loc_descr_ref repl
28492 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
28493 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
28494 add_loc_descr (&repl
, loc
->dw_loc_next
);
28498 case DW_OP_implicit_value
:
28499 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
28500 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
28503 case DW_OP_implicit_pointer
:
28504 case DW_OP_GNU_implicit_pointer
:
28505 case DW_OP_GNU_parameter_ref
:
28506 case DW_OP_GNU_variable_value
:
28507 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
28510 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
28513 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28514 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28515 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28517 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
)
28520 && loc
->dw_loc_next
== NULL
28521 && AT_class (a
) == dw_val_class_loc
)
28522 switch (a
->dw_attr
)
28524 /* Following attributes allow both exprloc and reference,
28525 so if the whole expression is DW_OP_GNU_variable_value
28526 alone we could transform it into reference. */
28527 case DW_AT_byte_size
:
28528 case DW_AT_bit_size
:
28529 case DW_AT_lower_bound
:
28530 case DW_AT_upper_bound
:
28531 case DW_AT_bit_stride
:
28533 case DW_AT_allocated
:
28534 case DW_AT_associated
:
28535 case DW_AT_byte_stride
:
28536 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
28537 a
->dw_attr_val
.val_entry
= NULL
;
28538 a
->dw_attr_val
.v
.val_die_ref
.die
28539 = loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28540 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
28549 case DW_OP_const_type
:
28550 case DW_OP_regval_type
:
28551 case DW_OP_deref_type
:
28552 case DW_OP_convert
:
28553 case DW_OP_reinterpret
:
28554 case DW_OP_GNU_const_type
:
28555 case DW_OP_GNU_regval_type
:
28556 case DW_OP_GNU_deref_type
:
28557 case DW_OP_GNU_convert
:
28558 case DW_OP_GNU_reinterpret
:
28559 while (loc
->dw_loc_next
28560 && (loc
->dw_loc_next
->dw_loc_opc
== DW_OP_convert
28561 || loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
))
28563 dw_die_ref base1
, base2
;
28564 unsigned enc1
, enc2
, size1
, size2
;
28565 if (loc
->dw_loc_opc
== DW_OP_regval_type
28566 || loc
->dw_loc_opc
== DW_OP_deref_type
28567 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
28568 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
28569 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
28570 else if (loc
->dw_loc_oprnd1
.val_class
28571 == dw_val_class_unsigned_const
)
28574 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28575 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
28576 == dw_val_class_unsigned_const
)
28578 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28579 gcc_assert (base1
->die_tag
== DW_TAG_base_type
28580 && base2
->die_tag
== DW_TAG_base_type
);
28581 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
28582 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
28583 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
28584 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
28586 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
28587 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
28591 /* Optimize away next DW_OP_convert after
28592 adjusting LOC's base type die reference. */
28593 if (loc
->dw_loc_opc
== DW_OP_regval_type
28594 || loc
->dw_loc_opc
== DW_OP_deref_type
28595 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
28596 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
28597 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
28599 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
28600 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
28603 /* Don't change integer DW_OP_convert after e.g. floating
28604 point typed stack entry. */
28605 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
28606 keep
= loc
->dw_loc_next
;
28616 /* Helper function of resolve_addr. DIE had DW_AT_location of
28617 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
28618 and DW_OP_addr couldn't be resolved. resolve_addr has already
28619 removed the DW_AT_location attribute. This function attempts to
28620 add a new DW_AT_location attribute with DW_OP_implicit_pointer
28621 to it or DW_AT_const_value attribute, if possible. */
28624 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
28627 || lookup_decl_die (decl
) != die
28628 || DECL_EXTERNAL (decl
)
28629 || !TREE_STATIC (decl
)
28630 || DECL_INITIAL (decl
) == NULL_TREE
28631 || DECL_P (DECL_INITIAL (decl
))
28632 || get_AT (die
, DW_AT_const_value
))
28635 tree init
= DECL_INITIAL (decl
);
28636 HOST_WIDE_INT offset
= 0;
28637 /* For variables that have been optimized away and thus
28638 don't have a memory location, see if we can emit
28639 DW_AT_const_value instead. */
28640 if (tree_add_const_value_attribute (die
, init
))
28642 if (dwarf_strict
&& dwarf_version
< 5)
28644 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
28645 and ADDR_EXPR refers to a decl that has DW_AT_location or
28646 DW_AT_const_value (but isn't addressable, otherwise
28647 resolving the original DW_OP_addr wouldn't fail), see if
28648 we can add DW_OP_implicit_pointer. */
28650 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
28651 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
28653 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
28654 init
= TREE_OPERAND (init
, 0);
28657 if (TREE_CODE (init
) != ADDR_EXPR
)
28659 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
28660 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
28661 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
28662 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
28663 && TREE_OPERAND (init
, 0) != decl
))
28666 dw_loc_descr_ref l
;
28668 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
28670 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
28673 decl
= SYMBOL_REF_DECL (rtl
);
28676 decl
= TREE_OPERAND (init
, 0);
28677 ref
= lookup_decl_die (decl
);
28679 || (!get_AT (ref
, DW_AT_location
)
28680 && !get_AT (ref
, DW_AT_const_value
)))
28682 l
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
28683 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28684 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28685 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28686 add_AT_loc (die
, DW_AT_location
, l
);
28690 /* Return NULL if l is a DWARF expression, or first op that is not
28691 valid DWARF expression. */
28693 static dw_loc_descr_ref
28694 non_dwarf_expression (dw_loc_descr_ref l
)
28698 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
28700 switch (l
->dw_loc_opc
)
28703 case DW_OP_implicit_value
:
28704 case DW_OP_stack_value
:
28705 case DW_OP_implicit_pointer
:
28706 case DW_OP_GNU_implicit_pointer
:
28707 case DW_OP_GNU_parameter_ref
:
28709 case DW_OP_bit_piece
:
28714 l
= l
->dw_loc_next
;
28719 /* Return adjusted copy of EXPR:
28720 If it is empty DWARF expression, return it.
28721 If it is valid non-empty DWARF expression,
28722 return copy of EXPR with DW_OP_deref appended to it.
28723 If it is DWARF expression followed by DW_OP_reg{N,x}, return
28724 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
28725 If it is DWARF expression followed by DW_OP_stack_value, return
28726 copy of the DWARF expression without anything appended.
28727 Otherwise, return NULL. */
28729 static dw_loc_descr_ref
28730 copy_deref_exprloc (dw_loc_descr_ref expr
)
28732 dw_loc_descr_ref tail
= NULL
;
28737 dw_loc_descr_ref l
= non_dwarf_expression (expr
);
28738 if (l
&& l
->dw_loc_next
)
28743 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
28744 tail
= new_loc_descr ((enum dwarf_location_atom
)
28745 (DW_OP_breg0
+ (l
->dw_loc_opc
- DW_OP_reg0
)),
28748 switch (l
->dw_loc_opc
)
28751 tail
= new_loc_descr (DW_OP_bregx
,
28752 l
->dw_loc_oprnd1
.v
.val_unsigned
, 0);
28754 case DW_OP_stack_value
:
28761 tail
= new_loc_descr (DW_OP_deref
, 0, 0);
28763 dw_loc_descr_ref ret
= NULL
, *p
= &ret
;
28766 *p
= new_loc_descr (expr
->dw_loc_opc
, 0, 0);
28767 (*p
)->dw_loc_oprnd1
= expr
->dw_loc_oprnd1
;
28768 (*p
)->dw_loc_oprnd2
= expr
->dw_loc_oprnd2
;
28769 p
= &(*p
)->dw_loc_next
;
28770 expr
= expr
->dw_loc_next
;
28776 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
28777 reference to a variable or argument, adjust it if needed and return:
28778 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
28779 attribute if present should be removed
28780 0 keep the attribute perhaps with minor modifications, no need to rescan
28781 1 if the attribute has been successfully adjusted. */
28784 optimize_string_length (dw_attr_node
*a
)
28786 dw_loc_descr_ref l
= AT_loc (a
), lv
;
28788 if (l
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
28790 tree decl
= l
->dw_loc_oprnd1
.v
.val_decl_ref
;
28791 die
= lookup_decl_die (decl
);
28794 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28795 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= die
;
28796 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28802 die
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28804 /* DWARF5 allows reference class, so we can then reference the DIE.
28805 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
28806 if (l
->dw_loc_next
!= NULL
&& dwarf_version
>= 5)
28808 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
28809 a
->dw_attr_val
.val_entry
= NULL
;
28810 a
->dw_attr_val
.v
.val_die_ref
.die
= die
;
28811 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
28815 dw_attr_node
*av
= get_AT (die
, DW_AT_location
);
28817 bool non_dwarf_expr
= false;
28820 return dwarf_strict
? -1 : 0;
28821 switch (AT_class (av
))
28823 case dw_val_class_loc_list
:
28824 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
28825 if (d
->expr
&& non_dwarf_expression (d
->expr
))
28826 non_dwarf_expr
= true;
28828 case dw_val_class_loc
:
28831 return dwarf_strict
? -1 : 0;
28832 if (non_dwarf_expression (lv
))
28833 non_dwarf_expr
= true;
28836 return dwarf_strict
? -1 : 0;
28839 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
28840 into DW_OP_call4 or DW_OP_GNU_variable_value into
28841 DW_OP_call4 DW_OP_deref, do so. */
28842 if (!non_dwarf_expr
28843 && (l
->dw_loc_next
!= NULL
|| AT_class (av
) == dw_val_class_loc
))
28845 l
->dw_loc_opc
= DW_OP_call4
;
28846 if (l
->dw_loc_next
)
28847 l
->dw_loc_next
= NULL
;
28849 l
->dw_loc_next
= new_loc_descr (DW_OP_deref
, 0, 0);
28853 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
28854 copy over the DW_AT_location attribute from die to a. */
28855 if (l
->dw_loc_next
!= NULL
)
28857 a
->dw_attr_val
= av
->dw_attr_val
;
28861 dw_loc_list_ref list
, *p
;
28862 switch (AT_class (av
))
28864 case dw_val_class_loc_list
:
28867 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
28869 lv
= copy_deref_exprloc (d
->expr
);
28872 *p
= new_loc_list (lv
, d
->begin
, d
->end
, d
->section
);
28873 p
= &(*p
)->dw_loc_next
;
28875 else if (!dwarf_strict
&& d
->expr
)
28879 return dwarf_strict
? -1 : 0;
28880 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
28882 *AT_loc_list_ptr (a
) = list
;
28884 case dw_val_class_loc
:
28885 lv
= copy_deref_exprloc (AT_loc (av
));
28887 return dwarf_strict
? -1 : 0;
28888 a
->dw_attr_val
.v
.val_loc
= lv
;
28891 gcc_unreachable ();
28895 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
28896 an address in .rodata section if the string literal is emitted there,
28897 or remove the containing location list or replace DW_AT_const_value
28898 with DW_AT_location and empty location expression, if it isn't found
28899 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
28900 to something that has been emitted in the current CU. */
28903 resolve_addr (dw_die_ref die
)
28907 dw_loc_list_ref
*curr
, *start
, loc
;
28909 bool remove_AT_byte_size
= false;
28911 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
28912 switch (AT_class (a
))
28914 case dw_val_class_loc_list
:
28915 start
= curr
= AT_loc_list_ptr (a
);
28918 /* The same list can be referenced more than once. See if we have
28919 already recorded the result from a previous pass. */
28921 *curr
= loc
->dw_loc_next
;
28922 else if (!loc
->resolved_addr
)
28924 /* As things stand, we do not expect or allow one die to
28925 reference a suffix of another die's location list chain.
28926 References must be identical or completely separate.
28927 There is therefore no need to cache the result of this
28928 pass on any list other than the first; doing so
28929 would lead to unnecessary writes. */
28932 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
28933 if (!resolve_addr_in_expr (a
, (*curr
)->expr
))
28935 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
28936 dw_loc_descr_ref l
= (*curr
)->expr
;
28938 if (next
&& (*curr
)->ll_symbol
)
28940 gcc_assert (!next
->ll_symbol
);
28941 next
->ll_symbol
= (*curr
)->ll_symbol
;
28943 if (dwarf_split_debug_info
)
28944 remove_loc_list_addr_table_entries (l
);
28949 mark_base_types ((*curr
)->expr
);
28950 curr
= &(*curr
)->dw_loc_next
;
28954 loc
->resolved_addr
= 1;
28958 loc
->dw_loc_next
= *start
;
28963 remove_AT (die
, a
->dw_attr
);
28967 case dw_val_class_loc
:
28969 dw_loc_descr_ref l
= AT_loc (a
);
28970 /* DW_OP_GNU_variable_value DW_OP_stack_value or
28971 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
28972 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
28973 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
28974 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
28975 with DW_FORM_ref referencing the same DIE as
28976 DW_OP_GNU_variable_value used to reference. */
28977 if (a
->dw_attr
== DW_AT_string_length
28979 && l
->dw_loc_opc
== DW_OP_GNU_variable_value
28980 && (l
->dw_loc_next
== NULL
28981 || (l
->dw_loc_next
->dw_loc_next
== NULL
28982 && l
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
)))
28984 switch (optimize_string_length (a
))
28987 remove_AT (die
, a
->dw_attr
);
28989 /* If we drop DW_AT_string_length, we need to drop also
28990 DW_AT_{string_length_,}byte_size. */
28991 remove_AT_byte_size
= true;
28996 /* Even if we keep the optimized DW_AT_string_length,
28997 it might have changed AT_class, so process it again. */
29002 /* For -gdwarf-2 don't attempt to optimize
29003 DW_AT_data_member_location containing
29004 DW_OP_plus_uconst - older consumers might
29005 rely on it being that op instead of a more complex,
29006 but shorter, location description. */
29007 if ((dwarf_version
> 2
29008 || a
->dw_attr
!= DW_AT_data_member_location
29010 || l
->dw_loc_opc
!= DW_OP_plus_uconst
29011 || l
->dw_loc_next
!= NULL
)
29012 && !resolve_addr_in_expr (a
, l
))
29014 if (dwarf_split_debug_info
)
29015 remove_loc_list_addr_table_entries (l
);
29017 && l
->dw_loc_next
== NULL
29018 && l
->dw_loc_opc
== DW_OP_addr
29019 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
29020 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
29021 && a
->dw_attr
== DW_AT_location
)
29023 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
29024 remove_AT (die
, a
->dw_attr
);
29026 optimize_location_into_implicit_ptr (die
, decl
);
29029 if (a
->dw_attr
== DW_AT_string_length
)
29030 /* If we drop DW_AT_string_length, we need to drop also
29031 DW_AT_{string_length_,}byte_size. */
29032 remove_AT_byte_size
= true;
29033 remove_AT (die
, a
->dw_attr
);
29037 mark_base_types (l
);
29040 case dw_val_class_addr
:
29041 if (a
->dw_attr
== DW_AT_const_value
29042 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
29044 if (AT_index (a
) != NOT_INDEXED
)
29045 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
29046 remove_AT (die
, a
->dw_attr
);
29049 if ((die
->die_tag
== DW_TAG_call_site
29050 && a
->dw_attr
== DW_AT_call_origin
)
29051 || (die
->die_tag
== DW_TAG_GNU_call_site
29052 && a
->dw_attr
== DW_AT_abstract_origin
))
29054 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
29055 dw_die_ref tdie
= lookup_decl_die (tdecl
);
29058 && DECL_EXTERNAL (tdecl
)
29059 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
29060 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
29062 dw_die_ref pdie
= cdie
;
29063 /* Make sure we don't add these DIEs into type units.
29064 We could emit skeleton DIEs for context (namespaces,
29065 outer structs/classes) and a skeleton DIE for the
29066 innermost context with DW_AT_signature pointing to the
29067 type unit. See PR78835. */
29068 while (pdie
&& pdie
->die_tag
!= DW_TAG_type_unit
)
29069 pdie
= pdie
->die_parent
;
29072 /* Creating a full DIE for tdecl is overly expensive and
29073 at this point even wrong when in the LTO phase
29074 as it can end up generating new type DIEs we didn't
29075 output and thus optimize_external_refs will crash. */
29076 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
29077 add_AT_flag (tdie
, DW_AT_external
, 1);
29078 add_AT_flag (tdie
, DW_AT_declaration
, 1);
29079 add_linkage_attr (tdie
, tdecl
);
29080 add_name_and_src_coords_attributes (tdie
, tdecl
, true);
29081 equate_decl_number_to_die (tdecl
, tdie
);
29086 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
29087 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
29088 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
29092 if (AT_index (a
) != NOT_INDEXED
)
29093 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
29094 remove_AT (die
, a
->dw_attr
);
29103 if (remove_AT_byte_size
)
29104 remove_AT (die
, dwarf_version
>= 5
29105 ? DW_AT_string_length_byte_size
29106 : DW_AT_byte_size
);
29108 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
29111 /* Helper routines for optimize_location_lists.
29112 This pass tries to share identical local lists in .debug_loc
29115 /* Iteratively hash operands of LOC opcode into HSTATE. */
29118 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
29120 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
29121 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
29123 switch (loc
->dw_loc_opc
)
29125 case DW_OP_const4u
:
29126 case DW_OP_const8u
:
29130 case DW_OP_const1u
:
29131 case DW_OP_const1s
:
29132 case DW_OP_const2u
:
29133 case DW_OP_const2s
:
29134 case DW_OP_const4s
:
29135 case DW_OP_const8s
:
29139 case DW_OP_plus_uconst
:
29175 case DW_OP_deref_size
:
29176 case DW_OP_xderef_size
:
29177 hstate
.add_object (val1
->v
.val_int
);
29184 gcc_assert (val1
->val_class
== dw_val_class_loc
);
29185 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
29186 hstate
.add_object (offset
);
29189 case DW_OP_implicit_value
:
29190 hstate
.add_object (val1
->v
.val_unsigned
);
29191 switch (val2
->val_class
)
29193 case dw_val_class_const
:
29194 hstate
.add_object (val2
->v
.val_int
);
29196 case dw_val_class_vec
:
29198 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
29199 unsigned int len
= val2
->v
.val_vec
.length
;
29201 hstate
.add_int (elt_size
);
29202 hstate
.add_int (len
);
29203 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
29206 case dw_val_class_const_double
:
29207 hstate
.add_object (val2
->v
.val_double
.low
);
29208 hstate
.add_object (val2
->v
.val_double
.high
);
29210 case dw_val_class_wide_int
:
29211 hstate
.add (val2
->v
.val_wide
->get_val (),
29212 get_full_len (*val2
->v
.val_wide
)
29213 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
29215 case dw_val_class_addr
:
29216 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
29219 gcc_unreachable ();
29223 case DW_OP_bit_piece
:
29224 hstate
.add_object (val1
->v
.val_int
);
29225 hstate
.add_object (val2
->v
.val_int
);
29231 unsigned char dtprel
= 0xd1;
29232 hstate
.add_object (dtprel
);
29234 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
29236 case DW_OP_GNU_addr_index
:
29237 case DW_OP_GNU_const_index
:
29241 unsigned char dtprel
= 0xd1;
29242 hstate
.add_object (dtprel
);
29244 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
29247 case DW_OP_implicit_pointer
:
29248 case DW_OP_GNU_implicit_pointer
:
29249 hstate
.add_int (val2
->v
.val_int
);
29251 case DW_OP_entry_value
:
29252 case DW_OP_GNU_entry_value
:
29253 hstate
.add_object (val1
->v
.val_loc
);
29255 case DW_OP_regval_type
:
29256 case DW_OP_deref_type
:
29257 case DW_OP_GNU_regval_type
:
29258 case DW_OP_GNU_deref_type
:
29260 unsigned int byte_size
29261 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
29262 unsigned int encoding
29263 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
29264 hstate
.add_object (val1
->v
.val_int
);
29265 hstate
.add_object (byte_size
);
29266 hstate
.add_object (encoding
);
29269 case DW_OP_convert
:
29270 case DW_OP_reinterpret
:
29271 case DW_OP_GNU_convert
:
29272 case DW_OP_GNU_reinterpret
:
29273 if (val1
->val_class
== dw_val_class_unsigned_const
)
29275 hstate
.add_object (val1
->v
.val_unsigned
);
29279 case DW_OP_const_type
:
29280 case DW_OP_GNU_const_type
:
29282 unsigned int byte_size
29283 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
29284 unsigned int encoding
29285 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
29286 hstate
.add_object (byte_size
);
29287 hstate
.add_object (encoding
);
29288 if (loc
->dw_loc_opc
!= DW_OP_const_type
29289 && loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
29291 hstate
.add_object (val2
->val_class
);
29292 switch (val2
->val_class
)
29294 case dw_val_class_const
:
29295 hstate
.add_object (val2
->v
.val_int
);
29297 case dw_val_class_vec
:
29299 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
29300 unsigned int len
= val2
->v
.val_vec
.length
;
29302 hstate
.add_object (elt_size
);
29303 hstate
.add_object (len
);
29304 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
29307 case dw_val_class_const_double
:
29308 hstate
.add_object (val2
->v
.val_double
.low
);
29309 hstate
.add_object (val2
->v
.val_double
.high
);
29311 case dw_val_class_wide_int
:
29312 hstate
.add (val2
->v
.val_wide
->get_val (),
29313 get_full_len (*val2
->v
.val_wide
)
29314 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
29317 gcc_unreachable ();
29323 /* Other codes have no operands. */
29328 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
29331 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
29333 dw_loc_descr_ref l
;
29334 bool sizes_computed
= false;
29335 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
29336 size_of_locs (loc
);
29338 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
29340 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
29341 hstate
.add_object (opc
);
29342 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
29344 size_of_locs (loc
);
29345 sizes_computed
= true;
29347 hash_loc_operands (l
, hstate
);
29351 /* Compute hash of the whole location list LIST_HEAD. */
29354 hash_loc_list (dw_loc_list_ref list_head
)
29356 dw_loc_list_ref curr
= list_head
;
29357 inchash::hash hstate
;
29359 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
29361 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
29362 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
29364 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
29365 hash_locs (curr
->expr
, hstate
);
29367 list_head
->hash
= hstate
.end ();
29370 /* Return true if X and Y opcodes have the same operands. */
29373 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
29375 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
29376 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
29377 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
29378 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
29380 switch (x
->dw_loc_opc
)
29382 case DW_OP_const4u
:
29383 case DW_OP_const8u
:
29387 case DW_OP_const1u
:
29388 case DW_OP_const1s
:
29389 case DW_OP_const2u
:
29390 case DW_OP_const2s
:
29391 case DW_OP_const4s
:
29392 case DW_OP_const8s
:
29396 case DW_OP_plus_uconst
:
29432 case DW_OP_deref_size
:
29433 case DW_OP_xderef_size
:
29434 return valx1
->v
.val_int
== valy1
->v
.val_int
;
29437 /* If splitting debug info, the use of DW_OP_GNU_addr_index
29438 can cause irrelevant differences in dw_loc_addr. */
29439 gcc_assert (valx1
->val_class
== dw_val_class_loc
29440 && valy1
->val_class
== dw_val_class_loc
29441 && (dwarf_split_debug_info
29442 || x
->dw_loc_addr
== y
->dw_loc_addr
));
29443 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
29444 case DW_OP_implicit_value
:
29445 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
29446 || valx2
->val_class
!= valy2
->val_class
)
29448 switch (valx2
->val_class
)
29450 case dw_val_class_const
:
29451 return valx2
->v
.val_int
== valy2
->v
.val_int
;
29452 case dw_val_class_vec
:
29453 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
29454 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
29455 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
29456 valx2
->v
.val_vec
.elt_size
29457 * valx2
->v
.val_vec
.length
) == 0;
29458 case dw_val_class_const_double
:
29459 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
29460 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
29461 case dw_val_class_wide_int
:
29462 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
29463 case dw_val_class_addr
:
29464 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
29466 gcc_unreachable ();
29469 case DW_OP_bit_piece
:
29470 return valx1
->v
.val_int
== valy1
->v
.val_int
29471 && valx2
->v
.val_int
== valy2
->v
.val_int
;
29474 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
29475 case DW_OP_GNU_addr_index
:
29476 case DW_OP_GNU_const_index
:
29478 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
29479 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
29480 return rtx_equal_p (ax1
, ay1
);
29482 case DW_OP_implicit_pointer
:
29483 case DW_OP_GNU_implicit_pointer
:
29484 return valx1
->val_class
== dw_val_class_die_ref
29485 && valx1
->val_class
== valy1
->val_class
29486 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
29487 && valx2
->v
.val_int
== valy2
->v
.val_int
;
29488 case DW_OP_entry_value
:
29489 case DW_OP_GNU_entry_value
:
29490 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
29491 case DW_OP_const_type
:
29492 case DW_OP_GNU_const_type
:
29493 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
29494 || valx2
->val_class
!= valy2
->val_class
)
29496 switch (valx2
->val_class
)
29498 case dw_val_class_const
:
29499 return valx2
->v
.val_int
== valy2
->v
.val_int
;
29500 case dw_val_class_vec
:
29501 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
29502 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
29503 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
29504 valx2
->v
.val_vec
.elt_size
29505 * valx2
->v
.val_vec
.length
) == 0;
29506 case dw_val_class_const_double
:
29507 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
29508 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
29509 case dw_val_class_wide_int
:
29510 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
29512 gcc_unreachable ();
29514 case DW_OP_regval_type
:
29515 case DW_OP_deref_type
:
29516 case DW_OP_GNU_regval_type
:
29517 case DW_OP_GNU_deref_type
:
29518 return valx1
->v
.val_int
== valy1
->v
.val_int
29519 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
29520 case DW_OP_convert
:
29521 case DW_OP_reinterpret
:
29522 case DW_OP_GNU_convert
:
29523 case DW_OP_GNU_reinterpret
:
29524 if (valx1
->val_class
!= valy1
->val_class
)
29526 if (valx1
->val_class
== dw_val_class_unsigned_const
)
29527 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
29528 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
29529 case DW_OP_GNU_parameter_ref
:
29530 return valx1
->val_class
== dw_val_class_die_ref
29531 && valx1
->val_class
== valy1
->val_class
29532 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
29534 /* Other codes have no operands. */
29539 /* Return true if DWARF location expressions X and Y are the same. */
29542 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
29544 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
29545 if (x
->dw_loc_opc
!= y
->dw_loc_opc
29546 || x
->dtprel
!= y
->dtprel
29547 || !compare_loc_operands (x
, y
))
29549 return x
== NULL
&& y
== NULL
;
29552 /* Hashtable helpers. */
29554 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
29556 static inline hashval_t
hash (const dw_loc_list_struct
*);
29557 static inline bool equal (const dw_loc_list_struct
*,
29558 const dw_loc_list_struct
*);
29561 /* Return precomputed hash of location list X. */
29564 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
29569 /* Return true if location lists A and B are the same. */
29572 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
29573 const dw_loc_list_struct
*b
)
29577 if (a
->hash
!= b
->hash
)
29579 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
29580 if (strcmp (a
->begin
, b
->begin
) != 0
29581 || strcmp (a
->end
, b
->end
) != 0
29582 || (a
->section
== NULL
) != (b
->section
== NULL
)
29583 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
29584 || !compare_locs (a
->expr
, b
->expr
))
29586 return a
== NULL
&& b
== NULL
;
29589 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
29592 /* Recursively optimize location lists referenced from DIE
29593 children and share them whenever possible. */
29596 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
29601 dw_loc_list_struct
**slot
;
29603 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29604 if (AT_class (a
) == dw_val_class_loc_list
)
29606 dw_loc_list_ref list
= AT_loc_list (a
);
29607 /* TODO: perform some optimizations here, before hashing
29608 it and storing into the hash table. */
29609 hash_loc_list (list
);
29610 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
29614 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
29617 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
29621 /* Recursively assign each location list a unique index into the debug_addr
29625 index_location_lists (dw_die_ref die
)
29631 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29632 if (AT_class (a
) == dw_val_class_loc_list
)
29634 dw_loc_list_ref list
= AT_loc_list (a
);
29635 dw_loc_list_ref curr
;
29636 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
29638 /* Don't index an entry that has already been indexed
29639 or won't be output. */
29640 if (curr
->begin_entry
!= NULL
29641 || (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
))
29645 = add_addr_table_entry (xstrdup (curr
->begin
), ate_kind_label
);
29649 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
29652 /* Optimize location lists referenced from DIE
29653 children and share them whenever possible. */
29656 optimize_location_lists (dw_die_ref die
)
29658 loc_list_hash_type
htab (500);
29659 optimize_location_lists_1 (die
, &htab
);
29662 /* Traverse the limbo die list, and add parent/child links. The only
29663 dies without parents that should be here are concrete instances of
29664 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
29665 For concrete instances, we can get the parent die from the abstract
29669 flush_limbo_die_list (void)
29671 limbo_die_node
*node
;
29673 /* get_context_die calls force_decl_die, which can put new DIEs on the
29674 limbo list in LTO mode when nested functions are put in a different
29675 partition than that of their parent function. */
29676 while ((node
= limbo_die_list
))
29678 dw_die_ref die
= node
->die
;
29679 limbo_die_list
= node
->next
;
29681 if (die
->die_parent
== NULL
)
29683 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
29685 if (origin
&& origin
->die_parent
)
29686 add_child_die (origin
->die_parent
, die
);
29687 else if (is_cu_die (die
))
29689 else if (seen_error ())
29690 /* It's OK to be confused by errors in the input. */
29691 add_child_die (comp_unit_die (), die
);
29694 /* In certain situations, the lexical block containing a
29695 nested function can be optimized away, which results
29696 in the nested function die being orphaned. Likewise
29697 with the return type of that nested function. Force
29698 this to be a child of the containing function.
29700 It may happen that even the containing function got fully
29701 inlined and optimized out. In that case we are lost and
29702 assign the empty child. This should not be big issue as
29703 the function is likely unreachable too. */
29704 gcc_assert (node
->created_for
);
29706 if (DECL_P (node
->created_for
))
29707 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
29708 else if (TYPE_P (node
->created_for
))
29709 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
29711 origin
= comp_unit_die ();
29713 add_child_die (origin
, die
);
29719 /* Reset DIEs so we can output them again. */
29722 reset_dies (dw_die_ref die
)
29726 /* Remove stuff we re-generate. */
29728 die
->die_offset
= 0;
29729 die
->die_abbrev
= 0;
29730 remove_AT (die
, DW_AT_sibling
);
29732 FOR_EACH_CHILD (die
, c
, reset_dies (c
));
29735 /* Output stuff that dwarf requires at the end of every file,
29736 and generate the DWARF-2 debugging info. */
29739 dwarf2out_finish (const char *)
29741 comdat_type_node
*ctnode
;
29742 dw_die_ref main_comp_unit_die
;
29743 unsigned char checksum
[16];
29744 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
29746 /* Flush out any latecomers to the limbo party. */
29747 flush_limbo_die_list ();
29751 verify_die (comp_unit_die ());
29752 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
29753 verify_die (node
->die
);
29756 /* We shouldn't have any symbols with delayed asm names for
29757 DIEs generated after early finish. */
29758 gcc_assert (deferred_asm_name
== NULL
);
29760 gen_remaining_tmpl_value_param_die_attribute ();
29762 if (flag_generate_lto
|| flag_generate_offload
)
29764 gcc_assert (flag_fat_lto_objects
|| flag_generate_offload
);
29766 /* Prune stuff so that dwarf2out_finish runs successfully
29767 for the fat part of the object. */
29768 reset_dies (comp_unit_die ());
29769 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
29770 reset_dies (node
->die
);
29772 hash_table
<comdat_type_hasher
> comdat_type_table (100);
29773 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
29775 comdat_type_node
**slot
29776 = comdat_type_table
.find_slot (ctnode
, INSERT
);
29778 /* Don't reset types twice. */
29779 if (*slot
!= HTAB_EMPTY_ENTRY
)
29782 /* Add a pointer to the line table for the main compilation unit
29783 so that the debugger can make sense of DW_AT_decl_file
29785 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
29786 reset_dies (ctnode
->root_die
);
29791 /* Reset die CU symbol so we don't output it twice. */
29792 comp_unit_die ()->die_id
.die_symbol
= NULL
;
29794 /* Remove DW_AT_macro from the early output. */
29796 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
);
29798 /* Remove indirect string decisions. */
29799 debug_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
29802 #if ENABLE_ASSERT_CHECKING
29804 dw_die_ref die
= comp_unit_die (), c
;
29805 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
29808 resolve_addr (comp_unit_die ());
29809 move_marked_base_types ();
29811 /* Initialize sections and labels used for actual assembler output. */
29812 init_sections_and_labels (false);
29814 /* Traverse the DIE's and add sibling attributes to those DIE's that
29816 add_sibling_attributes (comp_unit_die ());
29817 limbo_die_node
*node
;
29818 for (node
= cu_die_list
; node
; node
= node
->next
)
29819 add_sibling_attributes (node
->die
);
29820 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
29821 add_sibling_attributes (ctnode
->root_die
);
29823 /* When splitting DWARF info, we put some attributes in the
29824 skeleton compile_unit DIE that remains in the .o, while
29825 most attributes go in the DWO compile_unit_die. */
29826 if (dwarf_split_debug_info
)
29828 limbo_die_node
*cu
;
29829 main_comp_unit_die
= gen_compile_unit_die (NULL
);
29830 if (dwarf_version
>= 5)
29831 main_comp_unit_die
->die_tag
= DW_TAG_skeleton_unit
;
29832 cu
= limbo_die_list
;
29833 gcc_assert (cu
->die
== main_comp_unit_die
);
29834 limbo_die_list
= limbo_die_list
->next
;
29835 cu
->next
= cu_die_list
;
29839 main_comp_unit_die
= comp_unit_die ();
29841 /* Output a terminator label for the .text section. */
29842 switch_to_section (text_section
);
29843 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
29844 if (cold_text_section
)
29846 switch_to_section (cold_text_section
);
29847 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
29850 /* We can only use the low/high_pc attributes if all of the code was
29852 if (!have_multiple_function_sections
29853 || (dwarf_version
< 3 && dwarf_strict
))
29855 /* Don't add if the CU has no associated code. */
29856 if (text_section_used
)
29857 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
29858 text_end_label
, true);
29864 bool range_list_added
= false;
29866 if (text_section_used
)
29867 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
29868 text_end_label
, &range_list_added
, true);
29869 if (cold_text_section_used
)
29870 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
29871 cold_end_label
, &range_list_added
, true);
29873 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
29875 if (DECL_IGNORED_P (fde
->decl
))
29877 if (!fde
->in_std_section
)
29878 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
29879 fde
->dw_fde_end
, &range_list_added
,
29881 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
29882 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
29883 fde
->dw_fde_second_end
, &range_list_added
,
29887 if (range_list_added
)
29889 /* We need to give .debug_loc and .debug_ranges an appropriate
29890 "base address". Use zero so that these addresses become
29891 absolute. Historically, we've emitted the unexpected
29892 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
29893 Emit both to give time for other tools to adapt. */
29894 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
29895 if (! dwarf_strict
&& dwarf_version
< 4)
29896 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
29902 /* AIX Assembler inserts the length, so adjust the reference to match the
29903 offset expected by debuggers. */
29904 strcpy (dl_section_ref
, debug_line_section_label
);
29905 if (XCOFF_DEBUGGING_INFO
)
29906 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
29908 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
29909 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
29913 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
29914 macinfo_section_label
);
29916 if (dwarf_split_debug_info
)
29918 if (have_location_lists
)
29920 if (dwarf_version
>= 5)
29921 add_AT_loclistsptr (comp_unit_die (), DW_AT_loclists_base
,
29922 loc_section_label
);
29923 /* optimize_location_lists calculates the size of the lists,
29924 so index them first, and assign indices to the entries.
29925 Although optimize_location_lists will remove entries from
29926 the table, it only does so for duplicates, and therefore
29927 only reduces ref_counts to 1. */
29928 index_location_lists (comp_unit_die ());
29931 if (addr_index_table
!= NULL
)
29933 unsigned int index
= 0;
29935 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
29941 if (have_location_lists
)
29943 optimize_location_lists (comp_unit_die ());
29944 /* And finally assign indexes to the entries for -gsplit-dwarf. */
29945 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
29946 assign_location_list_indexes (comp_unit_die ());
29949 save_macinfo_strings ();
29951 if (dwarf_split_debug_info
)
29953 unsigned int index
= 0;
29955 /* Add attributes common to skeleton compile_units and
29956 type_units. Because these attributes include strings, it
29957 must be done before freezing the string table. Top-level
29958 skeleton die attrs are added when the skeleton type unit is
29959 created, so ensure it is created by this point. */
29960 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
29961 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
29964 /* Output all of the compilation units. We put the main one last so that
29965 the offsets are available to output_pubnames. */
29966 for (node
= cu_die_list
; node
; node
= node
->next
)
29967 output_comp_unit (node
->die
, 0, NULL
);
29969 hash_table
<comdat_type_hasher
> comdat_type_table (100);
29970 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
29972 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
29974 /* Don't output duplicate types. */
29975 if (*slot
!= HTAB_EMPTY_ENTRY
)
29978 /* Add a pointer to the line table for the main compilation unit
29979 so that the debugger can make sense of DW_AT_decl_file
29981 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
29982 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
29983 (!dwarf_split_debug_info
29985 : debug_skeleton_line_section_label
));
29987 output_comdat_type_unit (ctnode
);
29991 if (dwarf_split_debug_info
)
29994 struct md5_ctx ctx
;
29996 if (dwarf_version
>= 5 && !vec_safe_is_empty (ranges_table
))
29999 /* Compute a checksum of the comp_unit to use as the dwo_id. */
30000 md5_init_ctx (&ctx
);
30002 die_checksum (comp_unit_die (), &ctx
, &mark
);
30003 unmark_all_dies (comp_unit_die ());
30004 md5_finish_ctx (&ctx
, checksum
);
30006 if (dwarf_version
< 5)
30008 /* Use the first 8 bytes of the checksum as the dwo_id,
30009 and add it to both comp-unit DIEs. */
30010 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
30011 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
30014 /* Add the base offset of the ranges table to the skeleton
30016 if (!vec_safe_is_empty (ranges_table
))
30018 if (dwarf_version
>= 5)
30019 add_AT_lineptr (main_comp_unit_die
, DW_AT_rnglists_base
,
30020 ranges_base_label
);
30022 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
30023 ranges_section_label
);
30026 switch_to_section (debug_addr_section
);
30027 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
30028 output_addr_table ();
30031 /* Output the main compilation unit if non-empty or if .debug_macinfo
30032 or .debug_macro will be emitted. */
30033 output_comp_unit (comp_unit_die (), have_macinfo
,
30034 dwarf_split_debug_info
? checksum
: NULL
);
30036 if (dwarf_split_debug_info
&& info_section_emitted
)
30037 output_skeleton_debug_sections (main_comp_unit_die
, checksum
);
30039 /* Output the abbreviation table. */
30040 if (vec_safe_length (abbrev_die_table
) != 1)
30042 switch_to_section (debug_abbrev_section
);
30043 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
30044 output_abbrev_section ();
30047 /* Output location list section if necessary. */
30048 if (have_location_lists
)
30050 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
30051 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
30052 /* Output the location lists info. */
30053 switch_to_section (debug_loc_section
);
30054 if (dwarf_version
>= 5)
30056 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_LOC_SECTION_LABEL
, 1);
30057 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_LOC_SECTION_LABEL
, 2);
30058 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
30059 dw2_asm_output_data (4, 0xffffffff,
30060 "Initial length escape value indicating "
30061 "64-bit DWARF extension");
30062 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
30063 "Length of Location Lists");
30064 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
30065 dw2_asm_output_data (2, dwarf_version
, "DWARF Version");
30066 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
30067 dw2_asm_output_data (1, 0, "Segment Size");
30068 dw2_asm_output_data (4, dwarf_split_debug_info
? loc_list_idx
: 0,
30069 "Offset Entry Count");
30071 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
30072 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
30074 unsigned int save_loc_list_idx
= loc_list_idx
;
30076 output_loclists_offsets (comp_unit_die ());
30077 gcc_assert (save_loc_list_idx
== loc_list_idx
);
30079 output_location_lists (comp_unit_die ());
30080 if (dwarf_version
>= 5)
30081 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
30084 output_pubtables ();
30086 /* Output the address range information if a CU (.debug_info section)
30087 was emitted. We output an empty table even if we had no functions
30088 to put in it. This because the consumer has no way to tell the
30089 difference between an empty table that we omitted and failure to
30090 generate a table that would have contained data. */
30091 if (info_section_emitted
)
30093 switch_to_section (debug_aranges_section
);
30097 /* Output ranges section if necessary. */
30098 if (!vec_safe_is_empty (ranges_table
))
30100 if (dwarf_version
>= 5)
30101 output_rnglists ();
30106 /* Have to end the macro section. */
30109 switch_to_section (debug_macinfo_section
);
30110 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
30111 output_macinfo (!dwarf_split_debug_info
? debug_line_section_label
30112 : debug_skeleton_line_section_label
, false);
30113 dw2_asm_output_data (1, 0, "End compilation unit");
30116 /* Output the source line correspondence table. We must do this
30117 even if there is no line information. Otherwise, on an empty
30118 translation unit, we will generate a present, but empty,
30119 .debug_info section. IRIX 6.5 `nm' will then complain when
30120 examining the file. This is done late so that any filenames
30121 used by the debug_info section are marked as 'used'. */
30122 switch_to_section (debug_line_section
);
30123 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
30124 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
30125 output_line_info (false);
30127 if (dwarf_split_debug_info
&& info_section_emitted
)
30129 switch_to_section (debug_skeleton_line_section
);
30130 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
30131 output_line_info (true);
30134 /* If we emitted any indirect strings, output the string table too. */
30135 if (debug_str_hash
|| skeleton_debug_str_hash
)
30136 output_indirect_strings ();
30137 if (debug_line_str_hash
)
30139 switch_to_section (debug_line_str_section
);
30140 const enum dwarf_form form
= DW_FORM_line_strp
;
30141 debug_line_str_hash
->traverse
<enum dwarf_form
,
30142 output_indirect_string
> (form
);
30146 /* Returns a hash value for X (which really is a variable_value_struct). */
30149 variable_value_hasher::hash (variable_value_struct
*x
)
30151 return (hashval_t
) x
->decl_id
;
30154 /* Return nonzero if decl_id of variable_value_struct X is the same as
30158 variable_value_hasher::equal (variable_value_struct
*x
, tree y
)
30160 return x
->decl_id
== DECL_UID (y
);
30163 /* Helper function for resolve_variable_value, handle
30164 DW_OP_GNU_variable_value in one location expression.
30165 Return true if exprloc has been changed into loclist. */
30168 resolve_variable_value_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
30170 dw_loc_descr_ref next
;
30171 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= next
)
30173 next
= loc
->dw_loc_next
;
30174 if (loc
->dw_loc_opc
!= DW_OP_GNU_variable_value
30175 || loc
->dw_loc_oprnd1
.val_class
!= dw_val_class_decl_ref
)
30178 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
30179 if (DECL_CONTEXT (decl
) != current_function_decl
)
30182 dw_die_ref ref
= lookup_decl_die (decl
);
30185 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30186 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30187 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30190 dw_loc_list_ref l
= loc_list_from_tree (decl
, 0, NULL
);
30193 if (l
->dw_loc_next
)
30195 if (AT_class (a
) != dw_val_class_loc
)
30197 switch (a
->dw_attr
)
30199 /* Following attributes allow both exprloc and loclist
30200 classes, so we can change them into a loclist. */
30201 case DW_AT_location
:
30202 case DW_AT_string_length
:
30203 case DW_AT_return_addr
:
30204 case DW_AT_data_member_location
:
30205 case DW_AT_frame_base
:
30206 case DW_AT_segment
:
30207 case DW_AT_static_link
:
30208 case DW_AT_use_location
:
30209 case DW_AT_vtable_elem_location
:
30212 prev
->dw_loc_next
= NULL
;
30213 prepend_loc_descr_to_each (l
, AT_loc (a
));
30216 add_loc_descr_to_each (l
, next
);
30217 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
30218 a
->dw_attr_val
.val_entry
= NULL
;
30219 a
->dw_attr_val
.v
.val_loc_list
= l
;
30220 have_location_lists
= true;
30222 /* Following attributes allow both exprloc and reference,
30223 so if the whole expression is DW_OP_GNU_variable_value alone
30224 we could transform it into reference. */
30225 case DW_AT_byte_size
:
30226 case DW_AT_bit_size
:
30227 case DW_AT_lower_bound
:
30228 case DW_AT_upper_bound
:
30229 case DW_AT_bit_stride
:
30231 case DW_AT_allocated
:
30232 case DW_AT_associated
:
30233 case DW_AT_byte_stride
:
30234 if (prev
== NULL
&& next
== NULL
)
30242 /* Create DW_TAG_variable that we can refer to. */
30243 gen_decl_die (decl
, NULL_TREE
, NULL
,
30244 lookup_decl_die (current_function_decl
));
30245 ref
= lookup_decl_die (decl
);
30248 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30249 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30250 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30256 prev
->dw_loc_next
= l
->expr
;
30257 add_loc_descr (&prev
->dw_loc_next
, next
);
30258 free_loc_descr (loc
, NULL
);
30259 next
= prev
->dw_loc_next
;
30263 memcpy (loc
, l
->expr
, sizeof (dw_loc_descr_node
));
30264 add_loc_descr (&loc
, next
);
30272 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
30275 resolve_variable_value (dw_die_ref die
)
30278 dw_loc_list_ref loc
;
30281 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30282 switch (AT_class (a
))
30284 case dw_val_class_loc
:
30285 if (!resolve_variable_value_in_expr (a
, AT_loc (a
)))
30288 case dw_val_class_loc_list
:
30289 loc
= AT_loc_list (a
);
30291 for (; loc
; loc
= loc
->dw_loc_next
)
30292 resolve_variable_value_in_expr (a
, loc
->expr
);
30299 /* Attempt to optimize DW_OP_GNU_variable_value refering to
30300 temporaries in the current function. */
30303 resolve_variable_values (void)
30305 if (!variable_value_hash
|| !current_function_decl
)
30308 struct variable_value_struct
*node
30309 = variable_value_hash
->find_with_hash (current_function_decl
,
30310 DECL_UID (current_function_decl
));
30317 FOR_EACH_VEC_SAFE_ELT (node
->dies
, i
, die
)
30318 resolve_variable_value (die
);
30321 /* Helper function for note_variable_value, handle one location
30325 note_variable_value_in_expr (dw_die_ref die
, dw_loc_descr_ref loc
)
30327 for (; loc
; loc
= loc
->dw_loc_next
)
30328 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
30329 && loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30331 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
30332 dw_die_ref ref
= lookup_decl_die (decl
);
30333 if (! ref
&& (flag_generate_lto
|| flag_generate_offload
))
30335 /* ??? This is somewhat a hack because we do not create DIEs
30336 for variables not in BLOCK trees early but when generating
30337 early LTO output we need the dw_val_class_decl_ref to be
30338 fully resolved. For fat LTO objects we'd also like to
30339 undo this after LTO dwarf output. */
30340 gcc_assert (DECL_CONTEXT (decl
));
30341 dw_die_ref ctx
= lookup_decl_die (DECL_CONTEXT (decl
));
30342 gcc_assert (ctx
!= NULL
);
30343 gen_decl_die (decl
, NULL_TREE
, NULL
, ctx
);
30344 ref
= lookup_decl_die (decl
);
30345 gcc_assert (ref
!= NULL
);
30349 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30350 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30351 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30355 && DECL_CONTEXT (decl
)
30356 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
30357 && lookup_decl_die (DECL_CONTEXT (decl
)))
30359 if (!variable_value_hash
)
30360 variable_value_hash
30361 = hash_table
<variable_value_hasher
>::create_ggc (10);
30363 tree fndecl
= DECL_CONTEXT (decl
);
30364 struct variable_value_struct
*node
;
30365 struct variable_value_struct
**slot
30366 = variable_value_hash
->find_slot_with_hash (fndecl
,
30371 node
= ggc_cleared_alloc
<variable_value_struct
> ();
30372 node
->decl_id
= DECL_UID (fndecl
);
30378 vec_safe_push (node
->dies
, die
);
30383 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
30384 with dw_val_class_decl_ref operand. */
30387 note_variable_value (dw_die_ref die
)
30391 dw_loc_list_ref loc
;
30394 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30395 switch (AT_class (a
))
30397 case dw_val_class_loc_list
:
30398 loc
= AT_loc_list (a
);
30400 if (!loc
->noted_variable_value
)
30402 loc
->noted_variable_value
= 1;
30403 for (; loc
; loc
= loc
->dw_loc_next
)
30404 note_variable_value_in_expr (die
, loc
->expr
);
30407 case dw_val_class_loc
:
30408 note_variable_value_in_expr (die
, AT_loc (a
));
30414 /* Mark children. */
30415 FOR_EACH_CHILD (die
, c
, note_variable_value (c
));
30418 /* Perform any cleanups needed after the early debug generation pass
30422 dwarf2out_early_finish (const char *filename
)
30426 /* PCH might result in DW_AT_producer string being restored from the
30427 header compilation, so always fill it with empty string initially
30428 and overwrite only here. */
30429 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
30430 producer_string
= gen_producer_string ();
30431 producer
->dw_attr_val
.v
.val_str
->refcount
--;
30432 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
30434 /* Add the name for the main input file now. We delayed this from
30435 dwarf2out_init to avoid complications with PCH. */
30436 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
30437 add_comp_dir_attribute (comp_unit_die ());
30439 /* When emitting DWARF5 .debug_line_str, move DW_AT_name and
30440 DW_AT_comp_dir into .debug_line_str section. */
30441 if (!DWARF2_ASM_LINE_DEBUG_INFO
30442 && dwarf_version
>= 5
30443 && DWARF5_USE_DEBUG_LINE_STR
)
30445 for (int i
= 0; i
< 2; i
++)
30447 dw_attr_node
*a
= get_AT (comp_unit_die (),
30448 i
? DW_AT_comp_dir
: DW_AT_name
);
30450 || AT_class (a
) != dw_val_class_str
30451 || strlen (AT_string (a
)) + 1 <= DWARF_OFFSET_SIZE
)
30454 if (! debug_line_str_hash
)
30455 debug_line_str_hash
30456 = hash_table
<indirect_string_hasher
>::create_ggc (10);
30458 struct indirect_string_node
*node
30459 = find_AT_string_in_table (AT_string (a
), debug_line_str_hash
);
30460 set_indirect_string (node
);
30461 node
->form
= DW_FORM_line_strp
;
30462 a
->dw_attr_val
.v
.val_str
->refcount
--;
30463 a
->dw_attr_val
.v
.val_str
= node
;
30467 /* With LTO early dwarf was really finished at compile-time, so make
30468 sure to adjust the phase after annotating the LTRANS CU DIE. */
30471 early_dwarf_finished
= true;
30475 /* Walk through the list of incomplete types again, trying once more to
30476 emit full debugging info for them. */
30477 retry_incomplete_types ();
30479 /* The point here is to flush out the limbo list so that it is empty
30480 and we don't need to stream it for LTO. */
30481 flush_limbo_die_list ();
30483 gen_scheduled_generic_parms_dies ();
30484 gen_remaining_tmpl_value_param_die_attribute ();
30486 /* Add DW_AT_linkage_name for all deferred DIEs. */
30487 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
30489 tree decl
= node
->created_for
;
30490 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
30491 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
30492 ended up in deferred_asm_name before we knew it was
30493 constant and never written to disk. */
30494 && DECL_ASSEMBLER_NAME (decl
))
30496 add_linkage_attr (node
->die
, decl
);
30497 move_linkage_attr (node
->die
);
30500 deferred_asm_name
= NULL
;
30502 if (flag_eliminate_unused_debug_types
)
30503 prune_unused_types ();
30505 /* Generate separate COMDAT sections for type DIEs. */
30506 if (use_debug_types
)
30508 break_out_comdat_types (comp_unit_die ());
30510 /* Each new type_unit DIE was added to the limbo die list when created.
30511 Since these have all been added to comdat_type_list, clear the
30513 limbo_die_list
= NULL
;
30515 /* For each new comdat type unit, copy declarations for incomplete
30516 types to make the new unit self-contained (i.e., no direct
30517 references to the main compile unit). */
30518 for (comdat_type_node
*ctnode
= comdat_type_list
;
30519 ctnode
!= NULL
; ctnode
= ctnode
->next
)
30520 copy_decls_for_unworthy_types (ctnode
->root_die
);
30521 copy_decls_for_unworthy_types (comp_unit_die ());
30523 /* In the process of copying declarations from one unit to another,
30524 we may have left some declarations behind that are no longer
30525 referenced. Prune them. */
30526 prune_unused_types ();
30529 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
30530 with dw_val_class_decl_ref operand. */
30531 note_variable_value (comp_unit_die ());
30532 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
30533 note_variable_value (node
->die
);
30534 for (comdat_type_node
*ctnode
= comdat_type_list
; ctnode
!= NULL
;
30535 ctnode
= ctnode
->next
)
30536 note_variable_value (ctnode
->root_die
);
30537 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
30538 note_variable_value (node
->die
);
30540 /* The AT_pubnames attribute needs to go in all skeleton dies, including
30541 both the main_cu and all skeleton TUs. Making this call unconditional
30542 would end up either adding a second copy of the AT_pubnames attribute, or
30543 requiring a special case in add_top_level_skeleton_die_attrs. */
30544 if (!dwarf_split_debug_info
)
30545 add_AT_pubnames (comp_unit_die ());
30547 /* The early debug phase is now finished. */
30548 early_dwarf_finished
= true;
30550 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
30551 if (!flag_generate_lto
&& !flag_generate_offload
)
30554 /* Now as we are going to output for LTO initialize sections and labels
30555 to the LTO variants. We don't need a random-seed postfix as other
30556 LTO sections as linking the LTO debug sections into one in a partial
30558 init_sections_and_labels (true);
30560 /* The output below is modeled after dwarf2out_finish with all
30561 location related output removed and some LTO specific changes.
30562 Some refactoring might make both smaller and easier to match up. */
30564 /* Traverse the DIE's and add add sibling attributes to those DIE's
30565 that have children. */
30566 add_sibling_attributes (comp_unit_die ());
30567 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
30568 add_sibling_attributes (node
->die
);
30569 for (comdat_type_node
*ctnode
= comdat_type_list
;
30570 ctnode
!= NULL
; ctnode
= ctnode
->next
)
30571 add_sibling_attributes (ctnode
->root_die
);
30574 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
30575 macinfo_section_label
);
30577 save_macinfo_strings ();
30579 /* Output all of the compilation units. We put the main one last so that
30580 the offsets are available to output_pubnames. */
30581 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
30582 output_comp_unit (node
->die
, 0, NULL
);
30584 hash_table
<comdat_type_hasher
> comdat_type_table (100);
30585 for (comdat_type_node
*ctnode
= comdat_type_list
;
30586 ctnode
!= NULL
; ctnode
= ctnode
->next
)
30588 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
30590 /* Don't output duplicate types. */
30591 if (*slot
!= HTAB_EMPTY_ENTRY
)
30594 /* Add a pointer to the line table for the main compilation unit
30595 so that the debugger can make sense of DW_AT_decl_file
30597 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
30598 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
30599 (!dwarf_split_debug_info
30600 ? debug_line_section_label
30601 : debug_skeleton_line_section_label
));
30603 output_comdat_type_unit (ctnode
);
30607 /* Stick a unique symbol to the main debuginfo section. */
30608 compute_comp_unit_symbol (comp_unit_die ());
30610 /* Output the main compilation unit. We always need it if only for
30612 output_comp_unit (comp_unit_die (), true, NULL
);
30614 /* Output the abbreviation table. */
30615 if (vec_safe_length (abbrev_die_table
) != 1)
30617 switch_to_section (debug_abbrev_section
);
30618 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
30619 output_abbrev_section ();
30622 /* Have to end the macro section. */
30625 /* We have to save macinfo state if we need to output it again
30626 for the FAT part of the object. */
30627 vec
<macinfo_entry
, va_gc
> *saved_macinfo_table
= macinfo_table
;
30628 if (flag_fat_lto_objects
)
30629 macinfo_table
= macinfo_table
->copy ();
30631 switch_to_section (debug_macinfo_section
);
30632 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
30633 output_macinfo (debug_skeleton_line_section_label
, true);
30634 dw2_asm_output_data (1, 0, "End compilation unit");
30636 /* Emit a skeleton debug_line section. */
30637 switch_to_section (debug_skeleton_line_section
);
30638 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
30639 output_line_info (true);
30641 if (flag_fat_lto_objects
)
30643 vec_free (macinfo_table
);
30644 macinfo_table
= saved_macinfo_table
;
30649 /* If we emitted any indirect strings, output the string table too. */
30650 if (debug_str_hash
|| skeleton_debug_str_hash
)
30651 output_indirect_strings ();
30653 /* Switch back to the text section. */
30654 switch_to_section (text_section
);
30657 /* Reset all state within dwarf2out.c so that we can rerun the compiler
30658 within the same process. For use by toplev::finalize. */
30661 dwarf2out_c_finalize (void)
30663 last_var_location_insn
= NULL
;
30664 cached_next_real_insn
= NULL
;
30665 used_rtx_array
= NULL
;
30666 incomplete_types
= NULL
;
30667 decl_scope_table
= NULL
;
30668 debug_info_section
= NULL
;
30669 debug_skeleton_info_section
= NULL
;
30670 debug_abbrev_section
= NULL
;
30671 debug_skeleton_abbrev_section
= NULL
;
30672 debug_aranges_section
= NULL
;
30673 debug_addr_section
= NULL
;
30674 debug_macinfo_section
= NULL
;
30675 debug_line_section
= NULL
;
30676 debug_skeleton_line_section
= NULL
;
30677 debug_loc_section
= NULL
;
30678 debug_pubnames_section
= NULL
;
30679 debug_pubtypes_section
= NULL
;
30680 debug_str_section
= NULL
;
30681 debug_line_str_section
= NULL
;
30682 debug_str_dwo_section
= NULL
;
30683 debug_str_offsets_section
= NULL
;
30684 debug_ranges_section
= NULL
;
30685 debug_frame_section
= NULL
;
30687 debug_str_hash
= NULL
;
30688 debug_line_str_hash
= NULL
;
30689 skeleton_debug_str_hash
= NULL
;
30690 dw2_string_counter
= 0;
30691 have_multiple_function_sections
= false;
30692 text_section_used
= false;
30693 cold_text_section_used
= false;
30694 cold_text_section
= NULL
;
30695 current_unit_personality
= NULL
;
30697 early_dwarf
= false;
30698 early_dwarf_finished
= false;
30700 next_die_offset
= 0;
30701 single_comp_unit_die
= NULL
;
30702 comdat_type_list
= NULL
;
30703 limbo_die_list
= NULL
;
30705 decl_die_table
= NULL
;
30706 common_block_die_table
= NULL
;
30707 decl_loc_table
= NULL
;
30708 call_arg_locations
= NULL
;
30709 call_arg_loc_last
= NULL
;
30710 call_site_count
= -1;
30711 tail_call_site_count
= -1;
30712 cached_dw_loc_list_table
= NULL
;
30713 abbrev_die_table
= NULL
;
30714 delete dwarf_proc_stack_usage_map
;
30715 dwarf_proc_stack_usage_map
= NULL
;
30716 line_info_label_num
= 0;
30717 cur_line_info_table
= NULL
;
30718 text_section_line_info
= NULL
;
30719 cold_text_section_line_info
= NULL
;
30720 separate_line_info
= NULL
;
30721 info_section_emitted
= false;
30722 pubname_table
= NULL
;
30723 pubtype_table
= NULL
;
30724 macinfo_table
= NULL
;
30725 ranges_table
= NULL
;
30726 ranges_by_label
= NULL
;
30728 have_location_lists
= false;
30731 last_emitted_file
= NULL
;
30733 tmpl_value_parm_die_table
= NULL
;
30734 generic_type_instances
= NULL
;
30735 frame_pointer_fb_offset
= 0;
30736 frame_pointer_fb_offset_valid
= false;
30737 base_types
.release ();
30738 XDELETEVEC (producer_string
);
30739 producer_string
= NULL
;
30742 #include "gt-dwarf2out.h"