1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2016 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"
66 #include "stringpool.h"
67 #include "insn-config.h"
70 #include "diagnostic.h"
71 #include "fold-const.h"
72 #include "stor-layout.h"
80 #include "dwarf2out.h"
81 #include "dwarf2asm.h"
84 #include "tree-pretty-print.h"
86 #include "common/common-target.h"
87 #include "langhooks.h"
92 #include "gdb/gdb-index.h"
95 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
96 static rtx_insn
*last_var_location_insn
;
97 static rtx_insn
*cached_next_real_insn
;
98 static void dwarf2out_decl (tree
);
100 #ifndef XCOFF_DEBUGGING_INFO
101 #define XCOFF_DEBUGGING_INFO 0
104 #ifndef HAVE_XCOFF_DWARF_EXTRAS
105 #define HAVE_XCOFF_DWARF_EXTRAS 0
108 #ifdef VMS_DEBUGGING_INFO
109 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
111 /* Define this macro to be a nonzero value if the directory specifications
112 which are output in the debug info should end with a separator. */
113 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
114 /* Define this macro to evaluate to a nonzero value if GCC should refrain
115 from generating indirect strings in DWARF2 debug information, for instance
116 if your target is stuck with an old version of GDB that is unable to
117 process them properly or uses VMS Debug. */
118 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
120 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
121 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
124 /* ??? Poison these here until it can be done generically. They've been
125 totally replaced in this file; make sure it stays that way. */
126 #undef DWARF2_UNWIND_INFO
127 #undef DWARF2_FRAME_INFO
128 #if (GCC_VERSION >= 3000)
129 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
132 /* The size of the target's pointer type. */
134 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
137 /* Array of RTXes referenced by the debugging information, which therefore
138 must be kept around forever. */
139 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
141 /* A pointer to the base of a list of incomplete types which might be
142 completed at some later time. incomplete_types_list needs to be a
143 vec<tree, va_gc> *because we want to tell the garbage collector about
145 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
147 /* A pointer to the base of a table of references to declaration
148 scopes. This table is a display which tracks the nesting
149 of declaration scopes at the current scope and containing
150 scopes. This table is used to find the proper place to
151 define type declaration DIE's. */
152 static GTY(()) vec
<tree
, va_gc
> *decl_scope_table
;
154 /* Pointers to various DWARF2 sections. */
155 static GTY(()) section
*debug_info_section
;
156 static GTY(()) section
*debug_skeleton_info_section
;
157 static GTY(()) section
*debug_abbrev_section
;
158 static GTY(()) section
*debug_skeleton_abbrev_section
;
159 static GTY(()) section
*debug_aranges_section
;
160 static GTY(()) section
*debug_addr_section
;
161 static GTY(()) section
*debug_macinfo_section
;
162 static GTY(()) section
*debug_line_section
;
163 static GTY(()) section
*debug_skeleton_line_section
;
164 static GTY(()) section
*debug_loc_section
;
165 static GTY(()) section
*debug_pubnames_section
;
166 static GTY(()) section
*debug_pubtypes_section
;
167 static GTY(()) section
*debug_str_section
;
168 static GTY(()) section
*debug_str_dwo_section
;
169 static GTY(()) section
*debug_str_offsets_section
;
170 static GTY(()) section
*debug_ranges_section
;
171 static GTY(()) section
*debug_frame_section
;
173 /* Maximum size (in bytes) of an artificially generated label. */
174 #define MAX_ARTIFICIAL_LABEL_BYTES 30
176 /* According to the (draft) DWARF 3 specification, the initial length
177 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
178 bytes are 0xffffffff, followed by the length stored in the next 8
181 However, the SGI/MIPS ABI uses an initial length which is equal to
182 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
184 #ifndef DWARF_INITIAL_LENGTH_SIZE
185 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
188 /* Round SIZE up to the nearest BOUNDARY. */
189 #define DWARF_ROUND(SIZE,BOUNDARY) \
190 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
192 /* CIE identifier. */
193 #if HOST_BITS_PER_WIDE_INT >= 64
194 #define DWARF_CIE_ID \
195 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
197 #define DWARF_CIE_ID DW_CIE_ID
201 /* A vector for a table that contains frame description
202 information for each routine. */
203 #define NOT_INDEXED (-1U)
204 #define NO_INDEX_ASSIGNED (-2U)
206 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
208 struct GTY((for_user
)) indirect_string_node
{
210 unsigned int refcount
;
211 enum dwarf_form form
;
216 struct indirect_string_hasher
: ggc_ptr_hash
<indirect_string_node
>
218 typedef const char *compare_type
;
220 static hashval_t
hash (indirect_string_node
*);
221 static bool equal (indirect_string_node
*, const char *);
224 static GTY (()) hash_table
<indirect_string_hasher
> *debug_str_hash
;
226 /* With split_debug_info, both the comp_dir and dwo_name go in the
227 main object file, rather than the dwo, similar to the force_direct
228 parameter elsewhere but with additional complications:
230 1) The string is needed in both the main object file and the dwo.
231 That is, the comp_dir and dwo_name will appear in both places.
233 2) Strings can use three forms: DW_FORM_string, DW_FORM_strp or
234 DW_FORM_GNU_str_index.
236 3) GCC chooses the form to use late, depending on the size and
239 Rather than forcing the all debug string handling functions and
240 callers to deal with these complications, simply use a separate,
241 special-cased string table for any attribute that should go in the
242 main object file. This limits the complexity to just the places
245 static GTY (()) hash_table
<indirect_string_hasher
> *skeleton_debug_str_hash
;
247 static GTY(()) int dw2_string_counter
;
249 /* True if the compilation unit places functions in more than one section. */
250 static GTY(()) bool have_multiple_function_sections
= false;
252 /* Whether the default text and cold text sections have been used at all. */
254 static GTY(()) bool text_section_used
= false;
255 static GTY(()) bool cold_text_section_used
= false;
257 /* The default cold text section. */
258 static GTY(()) section
*cold_text_section
;
260 /* The DIE for C++14 'auto' in a function return type. */
261 static GTY(()) dw_die_ref auto_die
;
263 /* The DIE for C++14 'decltype(auto)' in a function return type. */
264 static GTY(()) dw_die_ref decltype_auto_die
;
266 /* Forward declarations for functions defined in this file. */
268 static char *stripattributes (const char *);
269 static void output_call_frame_info (int);
270 static void dwarf2out_note_section_used (void);
272 /* Personality decl of current unit. Used only when assembler does not support
274 static GTY(()) rtx current_unit_personality
;
276 /* Data and reference forms for relocatable data. */
277 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
278 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
280 #ifndef DEBUG_FRAME_SECTION
281 #define DEBUG_FRAME_SECTION ".debug_frame"
284 #ifndef FUNC_BEGIN_LABEL
285 #define FUNC_BEGIN_LABEL "LFB"
288 #ifndef FUNC_END_LABEL
289 #define FUNC_END_LABEL "LFE"
292 #ifndef PROLOGUE_END_LABEL
293 #define PROLOGUE_END_LABEL "LPE"
296 #ifndef EPILOGUE_BEGIN_LABEL
297 #define EPILOGUE_BEGIN_LABEL "LEB"
300 #ifndef FRAME_BEGIN_LABEL
301 #define FRAME_BEGIN_LABEL "Lframe"
303 #define CIE_AFTER_SIZE_LABEL "LSCIE"
304 #define CIE_END_LABEL "LECIE"
305 #define FDE_LABEL "LSFDE"
306 #define FDE_AFTER_SIZE_LABEL "LASFDE"
307 #define FDE_END_LABEL "LEFDE"
308 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
309 #define LINE_NUMBER_END_LABEL "LELT"
310 #define LN_PROLOG_AS_LABEL "LASLTP"
311 #define LN_PROLOG_END_LABEL "LELTP"
312 #define DIE_LABEL_PREFIX "DW"
314 /* Match the base name of a file to the base name of a compilation unit. */
317 matches_main_base (const char *path
)
319 /* Cache the last query. */
320 static const char *last_path
= NULL
;
321 static int last_match
= 0;
322 if (path
!= last_path
)
325 int length
= base_of_path (path
, &base
);
327 last_match
= (length
== main_input_baselength
328 && memcmp (base
, main_input_basename
, length
) == 0);
333 #ifdef DEBUG_DEBUG_STRUCT
336 dump_struct_debug (tree type
, enum debug_info_usage usage
,
337 enum debug_struct_file criterion
, int generic
,
338 int matches
, int result
)
340 /* Find the type name. */
341 tree type_decl
= TYPE_STUB_DECL (type
);
343 const char *name
= 0;
344 if (TREE_CODE (t
) == TYPE_DECL
)
347 name
= IDENTIFIER_POINTER (t
);
349 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
351 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
352 matches
? "bas" : "hdr",
353 generic
? "gen" : "ord",
354 usage
== DINFO_USAGE_DFN
? ";" :
355 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
357 (void*) type_decl
, name
);
360 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
361 dump_struct_debug (type, usage, criterion, generic, matches, result)
365 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
370 /* Get the number of HOST_WIDE_INTs needed to represent the precision
371 of the number. Some constants have a large uniform precision, so
372 we get the precision needed for the actual value of the number. */
375 get_full_len (const wide_int
&op
)
377 int prec
= wi::min_precision (op
, UNSIGNED
);
378 return ((prec
+ HOST_BITS_PER_WIDE_INT
- 1)
379 / HOST_BITS_PER_WIDE_INT
);
383 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
385 enum debug_struct_file criterion
;
387 bool generic
= lang_hooks
.types
.generic_p (type
);
390 criterion
= debug_struct_generic
[usage
];
392 criterion
= debug_struct_ordinary
[usage
];
394 if (criterion
== DINFO_STRUCT_FILE_NONE
)
395 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
396 if (criterion
== DINFO_STRUCT_FILE_ANY
)
397 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
399 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
401 if (type_decl
!= NULL
)
403 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
404 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
406 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
407 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
410 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
413 /* Return a pointer to a copy of the section string name S with all
414 attributes stripped off, and an asterisk prepended (for assemble_name). */
417 stripattributes (const char *s
)
419 char *stripped
= XNEWVEC (char, strlen (s
) + 2);
424 while (*s
&& *s
!= ',')
431 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
432 switch to the data section instead, and write out a synthetic start label
433 for collect2 the first time around. */
436 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED
)
438 if (eh_frame_section
== 0)
442 if (EH_TABLES_CAN_BE_READ_ONLY
)
448 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
450 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
452 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
455 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
456 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
457 && (per_encoding
& 0x70) != DW_EH_PE_absptr
458 && (per_encoding
& 0x70) != DW_EH_PE_aligned
459 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
460 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
461 ? 0 : SECTION_WRITE
);
464 flags
= SECTION_WRITE
;
466 #ifdef EH_FRAME_SECTION_NAME
467 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
469 eh_frame_section
= ((flags
== SECTION_WRITE
)
470 ? data_section
: readonly_data_section
);
471 #endif /* EH_FRAME_SECTION_NAME */
474 switch_to_section (eh_frame_section
);
476 #ifdef EH_FRAME_THROUGH_COLLECT2
477 /* We have no special eh_frame section. Emit special labels to guide
481 tree label
= get_file_function_name ("F");
482 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
483 targetm
.asm_out
.globalize_label (asm_out_file
,
484 IDENTIFIER_POINTER (label
));
485 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
490 /* Switch [BACK] to the eh or debug frame table section, depending on
494 switch_to_frame_table_section (int for_eh
, bool back
)
497 switch_to_eh_frame_section (back
);
500 if (!debug_frame_section
)
501 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
502 SECTION_DEBUG
, NULL
);
503 switch_to_section (debug_frame_section
);
507 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
509 enum dw_cfi_oprnd_type
510 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
515 case DW_CFA_GNU_window_save
:
516 case DW_CFA_remember_state
:
517 case DW_CFA_restore_state
:
518 return dw_cfi_oprnd_unused
;
521 case DW_CFA_advance_loc1
:
522 case DW_CFA_advance_loc2
:
523 case DW_CFA_advance_loc4
:
524 case DW_CFA_MIPS_advance_loc8
:
525 return dw_cfi_oprnd_addr
;
528 case DW_CFA_offset_extended
:
530 case DW_CFA_offset_extended_sf
:
531 case DW_CFA_def_cfa_sf
:
533 case DW_CFA_restore_extended
:
534 case DW_CFA_undefined
:
535 case DW_CFA_same_value
:
536 case DW_CFA_def_cfa_register
:
537 case DW_CFA_register
:
538 case DW_CFA_expression
:
539 return dw_cfi_oprnd_reg_num
;
541 case DW_CFA_def_cfa_offset
:
542 case DW_CFA_GNU_args_size
:
543 case DW_CFA_def_cfa_offset_sf
:
544 return dw_cfi_oprnd_offset
;
546 case DW_CFA_def_cfa_expression
:
547 return dw_cfi_oprnd_loc
;
554 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
556 enum dw_cfi_oprnd_type
557 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
562 case DW_CFA_def_cfa_sf
:
564 case DW_CFA_offset_extended_sf
:
565 case DW_CFA_offset_extended
:
566 return dw_cfi_oprnd_offset
;
568 case DW_CFA_register
:
569 return dw_cfi_oprnd_reg_num
;
571 case DW_CFA_expression
:
572 return dw_cfi_oprnd_loc
;
575 return dw_cfi_oprnd_unused
;
579 /* Output one FDE. */
582 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
583 char *section_start_label
, int fde_encoding
, char *augmentation
,
584 bool any_lsda_needed
, int lsda_encoding
)
586 const char *begin
, *end
;
587 static unsigned int j
;
590 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
592 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
594 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
595 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
596 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
598 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
599 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
600 " indicating 64-bit DWARF extension");
601 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
604 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
607 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
609 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
610 debug_frame_section
, "FDE CIE offset");
612 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
613 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
617 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
618 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
619 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
620 "FDE initial location");
621 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
622 end
, begin
, "FDE address range");
626 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
627 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
634 int size
= size_of_encoded_value (lsda_encoding
);
636 if (lsda_encoding
== DW_EH_PE_aligned
)
638 int offset
= ( 4 /* Length */
640 + 2 * size_of_encoded_value (fde_encoding
)
641 + 1 /* Augmentation size */ );
642 int pad
= -offset
& (PTR_SIZE
- 1);
645 gcc_assert (size_of_uleb128 (size
) == 1);
648 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
650 if (fde
->uses_eh_lsda
)
652 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
653 fde
->funcdef_number
);
654 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
655 gen_rtx_SYMBOL_REF (Pmode
, l1
),
657 "Language Specific Data Area");
661 if (lsda_encoding
== DW_EH_PE_aligned
)
662 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
663 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
664 "Language Specific Data Area (none)");
668 dw2_asm_output_data_uleb128 (0, "Augmentation size");
671 /* Loop through the Call Frame Instructions associated with this FDE. */
672 fde
->dw_fde_current_label
= begin
;
674 size_t from
, until
, i
;
677 until
= vec_safe_length (fde
->dw_fde_cfi
);
679 if (fde
->dw_fde_second_begin
== NULL
)
682 until
= fde
->dw_fde_switch_cfi_index
;
684 from
= fde
->dw_fde_switch_cfi_index
;
686 for (i
= from
; i
< until
; i
++)
687 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
690 /* If we are to emit a ref/link from function bodies to their frame tables,
691 do it now. This is typically performed to make sure that tables
692 associated with functions are dragged with them and not discarded in
693 garbage collecting links. We need to do this on a per function basis to
694 cope with -ffunction-sections. */
696 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
697 /* Switch to the function section, emit the ref to the tables, and
698 switch *back* into the table section. */
699 switch_to_section (function_section (fde
->decl
));
700 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
701 switch_to_frame_table_section (for_eh
, true);
704 /* Pad the FDE out to an address sized boundary. */
705 ASM_OUTPUT_ALIGN (asm_out_file
,
706 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
707 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
712 /* Return true if frame description entry FDE is needed for EH. */
715 fde_needed_for_eh_p (dw_fde_ref fde
)
717 if (flag_asynchronous_unwind_tables
)
720 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
723 if (fde
->uses_eh_lsda
)
726 /* If exceptions are enabled, we have collected nothrow info. */
727 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
733 /* Output the call frame information used to record information
734 that relates to calculating the frame pointer, and records the
735 location of saved registers. */
738 output_call_frame_info (int for_eh
)
743 char l1
[20], l2
[20], section_start_label
[20];
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
)
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 const char *file ATTRIBUTE_UNUSED
)
1036 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1042 current_function_func_begin_label
= NULL
;
1044 do_frame
= dwarf2out_do_frame ();
1046 /* ??? current_function_func_begin_label is also used by except.c for
1047 call-site information. We must emit this label if it might be used. */
1049 && (!flag_exceptions
1050 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1053 fnsec
= function_section (current_function_decl
);
1054 switch_to_section (fnsec
);
1055 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1056 current_function_funcdef_no
);
1057 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1058 current_function_funcdef_no
);
1059 dup_label
= xstrdup (label
);
1060 current_function_func_begin_label
= dup_label
;
1062 /* We can elide the fde allocation if we're not emitting debug info. */
1066 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1067 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1068 would include pass_dwarf2_frame. If we've not created the FDE yet,
1072 fde
= dwarf2out_alloc_current_fde ();
1074 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1075 fde
->dw_fde_begin
= dup_label
;
1076 fde
->dw_fde_current_label
= dup_label
;
1077 fde
->in_std_section
= (fnsec
== text_section
1078 || (cold_text_section
&& fnsec
== cold_text_section
));
1080 /* We only want to output line number information for the genuine dwarf2
1081 prologue case, not the eh frame case. */
1082 #ifdef DWARF2_DEBUGGING_INFO
1084 dwarf2out_source_line (line
, file
, 0, true);
1087 if (dwarf2out_do_cfi_asm ())
1088 dwarf2out_do_cfi_startproc (false);
1091 rtx personality
= get_personality_function (current_function_decl
);
1092 if (!current_unit_personality
)
1093 current_unit_personality
= personality
;
1095 /* We cannot keep a current personality per function as without CFI
1096 asm, at the point where we emit the CFI data, there is no current
1097 function anymore. */
1098 if (personality
&& current_unit_personality
!= personality
)
1099 sorry ("multiple EH personalities are supported only with assemblers "
1100 "supporting .cfi_personality directive");
1104 /* Output a marker (i.e. a label) for the end of the generated code
1105 for a function prologue. This gets called *after* the prologue code has
1109 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1110 const char *file ATTRIBUTE_UNUSED
)
1112 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1114 /* Output a label to mark the endpoint of the code generated for this
1116 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1117 current_function_funcdef_no
);
1118 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1119 current_function_funcdef_no
);
1120 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1123 /* Output a marker (i.e. a label) for the beginning of the generated code
1124 for a function epilogue. This gets called *before* the prologue code has
1128 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1129 const char *file ATTRIBUTE_UNUSED
)
1131 dw_fde_ref fde
= cfun
->fde
;
1132 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1134 if (fde
->dw_fde_vms_begin_epilogue
)
1137 /* Output a label to mark the endpoint of the code generated for this
1139 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1140 current_function_funcdef_no
);
1141 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1142 current_function_funcdef_no
);
1143 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1146 /* Output a marker (i.e. a label) for the absolute end of the generated code
1147 for a function definition. This gets called *after* the epilogue code has
1151 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1152 const char *file ATTRIBUTE_UNUSED
)
1155 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1157 last_var_location_insn
= NULL
;
1158 cached_next_real_insn
= NULL
;
1160 if (dwarf2out_do_cfi_asm ())
1161 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1163 /* Output a label to mark the endpoint of the code generated for this
1165 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1166 current_function_funcdef_no
);
1167 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1169 gcc_assert (fde
!= NULL
);
1170 if (fde
->dw_fde_second_begin
== NULL
)
1171 fde
->dw_fde_end
= xstrdup (label
);
1175 dwarf2out_frame_finish (void)
1177 /* Output call frame information. */
1178 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1179 output_call_frame_info (0);
1181 /* Output another copy for the unwinder. */
1182 if ((flag_unwind_tables
|| flag_exceptions
)
1183 && targetm_common
.except_unwind_info (&global_options
) == UI_DWARF2
)
1184 output_call_frame_info (1);
1187 /* Note that the current function section is being used for code. */
1190 dwarf2out_note_section_used (void)
1192 section
*sec
= current_function_section ();
1193 if (sec
== text_section
)
1194 text_section_used
= true;
1195 else if (sec
== cold_text_section
)
1196 cold_text_section_used
= true;
1199 static void var_location_switch_text_section (void);
1200 static void set_cur_line_info_table (section
*);
1203 dwarf2out_switch_text_section (void)
1206 dw_fde_ref fde
= cfun
->fde
;
1208 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1210 if (!in_cold_section_p
)
1212 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1213 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1214 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1218 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1219 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1220 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1222 have_multiple_function_sections
= true;
1224 /* There is no need to mark used sections when not debugging. */
1225 if (cold_text_section
!= NULL
)
1226 dwarf2out_note_section_used ();
1228 if (dwarf2out_do_cfi_asm ())
1229 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1231 /* Now do the real section switch. */
1232 sect
= current_function_section ();
1233 switch_to_section (sect
);
1235 fde
->second_in_std_section
1236 = (sect
== text_section
1237 || (cold_text_section
&& sect
== cold_text_section
));
1239 if (dwarf2out_do_cfi_asm ())
1240 dwarf2out_do_cfi_startproc (true);
1242 var_location_switch_text_section ();
1244 if (cold_text_section
!= NULL
)
1245 set_cur_line_info_table (sect
);
1248 /* And now, the subset of the debugging information support code necessary
1249 for emitting location expressions. */
1251 /* Data about a single source file. */
1252 struct GTY((for_user
)) dwarf_file_data
{
1253 const char * filename
;
1257 /* Describe an entry into the .debug_addr section. */
1261 ate_kind_rtx_dtprel
,
1265 struct GTY((for_user
)) addr_table_entry
{
1267 unsigned int refcount
;
1269 union addr_table_entry_struct_union
1271 rtx
GTY ((tag ("0"))) rtl
;
1272 char * GTY ((tag ("1"))) label
;
1274 GTY ((desc ("%1.kind"))) addr
;
1277 /* Location lists are ranges + location descriptions for that range,
1278 so you can track variables that are in different places over
1279 their entire life. */
1280 typedef struct GTY(()) dw_loc_list_struct
{
1281 dw_loc_list_ref dw_loc_next
;
1282 const char *begin
; /* Label and addr_entry for start of range */
1283 addr_table_entry
*begin_entry
;
1284 const char *end
; /* Label for end of range */
1285 char *ll_symbol
; /* Label for beginning of location list.
1286 Only on head of list */
1287 const char *section
; /* Section this loclist is relative to */
1288 dw_loc_descr_ref expr
;
1290 /* True if all addresses in this and subsequent lists are known to be
1293 /* True if this list has been replaced by dw_loc_next. */
1296 /* True if the range should be emitted even if begin and end
1301 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
1302 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1304 /* Convert a DWARF stack opcode into its string name. */
1307 dwarf_stack_op_name (unsigned int op
)
1309 const char *name
= get_DW_OP_name (op
);
1314 return "OP_<unknown>";
1317 /* Return a pointer to a newly allocated location description. Location
1318 descriptions are simple expression terms that can be strung
1319 together to form more complicated location (address) descriptions. */
1321 static inline dw_loc_descr_ref
1322 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1323 unsigned HOST_WIDE_INT oprnd2
)
1325 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1327 descr
->dw_loc_opc
= op
;
1328 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1329 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1330 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1331 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1332 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1333 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1338 /* Return a pointer to a newly allocated location description for
1341 static inline dw_loc_descr_ref
1342 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
1345 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1348 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
1351 /* Add a location description term to a location description expression. */
1354 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1356 dw_loc_descr_ref
*d
;
1358 /* Find the end of the chain. */
1359 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1365 /* Compare two location operands for exact equality. */
1368 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1370 if (a
->val_class
!= b
->val_class
)
1372 switch (a
->val_class
)
1374 case dw_val_class_none
:
1376 case dw_val_class_addr
:
1377 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1379 case dw_val_class_offset
:
1380 case dw_val_class_unsigned_const
:
1381 case dw_val_class_const
:
1382 case dw_val_class_range_list
:
1383 case dw_val_class_lineptr
:
1384 case dw_val_class_macptr
:
1385 /* These are all HOST_WIDE_INT, signed or unsigned. */
1386 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1388 case dw_val_class_loc
:
1389 return a
->v
.val_loc
== b
->v
.val_loc
;
1390 case dw_val_class_loc_list
:
1391 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1392 case dw_val_class_die_ref
:
1393 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1394 case dw_val_class_fde_ref
:
1395 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1396 case dw_val_class_lbl_id
:
1397 case dw_val_class_high_pc
:
1398 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1399 case dw_val_class_str
:
1400 return a
->v
.val_str
== b
->v
.val_str
;
1401 case dw_val_class_flag
:
1402 return a
->v
.val_flag
== b
->v
.val_flag
;
1403 case dw_val_class_file
:
1404 return a
->v
.val_file
== b
->v
.val_file
;
1405 case dw_val_class_decl_ref
:
1406 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1408 case dw_val_class_const_double
:
1409 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1410 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1412 case dw_val_class_wide_int
:
1413 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1415 case dw_val_class_vec
:
1417 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1418 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1420 return (a_len
== b_len
1421 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1424 case dw_val_class_data8
:
1425 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1427 case dw_val_class_vms_delta
:
1428 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1429 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1431 case dw_val_class_discr_value
:
1432 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1433 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1434 case dw_val_class_discr_list
:
1435 /* It makes no sense comparing two discriminant value lists. */
1441 /* Compare two location atoms for exact equality. */
1444 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1446 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1449 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1450 address size, but since we always allocate cleared storage it
1451 should be zero for other types of locations. */
1452 if (a
->dtprel
!= b
->dtprel
)
1455 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1456 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1459 /* Compare two complete location expressions for exact equality. */
1462 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1468 if (a
== NULL
|| b
== NULL
)
1470 if (!loc_descr_equal_p_1 (a
, b
))
1479 /* Add a constant OFFSET to a location expression. */
1482 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
1484 dw_loc_descr_ref loc
;
1487 gcc_assert (*list_head
!= NULL
);
1492 /* Find the end of the chain. */
1493 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1497 if (loc
->dw_loc_opc
== DW_OP_fbreg
1498 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1499 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1500 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1501 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1503 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1504 offset. Don't optimize if an signed integer overflow would happen. */
1506 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1507 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1510 else if (offset
> 0)
1511 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1515 loc
->dw_loc_next
= int_loc_descriptor (-offset
);
1516 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1520 /* Add a constant OFFSET to a location list. */
1523 loc_list_plus_const (dw_loc_list_ref list_head
, HOST_WIDE_INT offset
)
1526 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1527 loc_descr_plus_const (&d
->expr
, offset
);
1530 #define DWARF_REF_SIZE \
1531 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1533 static unsigned long int get_base_type_offset (dw_die_ref
);
1535 /* Return the size of a location descriptor. */
1537 static unsigned long
1538 size_of_loc_descr (dw_loc_descr_ref loc
)
1540 unsigned long size
= 1;
1542 switch (loc
->dw_loc_opc
)
1545 size
+= DWARF2_ADDR_SIZE
;
1547 case DW_OP_GNU_addr_index
:
1548 case DW_OP_GNU_const_index
:
1549 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1550 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1569 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1572 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1577 case DW_OP_plus_uconst
:
1578 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1616 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1619 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1622 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1625 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1626 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1629 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1631 case DW_OP_bit_piece
:
1632 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1633 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1635 case DW_OP_deref_size
:
1636 case DW_OP_xderef_size
:
1645 case DW_OP_call_ref
:
1646 size
+= DWARF_REF_SIZE
;
1648 case DW_OP_implicit_value
:
1649 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1650 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1652 case DW_OP_GNU_implicit_pointer
:
1653 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1655 case DW_OP_GNU_entry_value
:
1657 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1658 size
+= size_of_uleb128 (op_size
) + op_size
;
1661 case DW_OP_GNU_const_type
:
1664 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1665 size
+= size_of_uleb128 (o
) + 1;
1666 switch (loc
->dw_loc_oprnd2
.val_class
)
1668 case dw_val_class_vec
:
1669 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1670 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1672 case dw_val_class_const
:
1673 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1675 case dw_val_class_const_double
:
1676 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1678 case dw_val_class_wide_int
:
1679 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1680 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1687 case DW_OP_GNU_regval_type
:
1690 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1691 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1692 + size_of_uleb128 (o
);
1695 case DW_OP_GNU_deref_type
:
1698 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1699 size
+= 1 + size_of_uleb128 (o
);
1702 case DW_OP_GNU_convert
:
1703 case DW_OP_GNU_reinterpret
:
1704 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1705 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1709 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1710 size
+= size_of_uleb128 (o
);
1713 case DW_OP_GNU_parameter_ref
:
1723 /* Return the size of a series of location descriptors. */
1726 size_of_locs (dw_loc_descr_ref loc
)
1731 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1732 field, to avoid writing to a PCH file. */
1733 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1735 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1737 size
+= size_of_loc_descr (l
);
1742 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1744 l
->dw_loc_addr
= size
;
1745 size
+= size_of_loc_descr (l
);
1751 /* Return the size of the value in a DW_AT_discr_value attribute. */
1754 size_of_discr_value (dw_discr_value
*discr_value
)
1756 if (discr_value
->pos
)
1757 return size_of_uleb128 (discr_value
->v
.uval
);
1759 return size_of_sleb128 (discr_value
->v
.sval
);
1762 /* Return the size of the value in a DW_discr_list attribute. */
1765 size_of_discr_list (dw_discr_list_ref discr_list
)
1769 for (dw_discr_list_ref list
= discr_list
;
1771 list
= list
->dw_discr_next
)
1773 /* One byte for the discriminant value descriptor, and then one or two
1774 LEB128 numbers, depending on whether it's a single case label or a
1777 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
1778 if (list
->dw_discr_range
!= 0)
1779 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
1784 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
1785 static void get_ref_die_offset_label (char *, dw_die_ref
);
1786 static unsigned long int get_ref_die_offset (dw_die_ref
);
1788 /* Output location description stack opcode's operands (if any).
1789 The for_eh_or_skip parameter controls whether register numbers are
1790 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1791 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1792 info). This should be suppressed for the cases that have not been converted
1793 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1796 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
1798 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
1799 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
1801 switch (loc
->dw_loc_opc
)
1803 #ifdef DWARF2_DEBUGGING_INFO
1806 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
1811 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1812 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
1814 fputc ('\n', asm_out_file
);
1819 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
1824 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1825 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
1827 fputc ('\n', asm_out_file
);
1832 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
1833 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
1840 gcc_assert (val1
->val_class
== dw_val_class_loc
);
1841 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
1843 dw2_asm_output_data (2, offset
, NULL
);
1846 case DW_OP_implicit_value
:
1847 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1848 switch (val2
->val_class
)
1850 case dw_val_class_const
:
1851 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
1853 case dw_val_class_vec
:
1855 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
1856 unsigned int len
= val2
->v
.val_vec
.length
;
1860 if (elt_size
> sizeof (HOST_WIDE_INT
))
1865 for (i
= 0, p
= val2
->v
.val_vec
.array
;
1868 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
1869 "fp or vector constant word %u", i
);
1872 case dw_val_class_const_double
:
1874 unsigned HOST_WIDE_INT first
, second
;
1876 if (WORDS_BIG_ENDIAN
)
1878 first
= val2
->v
.val_double
.high
;
1879 second
= val2
->v
.val_double
.low
;
1883 first
= val2
->v
.val_double
.low
;
1884 second
= val2
->v
.val_double
.high
;
1886 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1888 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1892 case dw_val_class_wide_int
:
1895 int len
= get_full_len (*val2
->v
.val_wide
);
1896 if (WORDS_BIG_ENDIAN
)
1897 for (i
= len
- 1; i
>= 0; --i
)
1898 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1899 val2
->v
.val_wide
->elt (i
), NULL
);
1901 for (i
= 0; i
< len
; ++i
)
1902 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1903 val2
->v
.val_wide
->elt (i
), NULL
);
1906 case dw_val_class_addr
:
1907 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
1908 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
1923 case DW_OP_implicit_value
:
1924 /* We currently don't make any attempt to make sure these are
1925 aligned properly like we do for the main unwind info, so
1926 don't support emitting things larger than a byte if we're
1927 only doing unwinding. */
1932 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1935 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1938 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1941 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1943 case DW_OP_plus_uconst
:
1944 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1978 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1982 unsigned r
= val1
->v
.val_unsigned
;
1983 if (for_eh_or_skip
>= 0)
1984 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1985 gcc_assert (size_of_uleb128 (r
)
1986 == size_of_uleb128 (val1
->v
.val_unsigned
));
1987 dw2_asm_output_data_uleb128 (r
, NULL
);
1991 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1995 unsigned r
= val1
->v
.val_unsigned
;
1996 if (for_eh_or_skip
>= 0)
1997 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1998 gcc_assert (size_of_uleb128 (r
)
1999 == size_of_uleb128 (val1
->v
.val_unsigned
));
2000 dw2_asm_output_data_uleb128 (r
, NULL
);
2001 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2005 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2007 case DW_OP_bit_piece
:
2008 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2009 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2011 case DW_OP_deref_size
:
2012 case DW_OP_xderef_size
:
2013 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2019 if (targetm
.asm_out
.output_dwarf_dtprel
)
2021 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2024 fputc ('\n', asm_out_file
);
2031 #ifdef DWARF2_DEBUGGING_INFO
2032 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2039 case DW_OP_GNU_addr_index
:
2040 case DW_OP_GNU_const_index
:
2041 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2042 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2043 "(index into .debug_addr)");
2049 unsigned long die_offset
2050 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2051 /* Make sure the offset has been computed and that we can encode it as
2053 gcc_assert (die_offset
> 0
2054 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
)
2057 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2062 case DW_OP_GNU_implicit_pointer
:
2064 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2065 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2066 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2067 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2068 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2069 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2073 case DW_OP_GNU_entry_value
:
2074 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2075 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2078 case DW_OP_GNU_const_type
:
2080 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2082 dw2_asm_output_data_uleb128 (o
, NULL
);
2083 switch (val2
->val_class
)
2085 case dw_val_class_const
:
2086 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2087 dw2_asm_output_data (1, l
, NULL
);
2088 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2090 case dw_val_class_vec
:
2092 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2093 unsigned int len
= val2
->v
.val_vec
.length
;
2098 dw2_asm_output_data (1, l
, NULL
);
2099 if (elt_size
> sizeof (HOST_WIDE_INT
))
2104 for (i
= 0, p
= val2
->v
.val_vec
.array
;
2107 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2108 "fp or vector constant word %u", i
);
2111 case dw_val_class_const_double
:
2113 unsigned HOST_WIDE_INT first
, second
;
2114 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2116 dw2_asm_output_data (1, 2 * l
, NULL
);
2117 if (WORDS_BIG_ENDIAN
)
2119 first
= val2
->v
.val_double
.high
;
2120 second
= val2
->v
.val_double
.low
;
2124 first
= val2
->v
.val_double
.low
;
2125 second
= val2
->v
.val_double
.high
;
2127 dw2_asm_output_data (l
, first
, NULL
);
2128 dw2_asm_output_data (l
, second
, NULL
);
2131 case dw_val_class_wide_int
:
2134 int len
= get_full_len (*val2
->v
.val_wide
);
2135 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2137 dw2_asm_output_data (1, len
* l
, NULL
);
2138 if (WORDS_BIG_ENDIAN
)
2139 for (i
= len
- 1; i
>= 0; --i
)
2140 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2142 for (i
= 0; i
< len
; ++i
)
2143 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2151 case DW_OP_GNU_regval_type
:
2153 unsigned r
= val1
->v
.val_unsigned
;
2154 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2156 if (for_eh_or_skip
>= 0)
2158 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2159 gcc_assert (size_of_uleb128 (r
)
2160 == size_of_uleb128 (val1
->v
.val_unsigned
));
2162 dw2_asm_output_data_uleb128 (r
, NULL
);
2163 dw2_asm_output_data_uleb128 (o
, NULL
);
2166 case DW_OP_GNU_deref_type
:
2168 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2170 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2171 dw2_asm_output_data_uleb128 (o
, NULL
);
2174 case DW_OP_GNU_convert
:
2175 case DW_OP_GNU_reinterpret
:
2176 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2177 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2180 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2182 dw2_asm_output_data_uleb128 (o
, NULL
);
2186 case DW_OP_GNU_parameter_ref
:
2189 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2190 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2191 dw2_asm_output_data (4, o
, NULL
);
2196 /* Other codes have no operands. */
2201 /* Output a sequence of location operations.
2202 The for_eh_or_skip parameter controls whether register numbers are
2203 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2204 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2205 info). This should be suppressed for the cases that have not been converted
2206 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2209 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2211 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2213 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2214 /* Output the opcode. */
2215 if (for_eh_or_skip
>= 0
2216 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2218 unsigned r
= (opc
- DW_OP_breg0
);
2219 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2220 gcc_assert (r
<= 31);
2221 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2223 else if (for_eh_or_skip
>= 0
2224 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2226 unsigned r
= (opc
- DW_OP_reg0
);
2227 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2228 gcc_assert (r
<= 31);
2229 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2232 dw2_asm_output_data (1, opc
,
2233 "%s", dwarf_stack_op_name (opc
));
2235 /* Output the operand(s) (if any). */
2236 output_loc_operands (loc
, for_eh_or_skip
);
2240 /* Output location description stack opcode's operands (if any).
2241 The output is single bytes on a line, suitable for .cfi_escape. */
2244 output_loc_operands_raw (dw_loc_descr_ref loc
)
2246 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2247 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2249 switch (loc
->dw_loc_opc
)
2252 case DW_OP_GNU_addr_index
:
2253 case DW_OP_GNU_const_index
:
2254 case DW_OP_implicit_value
:
2255 /* We cannot output addresses in .cfi_escape, only bytes. */
2261 case DW_OP_deref_size
:
2262 case DW_OP_xderef_size
:
2263 fputc (',', asm_out_file
);
2264 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2269 fputc (',', asm_out_file
);
2270 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2275 fputc (',', asm_out_file
);
2276 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2281 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2282 fputc (',', asm_out_file
);
2283 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2291 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2292 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2294 fputc (',', asm_out_file
);
2295 dw2_asm_output_data_raw (2, offset
);
2301 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2302 gcc_assert (size_of_uleb128 (r
)
2303 == size_of_uleb128 (val1
->v
.val_unsigned
));
2304 fputc (',', asm_out_file
);
2305 dw2_asm_output_data_uleb128_raw (r
);
2310 case DW_OP_plus_uconst
:
2312 fputc (',', asm_out_file
);
2313 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2316 case DW_OP_bit_piece
:
2317 fputc (',', asm_out_file
);
2318 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2319 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2356 fputc (',', asm_out_file
);
2357 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2362 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2363 gcc_assert (size_of_uleb128 (r
)
2364 == size_of_uleb128 (val1
->v
.val_unsigned
));
2365 fputc (',', asm_out_file
);
2366 dw2_asm_output_data_uleb128_raw (r
);
2367 fputc (',', asm_out_file
);
2368 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2372 case DW_OP_GNU_implicit_pointer
:
2373 case DW_OP_GNU_entry_value
:
2374 case DW_OP_GNU_const_type
:
2375 case DW_OP_GNU_regval_type
:
2376 case DW_OP_GNU_deref_type
:
2377 case DW_OP_GNU_convert
:
2378 case DW_OP_GNU_reinterpret
:
2379 case DW_OP_GNU_parameter_ref
:
2384 /* Other codes have no operands. */
2390 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2394 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2395 /* Output the opcode. */
2396 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2398 unsigned r
= (opc
- DW_OP_breg0
);
2399 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2400 gcc_assert (r
<= 31);
2401 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2403 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2405 unsigned r
= (opc
- DW_OP_reg0
);
2406 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2407 gcc_assert (r
<= 31);
2408 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2410 /* Output the opcode. */
2411 fprintf (asm_out_file
, "%#x", opc
);
2412 output_loc_operands_raw (loc
);
2414 if (!loc
->dw_loc_next
)
2416 loc
= loc
->dw_loc_next
;
2418 fputc (',', asm_out_file
);
2422 /* This function builds a dwarf location descriptor sequence from a
2423 dw_cfa_location, adding the given OFFSET to the result of the
2426 struct dw_loc_descr_node
*
2427 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
2429 struct dw_loc_descr_node
*head
, *tmp
;
2431 offset
+= cfa
->offset
;
2435 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2436 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2437 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2438 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2439 add_loc_descr (&head
, tmp
);
2442 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
2443 add_loc_descr (&head
, tmp
);
2447 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2452 /* This function builds a dwarf location descriptor sequence for
2453 the address at OFFSET from the CFA when stack is aligned to
2456 struct dw_loc_descr_node
*
2457 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2458 HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
2460 struct dw_loc_descr_node
*head
;
2461 unsigned int dwarf_fp
2462 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2464 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2465 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2467 head
= new_reg_loc_descr (dwarf_fp
, 0);
2468 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2469 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2470 loc_descr_plus_const (&head
, offset
);
2473 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2477 /* And now, the support for symbolic debugging information. */
2479 /* .debug_str support. */
2481 static void dwarf2out_init (const char *);
2482 static void dwarf2out_finish (const char *);
2483 static void dwarf2out_early_finish (void);
2484 static void dwarf2out_assembly_start (void);
2485 static void dwarf2out_define (unsigned int, const char *);
2486 static void dwarf2out_undef (unsigned int, const char *);
2487 static void dwarf2out_start_source_file (unsigned, const char *);
2488 static void dwarf2out_end_source_file (unsigned);
2489 static void dwarf2out_function_decl (tree
);
2490 static void dwarf2out_begin_block (unsigned, unsigned);
2491 static void dwarf2out_end_block (unsigned, unsigned);
2492 static bool dwarf2out_ignore_block (const_tree
);
2493 static void dwarf2out_early_global_decl (tree
);
2494 static void dwarf2out_late_global_decl (tree
);
2495 static void dwarf2out_type_decl (tree
, int);
2496 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool);
2497 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2499 static void dwarf2out_abstract_function (tree
);
2500 static void dwarf2out_var_location (rtx_insn
*);
2501 static void dwarf2out_size_function (tree
);
2502 static void dwarf2out_begin_function (tree
);
2503 static void dwarf2out_end_function (unsigned int);
2504 static void dwarf2out_register_main_translation_unit (tree unit
);
2505 static void dwarf2out_set_name (tree
, tree
);
2507 /* The debug hooks structure. */
2509 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2513 dwarf2out_early_finish
,
2514 dwarf2out_assembly_start
,
2517 dwarf2out_start_source_file
,
2518 dwarf2out_end_source_file
,
2519 dwarf2out_begin_block
,
2520 dwarf2out_end_block
,
2521 dwarf2out_ignore_block
,
2522 dwarf2out_source_line
,
2523 dwarf2out_begin_prologue
,
2524 #if VMS_DEBUGGING_INFO
2525 dwarf2out_vms_end_prologue
,
2526 dwarf2out_vms_begin_epilogue
,
2528 debug_nothing_int_charstar
,
2529 debug_nothing_int_charstar
,
2531 dwarf2out_end_epilogue
,
2532 dwarf2out_begin_function
,
2533 dwarf2out_end_function
, /* end_function */
2534 dwarf2out_register_main_translation_unit
,
2535 dwarf2out_function_decl
, /* function_decl */
2536 dwarf2out_early_global_decl
,
2537 dwarf2out_late_global_decl
,
2538 dwarf2out_type_decl
, /* type_decl */
2539 dwarf2out_imported_module_or_decl
,
2540 debug_nothing_tree
, /* deferred_inline_function */
2541 /* The DWARF 2 backend tries to reduce debugging bloat by not
2542 emitting the abstract description of inline functions until
2543 something tries to reference them. */
2544 dwarf2out_abstract_function
, /* outlining_inline_function */
2545 debug_nothing_rtx_code_label
, /* label */
2546 debug_nothing_int
, /* handle_pch */
2547 dwarf2out_var_location
,
2548 dwarf2out_size_function
, /* size_function */
2549 dwarf2out_switch_text_section
,
2551 1, /* start_end_main_source_file */
2552 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2555 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2558 debug_nothing_charstar
,
2561 debug_nothing_int_charstar
,
2562 debug_nothing_int_charstar
,
2563 debug_nothing_int_charstar
,
2565 debug_nothing_int_int
, /* begin_block */
2566 debug_nothing_int_int
, /* end_block */
2567 debug_true_const_tree
, /* ignore_block */
2568 dwarf2out_source_line
, /* source_line */
2569 debug_nothing_int_charstar
, /* begin_prologue */
2570 debug_nothing_int_charstar
, /* end_prologue */
2571 debug_nothing_int_charstar
, /* begin_epilogue */
2572 debug_nothing_int_charstar
, /* end_epilogue */
2573 debug_nothing_tree
, /* begin_function */
2574 debug_nothing_int
, /* end_function */
2575 debug_nothing_tree
, /* register_main_translation_unit */
2576 debug_nothing_tree
, /* function_decl */
2577 debug_nothing_tree
, /* early_global_decl */
2578 debug_nothing_tree
, /* late_global_decl */
2579 debug_nothing_tree_int
, /* type_decl */
2580 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
2581 debug_nothing_tree
, /* deferred_inline_function */
2582 debug_nothing_tree
, /* outlining_inline_function */
2583 debug_nothing_rtx_code_label
, /* label */
2584 debug_nothing_int
, /* handle_pch */
2585 debug_nothing_rtx_insn
, /* var_location */
2586 debug_nothing_tree
, /* size_function */
2587 debug_nothing_void
, /* switch_text_section */
2588 debug_nothing_tree_tree
, /* set_name */
2589 0, /* start_end_main_source_file */
2590 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
2593 /* NOTE: In the comments in this file, many references are made to
2594 "Debugging Information Entries". This term is abbreviated as `DIE'
2595 throughout the remainder of this file. */
2597 /* An internal representation of the DWARF output is built, and then
2598 walked to generate the DWARF debugging info. The walk of the internal
2599 representation is done after the entire program has been compiled.
2600 The types below are used to describe the internal representation. */
2602 /* Whether to put type DIEs into their own section .debug_types instead
2603 of making them part of the .debug_info section. Only supported for
2604 Dwarf V4 or higher and the user didn't disable them through
2605 -fno-debug-types-section. It is more efficient to put them in a
2606 separate comdat sections since the linker will then be able to
2607 remove duplicates. But not all tools support .debug_types sections
2610 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2612 /* Various DIE's use offsets relative to the beginning of the
2613 .debug_info section to refer to each other. */
2615 typedef long int dw_offset
;
2617 struct comdat_type_node
;
2619 /* The entries in the line_info table more-or-less mirror the opcodes
2620 that are used in the real dwarf line table. Arrays of these entries
2621 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2624 enum dw_line_info_opcode
{
2625 /* Emit DW_LNE_set_address; the operand is the label index. */
2628 /* Emit a row to the matrix with the given line. This may be done
2629 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2633 /* Emit a DW_LNS_set_file. */
2636 /* Emit a DW_LNS_set_column. */
2639 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2642 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2643 LI_set_prologue_end
,
2644 LI_set_epilogue_begin
,
2646 /* Emit a DW_LNE_set_discriminator. */
2647 LI_set_discriminator
2650 typedef struct GTY(()) dw_line_info_struct
{
2651 enum dw_line_info_opcode opcode
;
2653 } dw_line_info_entry
;
2656 struct GTY(()) dw_line_info_table
{
2657 /* The label that marks the end of this section. */
2658 const char *end_label
;
2660 /* The values for the last row of the matrix, as collected in the table.
2661 These are used to minimize the changes to the next row. */
2662 unsigned int file_num
;
2663 unsigned int line_num
;
2664 unsigned int column_num
;
2669 vec
<dw_line_info_entry
, va_gc
> *entries
;
2673 /* Each DIE attribute has a field specifying the attribute kind,
2674 a link to the next attribute in the chain, and an attribute value.
2675 Attributes are typically linked below the DIE they modify. */
2677 typedef struct GTY(()) dw_attr_struct
{
2678 enum dwarf_attribute dw_attr
;
2679 dw_val_node dw_attr_val
;
2684 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2685 The children of each node form a circular list linked by
2686 die_sib. die_child points to the node *before* the "first" child node. */
2688 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
2689 union die_symbol_or_type_node
2691 const char * GTY ((tag ("0"))) die_symbol
;
2692 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
2694 GTY ((desc ("%0.comdat_type_p"))) die_id
;
2695 vec
<dw_attr_node
, va_gc
> *die_attr
;
2696 dw_die_ref die_parent
;
2697 dw_die_ref die_child
;
2699 dw_die_ref die_definition
; /* ref from a specification to its definition */
2700 dw_offset die_offset
;
2701 unsigned long die_abbrev
;
2703 unsigned int decl_id
;
2704 enum dwarf_tag die_tag
;
2705 /* Die is used and must not be pruned as unused. */
2706 BOOL_BITFIELD die_perennial_p
: 1;
2707 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
2708 /* Lots of spare bits. */
2712 /* Set to TRUE while dwarf2out_early_global_decl is running. */
2713 static bool early_dwarf
;
2714 struct set_early_dwarf
{
2716 set_early_dwarf () : saved(early_dwarf
) { early_dwarf
= true; }
2717 ~set_early_dwarf () { early_dwarf
= saved
; }
2720 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2721 #define FOR_EACH_CHILD(die, c, expr) do { \
2722 c = die->die_child; \
2726 } while (c != die->die_child); \
2729 /* The pubname structure */
2731 typedef struct GTY(()) pubname_struct
{
2738 struct GTY(()) dw_ranges
{
2739 /* If this is positive, it's a block number, otherwise it's a
2740 bitwise-negated index into dw_ranges_by_label. */
2744 /* A structure to hold a macinfo entry. */
2746 typedef struct GTY(()) macinfo_struct
{
2748 unsigned HOST_WIDE_INT lineno
;
2754 struct GTY(()) dw_ranges_by_label
{
2759 /* The comdat type node structure. */
2760 struct GTY(()) comdat_type_node
2762 dw_die_ref root_die
;
2763 dw_die_ref type_die
;
2764 dw_die_ref skeleton_die
;
2765 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
2766 comdat_type_node
*next
;
2769 /* A list of DIEs for which we can't determine ancestry (parent_die
2770 field) just yet. Later in dwarf2out_finish we will fill in the
2772 typedef struct GTY(()) limbo_die_struct
{
2774 /* The tree for which this DIE was created. We use this to
2775 determine ancestry later. */
2777 struct limbo_die_struct
*next
;
2781 typedef struct skeleton_chain_struct
2785 struct skeleton_chain_struct
*parent
;
2787 skeleton_chain_node
;
2789 /* Define a macro which returns nonzero for a TYPE_DECL which was
2790 implicitly generated for a type.
2792 Note that, unlike the C front-end (which generates a NULL named
2793 TYPE_DECL node for each complete tagged type, each array type,
2794 and each function type node created) the C++ front-end generates
2795 a _named_ TYPE_DECL node for each tagged type node created.
2796 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2797 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2798 front-end, but for each type, tagged or not. */
2800 #define TYPE_DECL_IS_STUB(decl) \
2801 (DECL_NAME (decl) == NULL_TREE \
2802 || (DECL_ARTIFICIAL (decl) \
2803 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2804 /* This is necessary for stub decls that \
2805 appear in nested inline functions. */ \
2806 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2807 && (decl_ultimate_origin (decl) \
2808 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2810 /* Information concerning the compilation unit's programming
2811 language, and compiler version. */
2813 /* Fixed size portion of the DWARF compilation unit header. */
2814 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2815 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2817 /* Fixed size portion of the DWARF comdat type unit header. */
2818 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2819 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2820 + DWARF_OFFSET_SIZE)
2822 /* Fixed size portion of public names info. */
2823 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2825 /* Fixed size portion of the address range info. */
2826 #define DWARF_ARANGES_HEADER_SIZE \
2827 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2828 DWARF2_ADDR_SIZE * 2) \
2829 - DWARF_INITIAL_LENGTH_SIZE)
2831 /* Size of padding portion in the address range info. It must be
2832 aligned to twice the pointer size. */
2833 #define DWARF_ARANGES_PAD_SIZE \
2834 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2835 DWARF2_ADDR_SIZE * 2) \
2836 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2838 /* Use assembler line directives if available. */
2839 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2840 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2841 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2843 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2847 /* Minimum line offset in a special line info. opcode.
2848 This value was chosen to give a reasonable range of values. */
2849 #define DWARF_LINE_BASE -10
2851 /* First special line opcode - leave room for the standard opcodes. */
2852 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2854 /* Range of line offsets in a special line info. opcode. */
2855 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2857 /* Flag that indicates the initial value of the is_stmt_start flag.
2858 In the present implementation, we do not mark any lines as
2859 the beginning of a source statement, because that information
2860 is not made available by the GCC front-end. */
2861 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2863 /* Maximum number of operations per instruction bundle. */
2864 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2865 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2868 /* This location is used by calc_die_sizes() to keep track
2869 the offset of each DIE within the .debug_info section. */
2870 static unsigned long next_die_offset
;
2872 /* Record the root of the DIE's built for the current compilation unit. */
2873 static GTY(()) dw_die_ref single_comp_unit_die
;
2875 /* A list of type DIEs that have been separated into comdat sections. */
2876 static GTY(()) comdat_type_node
*comdat_type_list
;
2878 /* A list of DIEs with a NULL parent waiting to be relocated. */
2879 static GTY(()) limbo_die_node
*limbo_die_list
;
2881 /* A list of DIEs for which we may have to generate
2882 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2883 static GTY(()) limbo_die_node
*deferred_asm_name
;
2885 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
2887 typedef const char *compare_type
;
2889 static hashval_t
hash (dwarf_file_data
*);
2890 static bool equal (dwarf_file_data
*, const char *);
2893 /* Filenames referenced by this compilation unit. */
2894 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
2896 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
2898 typedef tree compare_type
;
2900 static hashval_t
hash (die_node
*);
2901 static bool equal (die_node
*, tree
);
2903 /* A hash table of references to DIE's that describe declarations.
2904 The key is a DECL_UID() which is a unique number identifying each decl. */
2905 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
2907 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
2909 static hashval_t
hash (die_struct
*);
2910 static bool equal (die_struct
*, die_struct
*);
2913 /* A hash table of references to DIE's that describe COMMON blocks.
2914 The key is DECL_UID() ^ die_parent. */
2915 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
2917 typedef struct GTY(()) die_arg_entry_struct
{
2923 /* Node of the variable location list. */
2924 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
2925 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2926 EXPR_LIST chain. For small bitsizes, bitsize is encoded
2927 in mode of the EXPR_LIST node and first EXPR_LIST operand
2928 is either NOTE_INSN_VAR_LOCATION for a piece with a known
2929 location or NULL for padding. For larger bitsizes,
2930 mode is 0 and first operand is a CONCAT with bitsize
2931 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2932 NULL as second operand. */
2934 const char * GTY (()) label
;
2935 struct var_loc_node
* GTY (()) next
;
2938 /* Variable location list. */
2939 struct GTY ((for_user
)) var_loc_list_def
{
2940 struct var_loc_node
* GTY (()) first
;
2942 /* Pointer to the last but one or last element of the
2943 chained list. If the list is empty, both first and
2944 last are NULL, if the list contains just one node
2945 or the last node certainly is not redundant, it points
2946 to the last node, otherwise points to the last but one.
2947 Do not mark it for GC because it is marked through the chain. */
2948 struct var_loc_node
* GTY ((skip ("%h"))) last
;
2950 /* Pointer to the last element before section switch,
2951 if NULL, either sections weren't switched or first
2952 is after section switch. */
2953 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
2955 /* DECL_UID of the variable decl. */
2956 unsigned int decl_id
;
2958 typedef struct var_loc_list_def var_loc_list
;
2960 /* Call argument location list. */
2961 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
2962 rtx
GTY (()) call_arg_loc_note
;
2963 const char * GTY (()) label
;
2964 tree
GTY (()) block
;
2966 rtx
GTY (()) symbol_ref
;
2967 struct call_arg_loc_node
* GTY (()) next
;
2971 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
2973 typedef const_tree compare_type
;
2975 static hashval_t
hash (var_loc_list
*);
2976 static bool equal (var_loc_list
*, const_tree
);
2979 /* Table of decl location linked lists. */
2980 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
2982 /* Head and tail of call_arg_loc chain. */
2983 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
2984 static struct call_arg_loc_node
*call_arg_loc_last
;
2986 /* Number of call sites in the current function. */
2987 static int call_site_count
= -1;
2988 /* Number of tail call sites in the current function. */
2989 static int tail_call_site_count
= -1;
2991 /* A cached location list. */
2992 struct GTY ((for_user
)) cached_dw_loc_list_def
{
2993 /* The DECL_UID of the decl that this entry describes. */
2994 unsigned int decl_id
;
2996 /* The cached location list. */
2997 dw_loc_list_ref loc_list
;
2999 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3001 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3004 typedef const_tree compare_type
;
3006 static hashval_t
hash (cached_dw_loc_list
*);
3007 static bool equal (cached_dw_loc_list
*, const_tree
);
3010 /* Table of cached location lists. */
3011 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3013 /* A pointer to the base of a list of references to DIE's that
3014 are uniquely identified by their tag, presence/absence of
3015 children DIE's, and list of attribute/value pairs. */
3016 static GTY((length ("abbrev_die_table_allocated")))
3017 dw_die_ref
*abbrev_die_table
;
3019 /* Number of elements currently allocated for abbrev_die_table. */
3020 static GTY(()) unsigned abbrev_die_table_allocated
;
3022 /* Number of elements in abbrev_die_table currently in use. */
3023 static GTY(()) unsigned abbrev_die_table_in_use
;
3025 /* A hash map to remember the stack usage for DWARF procedures. The value
3026 stored is the stack size difference between before the DWARF procedure
3027 invokation and after it returned. In other words, for a DWARF procedure
3028 that consumes N stack slots and that pushes M ones, this stores M - N. */
3029 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3031 /* Size (in elements) of increments by which we may expand the
3032 abbrev_die_table. */
3033 #define ABBREV_DIE_TABLE_INCREMENT 256
3035 /* A global counter for generating labels for line number data. */
3036 static unsigned int line_info_label_num
;
3038 /* The current table to which we should emit line number information
3039 for the current function. This will be set up at the beginning of
3040 assembly for the function. */
3041 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3043 /* The two default tables of line number info. */
3044 static GTY(()) dw_line_info_table
*text_section_line_info
;
3045 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3047 /* The set of all non-default tables of line number info. */
3048 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3050 /* A flag to tell pubnames/types export if there is an info section to
3052 static bool info_section_emitted
;
3054 /* A pointer to the base of a table that contains a list of publicly
3055 accessible names. */
3056 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3058 /* A pointer to the base of a table that contains a list of publicly
3059 accessible types. */
3060 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3062 /* A pointer to the base of a table that contains a list of macro
3063 defines/undefines (and file start/end markers). */
3064 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3066 /* True if .debug_macinfo or .debug_macros section is going to be
3068 #define have_macinfo \
3069 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3070 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3071 && !macinfo_table->is_empty ())
3073 /* Array of dies for which we should generate .debug_ranges info. */
3074 static GTY ((length ("ranges_table_allocated"))) dw_ranges
*ranges_table
;
3076 /* Number of elements currently allocated for ranges_table. */
3077 static GTY(()) unsigned ranges_table_allocated
;
3079 /* Number of elements in ranges_table currently in use. */
3080 static GTY(()) unsigned ranges_table_in_use
;
3082 /* Array of pairs of labels referenced in ranges_table. */
3083 static GTY ((length ("ranges_by_label_allocated")))
3084 dw_ranges_by_label
*ranges_by_label
;
3086 /* Number of elements currently allocated for ranges_by_label. */
3087 static GTY(()) unsigned ranges_by_label_allocated
;
3089 /* Number of elements in ranges_by_label currently in use. */
3090 static GTY(()) unsigned ranges_by_label_in_use
;
3092 /* Size (in elements) of increments by which we may expand the
3094 #define RANGES_TABLE_INCREMENT 64
3096 /* Whether we have location lists that need outputting */
3097 static GTY(()) bool have_location_lists
;
3099 /* Unique label counter. */
3100 static GTY(()) unsigned int loclabel_num
;
3102 /* Unique label counter for point-of-call tables. */
3103 static GTY(()) unsigned int poc_label_num
;
3105 /* The last file entry emitted by maybe_emit_file(). */
3106 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3108 /* Number of internal labels generated by gen_internal_sym(). */
3109 static GTY(()) int label_num
;
3111 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3113 /* Instances of generic types for which we need to generate debug
3114 info that describe their generic parameters and arguments. That
3115 generation needs to happen once all types are properly laid out so
3116 we do it at the end of compilation. */
3117 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3119 /* Offset from the "steady-state frame pointer" to the frame base,
3120 within the current function. */
3121 static HOST_WIDE_INT frame_pointer_fb_offset
;
3122 static bool frame_pointer_fb_offset_valid
;
3124 static vec
<dw_die_ref
> base_types
;
3126 /* Flags to represent a set of attribute classes for attributes that represent
3127 a scalar value (bounds, pointers, ...). */
3130 dw_scalar_form_constant
= 0x01,
3131 dw_scalar_form_exprloc
= 0x02,
3132 dw_scalar_form_reference
= 0x04
3135 /* Forward declarations for functions defined in this file. */
3137 static int is_pseudo_reg (const_rtx
);
3138 static tree
type_main_variant (tree
);
3139 static int is_tagged_type (const_tree
);
3140 static const char *dwarf_tag_name (unsigned);
3141 static const char *dwarf_attr_name (unsigned);
3142 static const char *dwarf_form_name (unsigned);
3143 static tree
decl_ultimate_origin (const_tree
);
3144 static tree
decl_class_context (tree
);
3145 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3146 static inline enum dw_val_class
AT_class (dw_attr_node
*);
3147 static inline unsigned int AT_index (dw_attr_node
*);
3148 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3149 static inline unsigned AT_flag (dw_attr_node
*);
3150 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3151 static inline HOST_WIDE_INT
AT_int (dw_attr_node
*);
3152 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3153 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_node
*);
3154 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3155 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3156 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3157 unsigned int, unsigned char *);
3158 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3159 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3160 static inline const char *AT_string (dw_attr_node
*);
3161 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3162 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3163 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3164 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3165 static inline int AT_ref_external (dw_attr_node
*);
3166 static inline void set_AT_ref_external (dw_attr_node
*, int);
3167 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3168 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3169 static inline dw_loc_descr_ref
AT_loc (dw_attr_node
*);
3170 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3172 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3173 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3174 static void remove_addr_table_entry (addr_table_entry
*);
3175 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3176 static inline rtx
AT_addr (dw_attr_node
*);
3177 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3178 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3179 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3180 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3181 unsigned HOST_WIDE_INT
);
3182 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3183 unsigned long, bool);
3184 static inline const char *AT_lbl (dw_attr_node
*);
3185 static dw_attr_node
*get_AT (dw_die_ref
, enum dwarf_attribute
);
3186 static const char *get_AT_low_pc (dw_die_ref
);
3187 static const char *get_AT_hi_pc (dw_die_ref
);
3188 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3189 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3190 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3191 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3192 static bool is_cxx (void);
3193 static bool is_fortran (void);
3194 static bool is_ada (void);
3195 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3196 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3197 static void add_child_die (dw_die_ref
, dw_die_ref
);
3198 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3199 static dw_die_ref
lookup_type_die (tree
);
3200 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3201 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3202 static void equate_type_number_to_die (tree
, dw_die_ref
);
3203 static dw_die_ref
lookup_decl_die (tree
);
3204 static var_loc_list
*lookup_decl_loc (const_tree
);
3205 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3206 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *);
3207 static void print_spaces (FILE *);
3208 static void print_die (dw_die_ref
, FILE *);
3209 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
3210 static dw_die_ref
pop_compile_unit (dw_die_ref
);
3211 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3212 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3213 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3214 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3215 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3216 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3217 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3218 struct md5_ctx
*, int *);
3219 struct checksum_attributes
;
3220 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3221 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3222 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3223 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3224 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3225 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3226 static int same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3227 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3228 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
3229 static void compute_section_prefix (dw_die_ref
);
3230 static int is_type_die (dw_die_ref
);
3231 static int is_comdat_die (dw_die_ref
);
3232 static int is_symbol_die (dw_die_ref
);
3233 static inline bool is_template_instantiation (dw_die_ref
);
3234 static void assign_symbol_names (dw_die_ref
);
3235 static void break_out_includes (dw_die_ref
);
3236 static int is_declaration_die (dw_die_ref
);
3237 static int should_move_die_to_comdat (dw_die_ref
);
3238 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3239 static dw_die_ref
clone_die (dw_die_ref
);
3240 static dw_die_ref
clone_tree (dw_die_ref
);
3241 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3242 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3243 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3244 static dw_die_ref
generate_skeleton (dw_die_ref
);
3245 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3248 static void break_out_comdat_types (dw_die_ref
);
3249 static void copy_decls_for_unworthy_types (dw_die_ref
);
3251 static void add_sibling_attributes (dw_die_ref
);
3252 static void output_location_lists (dw_die_ref
);
3253 static int constant_size (unsigned HOST_WIDE_INT
);
3254 static unsigned long size_of_die (dw_die_ref
);
3255 static void calc_die_sizes (dw_die_ref
);
3256 static void calc_base_type_die_sizes (void);
3257 static void mark_dies (dw_die_ref
);
3258 static void unmark_dies (dw_die_ref
);
3259 static void unmark_all_dies (dw_die_ref
);
3260 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3261 static unsigned long size_of_aranges (void);
3262 static enum dwarf_form
value_format (dw_attr_node
*);
3263 static void output_value_format (dw_attr_node
*);
3264 static void output_abbrev_section (void);
3265 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3266 static void output_die_symbol (dw_die_ref
);
3267 static void output_die (dw_die_ref
);
3268 static void output_compilation_unit_header (void);
3269 static void output_comp_unit (dw_die_ref
, int);
3270 static void output_comdat_type_unit (comdat_type_node
*);
3271 static const char *dwarf2_name (tree
, int);
3272 static void add_pubname (tree
, dw_die_ref
);
3273 static void add_enumerator_pubname (const char *, dw_die_ref
);
3274 static void add_pubname_string (const char *, dw_die_ref
);
3275 static void add_pubtype (tree
, dw_die_ref
);
3276 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3277 static void output_aranges (void);
3278 static unsigned int add_ranges_num (int);
3279 static unsigned int add_ranges (const_tree
);
3280 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3282 static void output_ranges (void);
3283 static dw_line_info_table
*new_line_info_table (void);
3284 static void output_line_info (bool);
3285 static void output_file_names (void);
3286 static dw_die_ref
base_type_die (tree
, bool);
3287 static int is_base_type (tree
);
3288 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, tree
, dw_die_ref
);
3289 static int decl_quals (const_tree
);
3290 static dw_die_ref
modified_type_die (tree
, int, bool, dw_die_ref
);
3291 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3292 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3293 static int type_is_enum (const_tree
);
3294 static unsigned int dbx_reg_number (const_rtx
);
3295 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3296 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3297 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3298 enum var_init_status
);
3299 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3300 enum var_init_status
);
3301 static dw_loc_descr_ref
based_loc_descr (rtx
, HOST_WIDE_INT
,
3302 enum var_init_status
);
3303 static int is_based_loc (const_rtx
);
3304 static bool resolve_one_addr (rtx
*);
3305 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3306 enum var_init_status
);
3307 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3308 enum var_init_status
);
3309 struct loc_descr_context
;
3310 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3311 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3312 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3313 const struct loc_descr_context
*);
3314 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3315 const struct loc_descr_context
*);
3316 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3317 static tree
field_type (const_tree
);
3318 static unsigned int simple_type_align_in_bits (const_tree
);
3319 static unsigned int simple_decl_align_in_bits (const_tree
);
3320 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3322 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3324 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3326 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3327 struct vlr_context
*);
3328 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3329 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3330 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3331 static void insert_float (const_rtx
, unsigned char *);
3332 static rtx
rtl_for_decl_location (tree
);
3333 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3334 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3335 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3336 static void add_name_attribute (dw_die_ref
, const char *);
3337 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3338 static void add_comp_dir_attribute (dw_die_ref
);
3339 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3340 const struct loc_descr_context
*);
3341 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3342 const struct loc_descr_context
*);
3343 static void add_subscript_info (dw_die_ref
, tree
, bool);
3344 static void add_byte_size_attribute (dw_die_ref
, tree
);
3345 static inline void add_bit_offset_attribute (dw_die_ref
, tree
,
3346 struct vlr_context
*);
3347 static void add_bit_size_attribute (dw_die_ref
, tree
);
3348 static void add_prototyped_attribute (dw_die_ref
, tree
);
3349 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3350 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3351 static void add_src_coords_attributes (dw_die_ref
, tree
);
3352 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
3353 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3354 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3355 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3356 static void push_decl_scope (tree
);
3357 static void pop_decl_scope (void);
3358 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3359 static inline int local_scope_p (dw_die_ref
);
3360 static inline int class_scope_p (dw_die_ref
);
3361 static inline int class_or_namespace_scope_p (dw_die_ref
);
3362 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3363 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3364 static const char *type_tag (const_tree
);
3365 static tree
member_declared_type (const_tree
);
3367 static const char *decl_start_label (tree
);
3369 static void gen_array_type_die (tree
, dw_die_ref
);
3370 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3372 static void gen_entry_point_die (tree
, dw_die_ref
);
3374 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3375 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3376 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3377 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3378 static void gen_formal_types_die (tree
, dw_die_ref
);
3379 static void gen_subprogram_die (tree
, dw_die_ref
);
3380 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3381 static void gen_const_die (tree
, dw_die_ref
);
3382 static void gen_label_die (tree
, dw_die_ref
);
3383 static void gen_lexical_block_die (tree
, dw_die_ref
);
3384 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3385 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3386 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3387 static dw_die_ref
gen_compile_unit_die (const char *);
3388 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3389 static void gen_member_die (tree
, dw_die_ref
);
3390 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3391 enum debug_info_usage
);
3392 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3393 static void gen_typedef_die (tree
, dw_die_ref
);
3394 static void gen_type_die (tree
, dw_die_ref
);
3395 static void gen_block_die (tree
, dw_die_ref
);
3396 static void decls_for_scope (tree
, dw_die_ref
);
3397 static bool is_naming_typedef_decl (const_tree
);
3398 static inline dw_die_ref
get_context_die (tree
);
3399 static void gen_namespace_die (tree
, dw_die_ref
);
3400 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3401 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3402 static dw_die_ref
force_decl_die (tree
);
3403 static dw_die_ref
force_type_die (tree
);
3404 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3405 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3406 static struct dwarf_file_data
* lookup_filename (const char *);
3407 static void retry_incomplete_types (void);
3408 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3409 static void gen_generic_params_dies (tree
);
3410 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3411 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3412 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3413 static int file_info_cmp (const void *, const void *);
3414 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3415 const char *, const char *);
3416 static void output_loc_list (dw_loc_list_ref
);
3417 static char *gen_internal_sym (const char *);
3418 static bool want_pubnames (void);
3420 static void prune_unmark_dies (dw_die_ref
);
3421 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3422 static void prune_unused_types_mark (dw_die_ref
, int);
3423 static void prune_unused_types_walk (dw_die_ref
);
3424 static void prune_unused_types_walk_attribs (dw_die_ref
);
3425 static void prune_unused_types_prune (dw_die_ref
);
3426 static void prune_unused_types (void);
3427 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3428 static inline const char *AT_vms_delta1 (dw_attr_node
*);
3429 static inline const char *AT_vms_delta2 (dw_attr_node
*);
3430 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3431 const char *, const char *);
3432 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3433 static void gen_remaining_tmpl_value_param_die_attribute (void);
3434 static bool generic_type_p (tree
);
3435 static void schedule_generic_params_dies_gen (tree t
);
3436 static void gen_scheduled_generic_parms_dies (void);
3438 static const char *comp_dir_string (void);
3440 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
3442 /* enum for tracking thread-local variables whose address is really an offset
3443 relative to the TLS pointer, which will need link-time relocation, but will
3444 not need relocation by the DWARF consumer. */
3452 /* Return the operator to use for an address of a variable. For dtprel_true, we
3453 use DW_OP_const*. For regular variables, which need both link-time
3454 relocation and consumer-level relocation (e.g., to account for shared objects
3455 loaded at a random address), we use DW_OP_addr*. */
3457 static inline enum dwarf_location_atom
3458 dw_addr_op (enum dtprel_bool dtprel
)
3460 if (dtprel
== dtprel_true
)
3461 return (dwarf_split_debug_info
? DW_OP_GNU_const_index
3462 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3464 return dwarf_split_debug_info
? DW_OP_GNU_addr_index
: DW_OP_addr
;
3467 /* Return a pointer to a newly allocated address location description. If
3468 dwarf_split_debug_info is true, then record the address with the appropriate
3470 static inline dw_loc_descr_ref
3471 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3473 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3475 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3476 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3477 ref
->dtprel
= dtprel
;
3478 if (dwarf_split_debug_info
)
3479 ref
->dw_loc_oprnd1
.val_entry
3480 = add_addr_table_entry (addr
,
3481 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3483 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3488 /* Section names used to hold DWARF debugging information. */
3490 #ifndef DEBUG_INFO_SECTION
3491 #define DEBUG_INFO_SECTION ".debug_info"
3493 #ifndef DEBUG_DWO_INFO_SECTION
3494 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3496 #ifndef DEBUG_ABBREV_SECTION
3497 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3499 #ifndef DEBUG_DWO_ABBREV_SECTION
3500 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3502 #ifndef DEBUG_ARANGES_SECTION
3503 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3505 #ifndef DEBUG_ADDR_SECTION
3506 #define DEBUG_ADDR_SECTION ".debug_addr"
3508 #ifndef DEBUG_NORM_MACINFO_SECTION
3509 #define DEBUG_NORM_MACINFO_SECTION ".debug_macinfo"
3511 #ifndef DEBUG_DWO_MACINFO_SECTION
3512 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3514 #ifndef DEBUG_MACINFO_SECTION
3515 #define DEBUG_MACINFO_SECTION \
3516 (!dwarf_split_debug_info \
3517 ? (DEBUG_NORM_MACINFO_SECTION) : (DEBUG_DWO_MACINFO_SECTION))
3519 #ifndef DEBUG_NORM_MACRO_SECTION
3520 #define DEBUG_NORM_MACRO_SECTION ".debug_macro"
3522 #ifndef DEBUG_DWO_MACRO_SECTION
3523 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3525 #ifndef DEBUG_MACRO_SECTION
3526 #define DEBUG_MACRO_SECTION \
3527 (!dwarf_split_debug_info \
3528 ? (DEBUG_NORM_MACRO_SECTION) : (DEBUG_DWO_MACRO_SECTION))
3530 #ifndef DEBUG_LINE_SECTION
3531 #define DEBUG_LINE_SECTION ".debug_line"
3533 #ifndef DEBUG_DWO_LINE_SECTION
3534 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3536 #ifndef DEBUG_LOC_SECTION
3537 #define DEBUG_LOC_SECTION ".debug_loc"
3539 #ifndef DEBUG_DWO_LOC_SECTION
3540 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3542 #ifndef DEBUG_PUBNAMES_SECTION
3543 #define DEBUG_PUBNAMES_SECTION \
3544 ((debug_generate_pub_sections == 2) \
3545 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3547 #ifndef DEBUG_PUBTYPES_SECTION
3548 #define DEBUG_PUBTYPES_SECTION \
3549 ((debug_generate_pub_sections == 2) \
3550 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3552 #define DEBUG_NORM_STR_OFFSETS_SECTION ".debug_str_offsets"
3553 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3554 #ifndef DEBUG_STR_OFFSETS_SECTION
3555 #define DEBUG_STR_OFFSETS_SECTION \
3556 (!dwarf_split_debug_info \
3557 ? (DEBUG_NORM_STR_OFFSETS_SECTION) : (DEBUG_DWO_STR_OFFSETS_SECTION))
3559 #ifndef DEBUG_STR_DWO_SECTION
3560 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3562 #ifndef DEBUG_STR_SECTION
3563 #define DEBUG_STR_SECTION ".debug_str"
3565 #ifndef DEBUG_RANGES_SECTION
3566 #define DEBUG_RANGES_SECTION ".debug_ranges"
3569 /* Standard ELF section names for compiled code and data. */
3570 #ifndef TEXT_SECTION_NAME
3571 #define TEXT_SECTION_NAME ".text"
3574 /* Section flags for .debug_macinfo/.debug_macro section. */
3575 #define DEBUG_MACRO_SECTION_FLAGS \
3576 (dwarf_split_debug_info ? SECTION_DEBUG | SECTION_EXCLUDE : SECTION_DEBUG)
3578 /* Section flags for .debug_str section. */
3579 #define DEBUG_STR_SECTION_FLAGS \
3580 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3581 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3584 /* Section flags for .debug_str.dwo section. */
3585 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3587 /* Labels we insert at beginning sections we can reference instead of
3588 the section names themselves. */
3590 #ifndef TEXT_SECTION_LABEL
3591 #define TEXT_SECTION_LABEL "Ltext"
3593 #ifndef COLD_TEXT_SECTION_LABEL
3594 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3596 #ifndef DEBUG_LINE_SECTION_LABEL
3597 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3599 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3600 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3602 #ifndef DEBUG_INFO_SECTION_LABEL
3603 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3605 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3606 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3608 #ifndef DEBUG_ABBREV_SECTION_LABEL
3609 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3611 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3612 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3614 #ifndef DEBUG_ADDR_SECTION_LABEL
3615 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3617 #ifndef DEBUG_LOC_SECTION_LABEL
3618 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3620 #ifndef DEBUG_RANGES_SECTION_LABEL
3621 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3623 #ifndef DEBUG_MACINFO_SECTION_LABEL
3624 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3626 #ifndef DEBUG_MACRO_SECTION_LABEL
3627 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3629 #define SKELETON_COMP_DIE_ABBREV 1
3630 #define SKELETON_TYPE_DIE_ABBREV 2
3632 /* Definitions of defaults for formats and names of various special
3633 (artificial) labels which may be generated within this file (when the -g
3634 options is used and DWARF2_DEBUGGING_INFO is in effect.
3635 If necessary, these may be overridden from within the tm.h file, but
3636 typically, overriding these defaults is unnecessary. */
3638 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3639 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3640 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3641 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3642 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3643 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3644 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3645 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3646 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3647 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3648 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3649 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3650 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3651 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3653 #ifndef TEXT_END_LABEL
3654 #define TEXT_END_LABEL "Letext"
3656 #ifndef COLD_END_LABEL
3657 #define COLD_END_LABEL "Letext_cold"
3659 #ifndef BLOCK_BEGIN_LABEL
3660 #define BLOCK_BEGIN_LABEL "LBB"
3662 #ifndef BLOCK_END_LABEL
3663 #define BLOCK_END_LABEL "LBE"
3665 #ifndef LINE_CODE_LABEL
3666 #define LINE_CODE_LABEL "LM"
3670 /* Return the root of the DIE's built for the current compilation unit. */
3672 comp_unit_die (void)
3674 if (!single_comp_unit_die
)
3675 single_comp_unit_die
= gen_compile_unit_die (NULL
);
3676 return single_comp_unit_die
;
3679 /* We allow a language front-end to designate a function that is to be
3680 called to "demangle" any name before it is put into a DIE. */
3682 static const char *(*demangle_name_func
) (const char *);
3685 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3687 demangle_name_func
= func
;
3690 /* Test if rtl node points to a pseudo register. */
3693 is_pseudo_reg (const_rtx rtl
)
3695 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3696 || (GET_CODE (rtl
) == SUBREG
3697 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3700 /* Return a reference to a type, with its const and volatile qualifiers
3704 type_main_variant (tree type
)
3706 type
= TYPE_MAIN_VARIANT (type
);
3708 /* ??? There really should be only one main variant among any group of
3709 variants of a given type (and all of the MAIN_VARIANT values for all
3710 members of the group should point to that one type) but sometimes the C
3711 front-end messes this up for array types, so we work around that bug
3713 if (TREE_CODE (type
) == ARRAY_TYPE
)
3714 while (type
!= TYPE_MAIN_VARIANT (type
))
3715 type
= TYPE_MAIN_VARIANT (type
);
3720 /* Return nonzero if the given type node represents a tagged type. */
3723 is_tagged_type (const_tree type
)
3725 enum tree_code code
= TREE_CODE (type
);
3727 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
3728 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
3731 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3734 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
3736 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
3739 /* Return die_offset of a DIE reference to a base type. */
3741 static unsigned long int
3742 get_base_type_offset (dw_die_ref ref
)
3744 if (ref
->die_offset
)
3745 return ref
->die_offset
;
3746 if (comp_unit_die ()->die_abbrev
)
3748 calc_base_type_die_sizes ();
3749 gcc_assert (ref
->die_offset
);
3751 return ref
->die_offset
;
3754 /* Return die_offset of a DIE reference other than base type. */
3756 static unsigned long int
3757 get_ref_die_offset (dw_die_ref ref
)
3759 gcc_assert (ref
->die_offset
);
3760 return ref
->die_offset
;
3763 /* Convert a DIE tag into its string name. */
3766 dwarf_tag_name (unsigned int tag
)
3768 const char *name
= get_DW_TAG_name (tag
);
3773 return "DW_TAG_<unknown>";
3776 /* Convert a DWARF attribute code into its string name. */
3779 dwarf_attr_name (unsigned int attr
)
3785 #if VMS_DEBUGGING_INFO
3786 case DW_AT_HP_prologue
:
3787 return "DW_AT_HP_prologue";
3789 case DW_AT_MIPS_loop_unroll_factor
:
3790 return "DW_AT_MIPS_loop_unroll_factor";
3793 #if VMS_DEBUGGING_INFO
3794 case DW_AT_HP_epilogue
:
3795 return "DW_AT_HP_epilogue";
3797 case DW_AT_MIPS_stride
:
3798 return "DW_AT_MIPS_stride";
3802 name
= get_DW_AT_name (attr
);
3807 return "DW_AT_<unknown>";
3810 /* Convert a DWARF value form code into its string name. */
3813 dwarf_form_name (unsigned int form
)
3815 const char *name
= get_DW_FORM_name (form
);
3820 return "DW_FORM_<unknown>";
3823 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3824 instance of an inlined instance of a decl which is local to an inline
3825 function, so we have to trace all of the way back through the origin chain
3826 to find out what sort of node actually served as the original seed for the
3830 decl_ultimate_origin (const_tree decl
)
3832 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
3835 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
3836 we're trying to output the abstract instance of this function. */
3837 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
3840 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3841 most distant ancestor, this should never happen. */
3842 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
3844 return DECL_ABSTRACT_ORIGIN (decl
);
3847 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3848 of a virtual function may refer to a base class, so we check the 'this'
3852 decl_class_context (tree decl
)
3854 tree context
= NULL_TREE
;
3856 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
3857 context
= DECL_CONTEXT (decl
);
3859 context
= TYPE_MAIN_VARIANT
3860 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
3862 if (context
&& !TYPE_P (context
))
3863 context
= NULL_TREE
;
3868 /* Add an attribute/value pair to a DIE. */
3871 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
3873 /* Maybe this should be an assert? */
3877 vec_safe_reserve (die
->die_attr
, 1);
3878 vec_safe_push (die
->die_attr
, *attr
);
3881 static inline enum dw_val_class
3882 AT_class (dw_attr_node
*a
)
3884 return a
->dw_attr_val
.val_class
;
3887 /* Return the index for any attribute that will be referenced with a
3888 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
3889 are stored in dw_attr_val.v.val_str for reference counting
3892 static inline unsigned int
3893 AT_index (dw_attr_node
*a
)
3895 if (AT_class (a
) == dw_val_class_str
)
3896 return a
->dw_attr_val
.v
.val_str
->index
;
3897 else if (a
->dw_attr_val
.val_entry
!= NULL
)
3898 return a
->dw_attr_val
.val_entry
->index
;
3902 /* Add a flag value attribute to a DIE. */
3905 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
3909 attr
.dw_attr
= attr_kind
;
3910 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
3911 attr
.dw_attr_val
.val_entry
= NULL
;
3912 attr
.dw_attr_val
.v
.val_flag
= flag
;
3913 add_dwarf_attr (die
, &attr
);
3916 static inline unsigned
3917 AT_flag (dw_attr_node
*a
)
3919 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
3920 return a
->dw_attr_val
.v
.val_flag
;
3923 /* Add a signed integer attribute value to a DIE. */
3926 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
3930 attr
.dw_attr
= attr_kind
;
3931 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
3932 attr
.dw_attr_val
.val_entry
= NULL
;
3933 attr
.dw_attr_val
.v
.val_int
= int_val
;
3934 add_dwarf_attr (die
, &attr
);
3937 static inline HOST_WIDE_INT
3938 AT_int (dw_attr_node
*a
)
3940 gcc_assert (a
&& AT_class (a
) == dw_val_class_const
);
3941 return a
->dw_attr_val
.v
.val_int
;
3944 /* Add an unsigned integer attribute value to a DIE. */
3947 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3948 unsigned HOST_WIDE_INT unsigned_val
)
3952 attr
.dw_attr
= attr_kind
;
3953 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
3954 attr
.dw_attr_val
.val_entry
= NULL
;
3955 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
3956 add_dwarf_attr (die
, &attr
);
3959 static inline unsigned HOST_WIDE_INT
3960 AT_unsigned (dw_attr_node
*a
)
3962 gcc_assert (a
&& AT_class (a
) == dw_val_class_unsigned_const
);
3963 return a
->dw_attr_val
.v
.val_unsigned
;
3966 /* Add an unsigned wide integer attribute value to a DIE. */
3969 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3974 attr
.dw_attr
= attr_kind
;
3975 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
3976 attr
.dw_attr_val
.val_entry
= NULL
;
3977 attr
.dw_attr_val
.v
.val_wide
= ggc_alloc
<wide_int
> ();
3978 *attr
.dw_attr_val
.v
.val_wide
= w
;
3979 add_dwarf_attr (die
, &attr
);
3982 /* Add an unsigned double integer attribute value to a DIE. */
3985 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3986 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
3990 attr
.dw_attr
= attr_kind
;
3991 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
3992 attr
.dw_attr_val
.val_entry
= NULL
;
3993 attr
.dw_attr_val
.v
.val_double
.high
= high
;
3994 attr
.dw_attr_val
.v
.val_double
.low
= low
;
3995 add_dwarf_attr (die
, &attr
);
3998 /* Add a floating point attribute value to a DIE and return it. */
4001 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4002 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4006 attr
.dw_attr
= attr_kind
;
4007 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4008 attr
.dw_attr_val
.val_entry
= NULL
;
4009 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4010 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4011 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4012 add_dwarf_attr (die
, &attr
);
4015 /* Add an 8-byte data attribute value to a DIE. */
4018 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4019 unsigned char data8
[8])
4023 attr
.dw_attr
= attr_kind
;
4024 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4025 attr
.dw_attr_val
.val_entry
= NULL
;
4026 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4027 add_dwarf_attr (die
, &attr
);
4030 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4031 dwarf_split_debug_info, address attributes in dies destined for the
4032 final executable have force_direct set to avoid using indexed
4036 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4042 lbl_id
= xstrdup (lbl_low
);
4043 attr
.dw_attr
= DW_AT_low_pc
;
4044 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4045 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4046 if (dwarf_split_debug_info
&& !force_direct
)
4047 attr
.dw_attr_val
.val_entry
4048 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4050 attr
.dw_attr_val
.val_entry
= NULL
;
4051 add_dwarf_attr (die
, &attr
);
4053 attr
.dw_attr
= DW_AT_high_pc
;
4054 if (dwarf_version
< 4)
4055 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4057 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4058 lbl_id
= xstrdup (lbl_high
);
4059 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4060 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4061 && dwarf_split_debug_info
&& !force_direct
)
4062 attr
.dw_attr_val
.val_entry
4063 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4065 attr
.dw_attr_val
.val_entry
= NULL
;
4066 add_dwarf_attr (die
, &attr
);
4069 /* Hash and equality functions for debug_str_hash. */
4072 indirect_string_hasher::hash (indirect_string_node
*x
)
4074 return htab_hash_string (x
->str
);
4078 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4080 return strcmp (x1
->str
, x2
) == 0;
4083 /* Add STR to the given string hash table. */
4085 static struct indirect_string_node
*
4086 find_AT_string_in_table (const char *str
,
4087 hash_table
<indirect_string_hasher
> *table
)
4089 struct indirect_string_node
*node
;
4091 indirect_string_node
**slot
4092 = table
->find_slot_with_hash (str
, htab_hash_string (str
), INSERT
);
4095 node
= ggc_cleared_alloc
<indirect_string_node
> ();
4096 node
->str
= ggc_strdup (str
);
4106 /* Add STR to the indirect string hash table. */
4108 static struct indirect_string_node
*
4109 find_AT_string (const char *str
)
4111 if (! debug_str_hash
)
4112 debug_str_hash
= hash_table
<indirect_string_hasher
>::create_ggc (10);
4114 return find_AT_string_in_table (str
, debug_str_hash
);
4117 /* Add a string attribute value to a DIE. */
4120 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4123 struct indirect_string_node
*node
;
4125 node
= find_AT_string (str
);
4127 attr
.dw_attr
= attr_kind
;
4128 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4129 attr
.dw_attr_val
.val_entry
= NULL
;
4130 attr
.dw_attr_val
.v
.val_str
= node
;
4131 add_dwarf_attr (die
, &attr
);
4134 static inline const char *
4135 AT_string (dw_attr_node
*a
)
4137 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4138 return a
->dw_attr_val
.v
.val_str
->str
;
4141 /* Call this function directly to bypass AT_string_form's logic to put
4142 the string inline in the die. */
4145 set_indirect_string (struct indirect_string_node
*node
)
4148 /* Already indirect is a no op. */
4149 if (node
->form
== DW_FORM_strp
|| node
->form
== DW_FORM_GNU_str_index
)
4151 gcc_assert (node
->label
);
4154 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4155 ++dw2_string_counter
;
4156 node
->label
= xstrdup (label
);
4158 if (!dwarf_split_debug_info
)
4160 node
->form
= DW_FORM_strp
;
4161 node
->index
= NOT_INDEXED
;
4165 node
->form
= DW_FORM_GNU_str_index
;
4166 node
->index
= NO_INDEX_ASSIGNED
;
4170 /* Find out whether a string should be output inline in DIE
4171 or out-of-line in .debug_str section. */
4173 static enum dwarf_form
4174 find_string_form (struct indirect_string_node
*node
)
4181 len
= strlen (node
->str
) + 1;
4183 /* If the string is shorter or equal to the size of the reference, it is
4184 always better to put it inline. */
4185 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4186 return node
->form
= DW_FORM_string
;
4188 /* If we cannot expect the linker to merge strings in .debug_str
4189 section, only put it into .debug_str if it is worth even in this
4191 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4192 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4193 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4194 return node
->form
= DW_FORM_string
;
4196 set_indirect_string (node
);
4201 /* Find out whether the string referenced from the attribute should be
4202 output inline in DIE or out-of-line in .debug_str section. */
4204 static enum dwarf_form
4205 AT_string_form (dw_attr_node
*a
)
4207 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4208 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4211 /* Add a DIE reference attribute value to a DIE. */
4214 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4217 gcc_checking_assert (targ_die
!= NULL
);
4219 /* With LTO we can end up trying to reference something we didn't create
4220 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4221 if (targ_die
== NULL
)
4224 attr
.dw_attr
= attr_kind
;
4225 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4226 attr
.dw_attr_val
.val_entry
= NULL
;
4227 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4228 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4229 add_dwarf_attr (die
, &attr
);
4232 /* Change DIE reference REF to point to NEW_DIE instead. */
4235 change_AT_die_ref (dw_attr_node
*ref
, dw_die_ref new_die
)
4237 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4238 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4239 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4242 /* Add an AT_specification attribute to a DIE, and also make the back
4243 pointer from the specification to the definition. */
4246 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4248 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4249 gcc_assert (!targ_die
->die_definition
);
4250 targ_die
->die_definition
= die
;
4253 static inline dw_die_ref
4254 AT_ref (dw_attr_node
*a
)
4256 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4257 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4261 AT_ref_external (dw_attr_node
*a
)
4263 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4264 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4270 set_AT_ref_external (dw_attr_node
*a
, int i
)
4272 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4273 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4276 /* Add an FDE reference attribute value to a DIE. */
4279 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4283 attr
.dw_attr
= attr_kind
;
4284 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4285 attr
.dw_attr_val
.val_entry
= NULL
;
4286 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4287 add_dwarf_attr (die
, &attr
);
4290 /* Add a location description attribute value to a DIE. */
4293 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4297 attr
.dw_attr
= attr_kind
;
4298 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4299 attr
.dw_attr_val
.val_entry
= NULL
;
4300 attr
.dw_attr_val
.v
.val_loc
= loc
;
4301 add_dwarf_attr (die
, &attr
);
4304 static inline dw_loc_descr_ref
4305 AT_loc (dw_attr_node
*a
)
4307 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4308 return a
->dw_attr_val
.v
.val_loc
;
4312 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4316 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4319 attr
.dw_attr
= attr_kind
;
4320 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4321 attr
.dw_attr_val
.val_entry
= NULL
;
4322 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4323 add_dwarf_attr (die
, &attr
);
4324 have_location_lists
= true;
4327 static inline dw_loc_list_ref
4328 AT_loc_list (dw_attr_node
*a
)
4330 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4331 return a
->dw_attr_val
.v
.val_loc_list
;
4334 static inline dw_loc_list_ref
*
4335 AT_loc_list_ptr (dw_attr_node
*a
)
4337 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4338 return &a
->dw_attr_val
.v
.val_loc_list
;
4341 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
4343 static hashval_t
hash (addr_table_entry
*);
4344 static bool equal (addr_table_entry
*, addr_table_entry
*);
4347 /* Table of entries into the .debug_addr section. */
4349 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
4351 /* Hash an address_table_entry. */
4354 addr_hasher::hash (addr_table_entry
*a
)
4356 inchash::hash hstate
;
4362 case ate_kind_rtx_dtprel
:
4365 case ate_kind_label
:
4366 return htab_hash_string (a
->addr
.label
);
4370 inchash::add_rtx (a
->addr
.rtl
, hstate
);
4371 return hstate
.end ();
4374 /* Determine equality for two address_table_entries. */
4377 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
4379 if (a1
->kind
!= a2
->kind
)
4384 case ate_kind_rtx_dtprel
:
4385 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4386 case ate_kind_label
:
4387 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
4393 /* Initialize an addr_table_entry. */
4396 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
4402 case ate_kind_rtx_dtprel
:
4403 e
->addr
.rtl
= (rtx
) addr
;
4405 case ate_kind_label
:
4406 e
->addr
.label
= (char *) addr
;
4410 e
->index
= NO_INDEX_ASSIGNED
;
4413 /* Add attr to the address table entry to the table. Defer setting an
4414 index until output time. */
4416 static addr_table_entry
*
4417 add_addr_table_entry (void *addr
, enum ate_kind kind
)
4419 addr_table_entry
*node
;
4420 addr_table_entry finder
;
4422 gcc_assert (dwarf_split_debug_info
);
4423 if (! addr_index_table
)
4424 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
4425 init_addr_table_entry (&finder
, kind
, addr
);
4426 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
4428 if (*slot
== HTAB_EMPTY_ENTRY
)
4430 node
= ggc_cleared_alloc
<addr_table_entry
> ();
4431 init_addr_table_entry (node
, kind
, addr
);
4441 /* Remove an entry from the addr table by decrementing its refcount.
4442 Strictly, decrementing the refcount would be enough, but the
4443 assertion that the entry is actually in the table has found
4447 remove_addr_table_entry (addr_table_entry
*entry
)
4449 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
4450 /* After an index is assigned, the table is frozen. */
4451 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
4455 /* Given a location list, remove all addresses it refers to from the
4459 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
4461 for (; descr
; descr
= descr
->dw_loc_next
)
4462 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
4464 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
4465 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
4469 /* A helper function for dwarf2out_finish called through
4470 htab_traverse. Assign an addr_table_entry its index. All entries
4471 must be collected into the table when this function is called,
4472 because the indexing code relies on htab_traverse to traverse nodes
4473 in the same order for each run. */
4476 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
4478 addr_table_entry
*node
= *h
;
4480 /* Don't index unreferenced nodes. */
4481 if (node
->refcount
== 0)
4484 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
4485 node
->index
= *index
;
4491 /* Add an address constant attribute value to a DIE. When using
4492 dwarf_split_debug_info, address attributes in dies destined for the
4493 final executable should be direct references--setting the parameter
4494 force_direct ensures this behavior. */
4497 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
4502 attr
.dw_attr
= attr_kind
;
4503 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
4504 attr
.dw_attr_val
.v
.val_addr
= addr
;
4505 if (dwarf_split_debug_info
&& !force_direct
)
4506 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
4508 attr
.dw_attr_val
.val_entry
= NULL
;
4509 add_dwarf_attr (die
, &attr
);
4512 /* Get the RTX from to an address DIE attribute. */
4515 AT_addr (dw_attr_node
*a
)
4517 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
4518 return a
->dw_attr_val
.v
.val_addr
;
4521 /* Add a file attribute value to a DIE. */
4524 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4525 struct dwarf_file_data
*fd
)
4529 attr
.dw_attr
= attr_kind
;
4530 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
4531 attr
.dw_attr_val
.val_entry
= NULL
;
4532 attr
.dw_attr_val
.v
.val_file
= fd
;
4533 add_dwarf_attr (die
, &attr
);
4536 /* Get the dwarf_file_data from a file DIE attribute. */
4538 static inline struct dwarf_file_data
*
4539 AT_file (dw_attr_node
*a
)
4541 gcc_assert (a
&& AT_class (a
) == dw_val_class_file
);
4542 return a
->dw_attr_val
.v
.val_file
;
4545 /* Add a vms delta attribute value to a DIE. */
4548 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4549 const char *lbl1
, const char *lbl2
)
4553 attr
.dw_attr
= attr_kind
;
4554 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
4555 attr
.dw_attr_val
.val_entry
= NULL
;
4556 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
4557 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
4558 add_dwarf_attr (die
, &attr
);
4561 /* Add a label identifier attribute value to a DIE. */
4564 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4569 attr
.dw_attr
= attr_kind
;
4570 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4571 attr
.dw_attr_val
.val_entry
= NULL
;
4572 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4573 if (dwarf_split_debug_info
)
4574 attr
.dw_attr_val
.val_entry
4575 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
4577 add_dwarf_attr (die
, &attr
);
4580 /* Add a section offset attribute value to a DIE, an offset into the
4581 debug_line section. */
4584 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4589 attr
.dw_attr
= attr_kind
;
4590 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
4591 attr
.dw_attr_val
.val_entry
= NULL
;
4592 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4593 add_dwarf_attr (die
, &attr
);
4596 /* Add a section offset attribute value to a DIE, an offset into the
4597 debug_macinfo section. */
4600 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4605 attr
.dw_attr
= attr_kind
;
4606 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
4607 attr
.dw_attr_val
.val_entry
= NULL
;
4608 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4609 add_dwarf_attr (die
, &attr
);
4612 /* Add an offset attribute value to a DIE. */
4615 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4616 unsigned HOST_WIDE_INT offset
)
4620 attr
.dw_attr
= attr_kind
;
4621 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
4622 attr
.dw_attr_val
.val_entry
= NULL
;
4623 attr
.dw_attr_val
.v
.val_offset
= offset
;
4624 add_dwarf_attr (die
, &attr
);
4627 /* Add a range_list attribute value to a DIE. When using
4628 dwarf_split_debug_info, address attributes in dies destined for the
4629 final executable should be direct references--setting the parameter
4630 force_direct ensures this behavior. */
4632 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4633 #define RELOCATED_OFFSET (NULL)
4636 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4637 long unsigned int offset
, bool force_direct
)
4641 attr
.dw_attr
= attr_kind
;
4642 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
4643 /* For the range_list attribute, use val_entry to store whether the
4644 offset should follow split-debug-info or normal semantics. This
4645 value is read in output_range_list_offset. */
4646 if (dwarf_split_debug_info
&& !force_direct
)
4647 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
4649 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
4650 attr
.dw_attr_val
.v
.val_offset
= offset
;
4651 add_dwarf_attr (die
, &attr
);
4654 /* Return the start label of a delta attribute. */
4656 static inline const char *
4657 AT_vms_delta1 (dw_attr_node
*a
)
4659 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4660 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
4663 /* Return the end label of a delta attribute. */
4665 static inline const char *
4666 AT_vms_delta2 (dw_attr_node
*a
)
4668 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4669 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
4672 static inline const char *
4673 AT_lbl (dw_attr_node
*a
)
4675 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
4676 || AT_class (a
) == dw_val_class_lineptr
4677 || AT_class (a
) == dw_val_class_macptr
4678 || AT_class (a
) == dw_val_class_high_pc
));
4679 return a
->dw_attr_val
.v
.val_lbl_id
;
4682 /* Get the attribute of type attr_kind. */
4684 static dw_attr_node
*
4685 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4689 dw_die_ref spec
= NULL
;
4694 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4695 if (a
->dw_attr
== attr_kind
)
4697 else if (a
->dw_attr
== DW_AT_specification
4698 || a
->dw_attr
== DW_AT_abstract_origin
)
4702 return get_AT (spec
, attr_kind
);
4707 /* Returns the parent of the declaration of DIE. */
4710 get_die_parent (dw_die_ref die
)
4717 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
4718 || (t
= get_AT_ref (die
, DW_AT_specification
)))
4721 return die
->die_parent
;
4724 /* Return the "low pc" attribute value, typically associated with a subprogram
4725 DIE. Return null if the "low pc" attribute is either not present, or if it
4726 cannot be represented as an assembler label identifier. */
4728 static inline const char *
4729 get_AT_low_pc (dw_die_ref die
)
4731 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
4733 return a
? AT_lbl (a
) : NULL
;
4736 /* Return the "high pc" attribute value, typically associated with a subprogram
4737 DIE. Return null if the "high pc" attribute is either not present, or if it
4738 cannot be represented as an assembler label identifier. */
4740 static inline const char *
4741 get_AT_hi_pc (dw_die_ref die
)
4743 dw_attr_node
*a
= get_AT (die
, DW_AT_high_pc
);
4745 return a
? AT_lbl (a
) : NULL
;
4748 /* Return the value of the string attribute designated by ATTR_KIND, or
4749 NULL if it is not present. */
4751 static inline const char *
4752 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4754 dw_attr_node
*a
= get_AT (die
, attr_kind
);
4756 return a
? AT_string (a
) : NULL
;
4759 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4760 if it is not present. */
4763 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4765 dw_attr_node
*a
= get_AT (die
, attr_kind
);
4767 return a
? AT_flag (a
) : 0;
4770 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4771 if it is not present. */
4773 static inline unsigned
4774 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4776 dw_attr_node
*a
= get_AT (die
, attr_kind
);
4778 return a
? AT_unsigned (a
) : 0;
4781 static inline dw_die_ref
4782 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4784 dw_attr_node
*a
= get_AT (die
, attr_kind
);
4786 return a
? AT_ref (a
) : NULL
;
4789 static inline struct dwarf_file_data
*
4790 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4792 dw_attr_node
*a
= get_AT (die
, attr_kind
);
4794 return a
? AT_file (a
) : NULL
;
4797 /* Return TRUE if the language is C++. */
4802 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4804 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
4805 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
4808 /* Return TRUE if the language is Java. */
4813 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4815 return lang
== DW_LANG_Java
;
4818 /* Return TRUE if the language is Fortran. */
4823 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4825 return (lang
== DW_LANG_Fortran77
4826 || lang
== DW_LANG_Fortran90
4827 || lang
== DW_LANG_Fortran95
4828 || lang
== DW_LANG_Fortran03
4829 || lang
== DW_LANG_Fortran08
);
4832 /* Return TRUE if the language is Ada. */
4837 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4839 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
4842 /* Remove the specified attribute if present. Return TRUE if removal
4846 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4854 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4855 if (a
->dw_attr
== attr_kind
)
4857 if (AT_class (a
) == dw_val_class_str
)
4858 if (a
->dw_attr_val
.v
.val_str
->refcount
)
4859 a
->dw_attr_val
.v
.val_str
->refcount
--;
4861 /* vec::ordered_remove should help reduce the number of abbrevs
4863 die
->die_attr
->ordered_remove (ix
);
4869 /* Remove CHILD from its parent. PREV must have the property that
4870 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4873 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
4875 gcc_assert (child
->die_parent
== prev
->die_parent
);
4876 gcc_assert (prev
->die_sib
== child
);
4879 gcc_assert (child
->die_parent
->die_child
== child
);
4883 prev
->die_sib
= child
->die_sib
;
4884 if (child
->die_parent
->die_child
== child
)
4885 child
->die_parent
->die_child
= prev
;
4888 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4889 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4892 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
4894 dw_die_ref parent
= old_child
->die_parent
;
4896 gcc_assert (parent
== prev
->die_parent
);
4897 gcc_assert (prev
->die_sib
== old_child
);
4899 new_child
->die_parent
= parent
;
4900 if (prev
== old_child
)
4902 gcc_assert (parent
->die_child
== old_child
);
4903 new_child
->die_sib
= new_child
;
4907 prev
->die_sib
= new_child
;
4908 new_child
->die_sib
= old_child
->die_sib
;
4910 if (old_child
->die_parent
->die_child
== old_child
)
4911 old_child
->die_parent
->die_child
= new_child
;
4914 /* Move all children from OLD_PARENT to NEW_PARENT. */
4917 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
4920 new_parent
->die_child
= old_parent
->die_child
;
4921 old_parent
->die_child
= NULL
;
4922 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
4925 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4929 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
4935 dw_die_ref prev
= c
;
4937 while (c
->die_tag
== tag
)
4939 remove_child_with_prev (c
, prev
);
4940 c
->die_parent
= NULL
;
4941 /* Might have removed every child. */
4942 if (c
== c
->die_sib
)
4946 } while (c
!= die
->die_child
);
4949 /* Add a CHILD_DIE as the last child of DIE. */
4952 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
4954 /* FIXME this should probably be an assert. */
4955 if (! die
|| ! child_die
)
4957 gcc_assert (die
!= child_die
);
4959 child_die
->die_parent
= die
;
4962 child_die
->die_sib
= die
->die_child
->die_sib
;
4963 die
->die_child
->die_sib
= child_die
;
4966 child_die
->die_sib
= child_die
;
4967 die
->die_child
= child_die
;
4970 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
4973 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
4974 dw_die_ref after_die
)
4980 && die
!= child_die
);
4982 child_die
->die_parent
= die
;
4983 child_die
->die_sib
= after_die
->die_sib
;
4984 after_die
->die_sib
= child_die
;
4985 if (die
->die_child
== after_die
)
4986 die
->die_child
= child_die
;
4989 /* Unassociate CHILD from its parent, and make its parent be
4993 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
4995 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
4996 if (p
->die_sib
== child
)
4998 remove_child_with_prev (child
, p
);
5001 add_child_die (new_parent
, child
);
5004 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5005 is the specification, to the end of PARENT's list of children.
5006 This is done by removing and re-adding it. */
5009 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5011 /* We want the declaration DIE from inside the class, not the
5012 specification DIE at toplevel. */
5013 if (child
->die_parent
!= parent
)
5015 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5021 gcc_assert (child
->die_parent
== parent
5022 || (child
->die_parent
5023 == get_AT_ref (parent
, DW_AT_specification
)));
5025 reparent_child (child
, parent
);
5028 /* Create and return a new die with a parent of PARENT_DIE. If
5029 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5030 associated tree T must be supplied to determine parenthood
5033 static inline dw_die_ref
5034 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5036 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5038 die
->die_tag
= tag_value
;
5040 if (parent_die
!= NULL
)
5041 add_child_die (parent_die
, die
);
5044 limbo_die_node
*limbo_node
;
5046 /* No DIEs created after early dwarf should end up in limbo,
5047 because the limbo list should not persist past LTO
5049 if (tag_value
!= DW_TAG_compile_unit
5050 /* These are allowed because they're generated while
5051 breaking out COMDAT units late. */
5052 && tag_value
!= DW_TAG_type_unit
5054 /* Allow nested functions to live in limbo because they will
5055 only temporarily live there, as decls_for_scope will fix
5057 && (TREE_CODE (t
) != FUNCTION_DECL
5058 || !decl_function_context (t
))
5059 /* Same as nested functions above but for types. Types that
5060 are local to a function will be fixed in
5062 && (!RECORD_OR_UNION_TYPE_P (t
)
5063 || !TYPE_CONTEXT (t
)
5064 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5065 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5066 especially in the ltrans stage, but once we implement LTO
5067 dwarf streaming, we should remove this exception. */
5070 fprintf (stderr
, "symbol ended up in limbo too late:");
5071 debug_generic_stmt (t
);
5075 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5076 limbo_node
->die
= die
;
5077 limbo_node
->created_for
= t
;
5078 limbo_node
->next
= limbo_die_list
;
5079 limbo_die_list
= limbo_node
;
5085 /* Return the DIE associated with the given type specifier. */
5087 static inline dw_die_ref
5088 lookup_type_die (tree type
)
5090 return TYPE_SYMTAB_DIE (type
);
5093 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5094 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5095 anonymous type instead the one of the naming typedef. */
5097 static inline dw_die_ref
5098 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5101 && TREE_CODE (type
) == RECORD_TYPE
5103 && type_die
->die_tag
== DW_TAG_typedef
5104 && is_naming_typedef_decl (TYPE_NAME (type
)))
5105 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5109 /* Like lookup_type_die, but if type is an anonymous type named by a
5110 typedef[1], return the DIE of the anonymous type instead the one of
5111 the naming typedef. This is because in gen_typedef_die, we did
5112 equate the anonymous struct named by the typedef with the DIE of
5113 the naming typedef. So by default, lookup_type_die on an anonymous
5114 struct yields the DIE of the naming typedef.
5116 [1]: Read the comment of is_naming_typedef_decl to learn about what
5117 a naming typedef is. */
5119 static inline dw_die_ref
5120 lookup_type_die_strip_naming_typedef (tree type
)
5122 dw_die_ref die
= lookup_type_die (type
);
5123 return strip_naming_typedef (type
, die
);
5126 /* Equate a DIE to a given type specifier. */
5129 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5131 TYPE_SYMTAB_DIE (type
) = type_die
;
5134 /* Returns a hash value for X (which really is a die_struct). */
5137 decl_die_hasher::hash (die_node
*x
)
5139 return (hashval_t
) x
->decl_id
;
5142 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5145 decl_die_hasher::equal (die_node
*x
, tree y
)
5147 return (x
->decl_id
== DECL_UID (y
));
5150 /* Return the DIE associated with a given declaration. */
5152 static inline dw_die_ref
5153 lookup_decl_die (tree decl
)
5155 return decl_die_table
->find_with_hash (decl
, DECL_UID (decl
));
5158 /* Returns a hash value for X (which really is a var_loc_list). */
5161 decl_loc_hasher::hash (var_loc_list
*x
)
5163 return (hashval_t
) x
->decl_id
;
5166 /* Return nonzero if decl_id of var_loc_list X is the same as
5170 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
5172 return (x
->decl_id
== DECL_UID (y
));
5175 /* Return the var_loc list associated with a given declaration. */
5177 static inline var_loc_list
*
5178 lookup_decl_loc (const_tree decl
)
5180 if (!decl_loc_table
)
5182 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
5185 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
5188 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
5190 return (hashval_t
) x
->decl_id
;
5193 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
5197 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
5199 return (x
->decl_id
== DECL_UID (y
));
5202 /* Equate a DIE to a particular declaration. */
5205 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
5207 unsigned int decl_id
= DECL_UID (decl
);
5209 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
5210 decl_die
->decl_id
= decl_id
;
5213 /* Return how many bits covers PIECE EXPR_LIST. */
5215 static HOST_WIDE_INT
5216 decl_piece_bitsize (rtx piece
)
5218 int ret
= (int) GET_MODE (piece
);
5221 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
5222 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
5223 return INTVAL (XEXP (XEXP (piece
, 0), 0));
5226 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5229 decl_piece_varloc_ptr (rtx piece
)
5231 if ((int) GET_MODE (piece
))
5232 return &XEXP (piece
, 0);
5234 return &XEXP (XEXP (piece
, 0), 1);
5237 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5238 Next is the chain of following piece nodes. */
5240 static rtx_expr_list
*
5241 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
5243 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
5244 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
5246 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
5251 /* Return rtx that should be stored into loc field for
5252 LOC_NOTE and BITPOS/BITSIZE. */
5255 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
5256 HOST_WIDE_INT bitsize
)
5260 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
5262 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
5267 /* This function either modifies location piece list *DEST in
5268 place (if SRC and INNER is NULL), or copies location piece list
5269 *SRC to *DEST while modifying it. Location BITPOS is modified
5270 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5271 not copied and if needed some padding around it is added.
5272 When modifying in place, DEST should point to EXPR_LIST where
5273 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5274 to the start of the whole list and INNER points to the EXPR_LIST
5275 where earlier pieces cover PIECE_BITPOS bits. */
5278 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
5279 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
5280 HOST_WIDE_INT bitsize
, rtx loc_note
)
5283 bool copy
= inner
!= NULL
;
5287 /* First copy all nodes preceding the current bitpos. */
5288 while (src
!= inner
)
5290 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5291 decl_piece_bitsize (*src
), NULL_RTX
);
5292 dest
= &XEXP (*dest
, 1);
5293 src
= &XEXP (*src
, 1);
5296 /* Add padding if needed. */
5297 if (bitpos
!= piece_bitpos
)
5299 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
5300 copy
? NULL_RTX
: *dest
);
5301 dest
= &XEXP (*dest
, 1);
5303 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
5306 /* A piece with correct bitpos and bitsize already exist,
5307 just update the location for it and return. */
5308 *decl_piece_varloc_ptr (*dest
) = loc_note
;
5311 /* Add the piece that changed. */
5312 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
5313 dest
= &XEXP (*dest
, 1);
5314 /* Skip over pieces that overlap it. */
5315 diff
= bitpos
- piece_bitpos
+ bitsize
;
5318 while (diff
> 0 && *src
)
5321 diff
-= decl_piece_bitsize (piece
);
5323 src
= &XEXP (piece
, 1);
5326 *src
= XEXP (piece
, 1);
5327 free_EXPR_LIST_node (piece
);
5330 /* Add padding if needed. */
5331 if (diff
< 0 && *src
)
5335 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
5336 dest
= &XEXP (*dest
, 1);
5340 /* Finally copy all nodes following it. */
5343 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5344 decl_piece_bitsize (*src
), NULL_RTX
);
5345 dest
= &XEXP (*dest
, 1);
5346 src
= &XEXP (*src
, 1);
5350 /* Add a variable location node to the linked list for DECL. */
5352 static struct var_loc_node
*
5353 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
)
5355 unsigned int decl_id
;
5357 struct var_loc_node
*loc
= NULL
;
5358 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
5360 if (TREE_CODE (decl
) == VAR_DECL
5361 && DECL_HAS_DEBUG_EXPR_P (decl
))
5363 tree realdecl
= DECL_DEBUG_EXPR (decl
);
5364 if (handled_component_p (realdecl
)
5365 || (TREE_CODE (realdecl
) == MEM_REF
5366 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5368 HOST_WIDE_INT maxsize
;
5371 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
, &maxsize
,
5373 if (!DECL_P (innerdecl
)
5374 || DECL_IGNORED_P (innerdecl
)
5375 || TREE_STATIC (innerdecl
)
5377 || bitpos
+ bitsize
> 256
5378 || bitsize
!= maxsize
)
5384 decl_id
= DECL_UID (decl
);
5386 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
5389 temp
= ggc_cleared_alloc
<var_loc_list
> ();
5390 temp
->decl_id
= decl_id
;
5396 /* For PARM_DECLs try to keep around the original incoming value,
5397 even if that means we'll emit a zero-range .debug_loc entry. */
5399 && temp
->first
== temp
->last
5400 && TREE_CODE (decl
) == PARM_DECL
5401 && NOTE_P (temp
->first
->loc
)
5402 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
5403 && DECL_INCOMING_RTL (decl
)
5404 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
5405 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
5406 == GET_CODE (DECL_INCOMING_RTL (decl
))
5407 && prev_real_insn (temp
->first
->loc
) == NULL_RTX
5409 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
5410 NOTE_VAR_LOCATION_LOC (loc_note
))
5411 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
5412 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
5414 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5415 temp
->first
->next
= loc
;
5417 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5419 else if (temp
->last
)
5421 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
5422 rtx
*piece_loc
= NULL
, last_loc_note
;
5423 HOST_WIDE_INT piece_bitpos
= 0;
5427 gcc_assert (last
->next
== NULL
);
5429 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
5431 piece_loc
= &last
->loc
;
5434 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
5435 if (piece_bitpos
+ cur_bitsize
> bitpos
)
5437 piece_bitpos
+= cur_bitsize
;
5438 piece_loc
= &XEXP (*piece_loc
, 1);
5442 /* TEMP->LAST here is either pointer to the last but one or
5443 last element in the chained list, LAST is pointer to the
5445 if (label
&& strcmp (last
->label
, label
) == 0)
5447 /* For SRA optimized variables if there weren't any real
5448 insns since last note, just modify the last node. */
5449 if (piece_loc
!= NULL
)
5451 adjust_piece_list (piece_loc
, NULL
, NULL
,
5452 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5455 /* If the last note doesn't cover any instructions, remove it. */
5456 if (temp
->last
!= last
)
5458 temp
->last
->next
= NULL
;
5461 gcc_assert (strcmp (last
->label
, label
) != 0);
5465 gcc_assert (temp
->first
== temp
->last
5466 || (temp
->first
->next
== temp
->last
5467 && TREE_CODE (decl
) == PARM_DECL
));
5468 memset (temp
->last
, '\0', sizeof (*temp
->last
));
5469 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5473 if (bitsize
== -1 && NOTE_P (last
->loc
))
5474 last_loc_note
= last
->loc
;
5475 else if (piece_loc
!= NULL
5476 && *piece_loc
!= NULL_RTX
5477 && piece_bitpos
== bitpos
5478 && decl_piece_bitsize (*piece_loc
) == bitsize
)
5479 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
5481 last_loc_note
= NULL_RTX
;
5482 /* If the current location is the same as the end of the list,
5483 and either both or neither of the locations is uninitialized,
5484 we have nothing to do. */
5485 if (last_loc_note
== NULL_RTX
5486 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
5487 NOTE_VAR_LOCATION_LOC (loc_note
)))
5488 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5489 != NOTE_VAR_LOCATION_STATUS (loc_note
))
5490 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5491 == VAR_INIT_STATUS_UNINITIALIZED
)
5492 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
5493 == VAR_INIT_STATUS_UNINITIALIZED
))))
5495 /* Add LOC to the end of list and update LAST. If the last
5496 element of the list has been removed above, reuse its
5497 memory for the new node, otherwise allocate a new one. */
5501 memset (loc
, '\0', sizeof (*loc
));
5504 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5505 if (bitsize
== -1 || piece_loc
== NULL
)
5506 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5508 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
5509 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5511 /* Ensure TEMP->LAST will point either to the new last but one
5512 element of the chain, or to the last element in it. */
5513 if (last
!= temp
->last
)
5521 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5524 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5529 /* Keep track of the number of spaces used to indent the
5530 output of the debugging routines that print the structure of
5531 the DIE internal representation. */
5532 static int print_indent
;
5534 /* Indent the line the number of spaces given by print_indent. */
5537 print_spaces (FILE *outfile
)
5539 fprintf (outfile
, "%*s", print_indent
, "");
5542 /* Print a type signature in hex. */
5545 print_signature (FILE *outfile
, char *sig
)
5549 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
5550 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
5554 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
5556 if (discr_value
->pos
)
5557 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
5559 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
5562 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
5564 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
5565 RECURSE, output location descriptor operations. */
5568 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
5570 switch (val
->val_class
)
5572 case dw_val_class_addr
:
5573 fprintf (outfile
, "address");
5575 case dw_val_class_offset
:
5576 fprintf (outfile
, "offset");
5578 case dw_val_class_loc
:
5579 fprintf (outfile
, "location descriptor");
5580 if (val
->v
.val_loc
== NULL
)
5581 fprintf (outfile
, " -> <null>\n");
5584 fprintf (outfile
, ":\n");
5586 print_loc_descr (val
->v
.val_loc
, outfile
);
5590 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
5592 case dw_val_class_loc_list
:
5593 fprintf (outfile
, "location list -> label:%s",
5594 val
->v
.val_loc_list
->ll_symbol
);
5596 case dw_val_class_range_list
:
5597 fprintf (outfile
, "range list");
5599 case dw_val_class_const
:
5600 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
5602 case dw_val_class_unsigned_const
:
5603 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
5605 case dw_val_class_const_double
:
5606 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
5607 HOST_WIDE_INT_PRINT_UNSIGNED
")",
5608 val
->v
.val_double
.high
,
5609 val
->v
.val_double
.low
);
5611 case dw_val_class_wide_int
:
5613 int i
= val
->v
.val_wide
->get_len ();
5614 fprintf (outfile
, "constant (");
5616 if (val
->v
.val_wide
->elt (i
- 1) == 0)
5617 fprintf (outfile
, "0x");
5618 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
5619 val
->v
.val_wide
->elt (--i
));
5621 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
5622 val
->v
.val_wide
->elt (i
));
5623 fprintf (outfile
, ")");
5626 case dw_val_class_vec
:
5627 fprintf (outfile
, "floating-point or vector constant");
5629 case dw_val_class_flag
:
5630 fprintf (outfile
, "%u", val
->v
.val_flag
);
5632 case dw_val_class_die_ref
:
5633 if (val
->v
.val_die_ref
.die
!= NULL
)
5635 dw_die_ref die
= val
->v
.val_die_ref
.die
;
5637 if (die
->comdat_type_p
)
5639 fprintf (outfile
, "die -> signature: ");
5640 print_signature (outfile
,
5641 die
->die_id
.die_type_node
->signature
);
5643 else if (die
->die_id
.die_symbol
)
5644 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
5646 fprintf (outfile
, "die -> %ld", die
->die_offset
);
5647 fprintf (outfile
, " (%p)", (void *) die
);
5650 fprintf (outfile
, "die -> <null>");
5652 case dw_val_class_vms_delta
:
5653 fprintf (outfile
, "delta: @slotcount(%s-%s)",
5654 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
5656 case dw_val_class_lbl_id
:
5657 case dw_val_class_lineptr
:
5658 case dw_val_class_macptr
:
5659 case dw_val_class_high_pc
:
5660 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
5662 case dw_val_class_str
:
5663 if (val
->v
.val_str
->str
!= NULL
)
5664 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
5666 fprintf (outfile
, "<null>");
5668 case dw_val_class_file
:
5669 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
5670 val
->v
.val_file
->emitted_number
);
5672 case dw_val_class_data8
:
5676 for (i
= 0; i
< 8; i
++)
5677 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
5680 case dw_val_class_discr_value
:
5681 print_discr_value (outfile
, &val
->v
.val_discr_value
);
5683 case dw_val_class_discr_list
:
5684 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
5686 node
= node
->dw_discr_next
)
5688 if (node
->dw_discr_range
)
5690 fprintf (outfile
, " .. ");
5691 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
5692 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
5695 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
5697 if (node
->dw_discr_next
!= NULL
)
5698 fprintf (outfile
, " | ");
5705 /* Likewise, for a DIE attribute. */
5708 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
5710 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
5714 /* Print the list of operands in the LOC location description to OUTFILE. This
5715 routine is a debugging aid only. */
5718 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
5720 dw_loc_descr_ref l
= loc
;
5724 print_spaces (outfile
);
5725 fprintf (outfile
, "<null>\n");
5729 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
5731 print_spaces (outfile
);
5732 fprintf (outfile
, "(%p) %s",
5734 dwarf_stack_op_name (l
->dw_loc_opc
));
5735 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
5737 fprintf (outfile
, " ");
5738 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
5740 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
5742 fprintf (outfile
, ", ");
5743 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
5745 fprintf (outfile
, "\n");
5749 /* Print the information associated with a given DIE, and its children.
5750 This routine is a debugging aid only. */
5753 print_die (dw_die_ref die
, FILE *outfile
)
5759 print_spaces (outfile
);
5760 fprintf (outfile
, "DIE %4ld: %s (%p)\n",
5761 die
->die_offset
, dwarf_tag_name (die
->die_tag
),
5763 print_spaces (outfile
);
5764 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
5765 fprintf (outfile
, " offset: %ld", die
->die_offset
);
5766 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
5768 if (die
->comdat_type_p
)
5770 print_spaces (outfile
);
5771 fprintf (outfile
, " signature: ");
5772 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
5773 fprintf (outfile
, "\n");
5776 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5778 print_spaces (outfile
);
5779 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
5781 print_attribute (a
, true, outfile
);
5782 fprintf (outfile
, "\n");
5785 if (die
->die_child
!= NULL
)
5788 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
5791 if (print_indent
== 0)
5792 fprintf (outfile
, "\n");
5795 /* Print the list of operations in the LOC location description. */
5798 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
5800 print_loc_descr (loc
, stderr
);
5803 /* Print the information collected for a given DIE. */
5806 debug_dwarf_die (dw_die_ref die
)
5808 print_die (die
, stderr
);
5812 debug (die_struct
&ref
)
5814 print_die (&ref
, stderr
);
5818 debug (die_struct
*ptr
)
5823 fprintf (stderr
, "<nil>\n");
5827 /* Print all DWARF information collected for the compilation unit.
5828 This routine is a debugging aid only. */
5834 print_die (comp_unit_die (), stderr
);
5837 /* Sanity checks on DIEs. */
5840 check_die (dw_die_ref die
)
5844 bool inline_found
= false;
5845 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
5846 int n_decl_line
= 0, n_decl_file
= 0;
5847 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5852 if (a
->dw_attr_val
.v
.val_unsigned
)
5853 inline_found
= true;
5855 case DW_AT_location
:
5864 case DW_AT_artificial
:
5867 case DW_AT_decl_line
:
5870 case DW_AT_decl_file
:
5877 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
5878 || n_decl_line
> 1 || n_decl_file
> 1)
5880 fprintf (stderr
, "Duplicate attributes in DIE:\n");
5881 debug_dwarf_die (die
);
5886 /* A debugging information entry that is a member of an abstract
5887 instance tree [that has DW_AT_inline] should not contain any
5888 attributes which describe aspects of the subroutine which vary
5889 between distinct inlined expansions or distinct out-of-line
5891 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5892 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
5893 && a
->dw_attr
!= DW_AT_high_pc
5894 && a
->dw_attr
!= DW_AT_location
5895 && a
->dw_attr
!= DW_AT_frame_base
5896 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
5900 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5901 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5902 DIE that marks the start of the DIEs for this include file. */
5905 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
5907 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
5908 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
5910 new_unit
->die_sib
= old_unit
;
5914 /* Close an include-file CU and reopen the enclosing one. */
5917 pop_compile_unit (dw_die_ref old_unit
)
5919 dw_die_ref new_unit
= old_unit
->die_sib
;
5921 old_unit
->die_sib
= NULL
;
5925 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5926 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5927 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5929 /* Calculate the checksum of a location expression. */
5932 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5935 inchash::hash hstate
;
5938 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
5940 hash_loc_operands (loc
, hstate
);
5941 hash
= hstate
.end();
5945 /* Calculate the checksum of an attribute. */
5948 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
5950 dw_loc_descr_ref loc
;
5953 CHECKSUM (at
->dw_attr
);
5955 /* We don't care that this was compiled with a different compiler
5956 snapshot; if the output is the same, that's what matters. */
5957 if (at
->dw_attr
== DW_AT_producer
)
5960 switch (AT_class (at
))
5962 case dw_val_class_const
:
5963 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
5965 case dw_val_class_unsigned_const
:
5966 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
5968 case dw_val_class_const_double
:
5969 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
5971 case dw_val_class_wide_int
:
5972 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
5973 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
5974 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
5976 case dw_val_class_vec
:
5977 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
5978 (at
->dw_attr_val
.v
.val_vec
.length
5979 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
5981 case dw_val_class_flag
:
5982 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
5984 case dw_val_class_str
:
5985 CHECKSUM_STRING (AT_string (at
));
5988 case dw_val_class_addr
:
5990 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5991 CHECKSUM_STRING (XSTR (r
, 0));
5994 case dw_val_class_offset
:
5995 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
5998 case dw_val_class_loc
:
5999 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6000 loc_checksum (loc
, ctx
);
6003 case dw_val_class_die_ref
:
6004 die_checksum (AT_ref (at
), ctx
, mark
);
6007 case dw_val_class_fde_ref
:
6008 case dw_val_class_vms_delta
:
6009 case dw_val_class_lbl_id
:
6010 case dw_val_class_lineptr
:
6011 case dw_val_class_macptr
:
6012 case dw_val_class_high_pc
:
6015 case dw_val_class_file
:
6016 CHECKSUM_STRING (AT_file (at
)->filename
);
6019 case dw_val_class_data8
:
6020 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6028 /* Calculate the checksum of a DIE. */
6031 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6037 /* To avoid infinite recursion. */
6040 CHECKSUM (die
->die_mark
);
6043 die
->die_mark
= ++(*mark
);
6045 CHECKSUM (die
->die_tag
);
6047 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6048 attr_checksum (a
, ctx
, mark
);
6050 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
6054 #undef CHECKSUM_BLOCK
6055 #undef CHECKSUM_STRING
6057 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
6058 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6059 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6060 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
6061 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
6062 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
6063 #define CHECKSUM_ATTR(FOO) \
6064 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
6066 /* Calculate the checksum of a number in signed LEB128 format. */
6069 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6076 byte
= (value
& 0x7f);
6078 more
= !((value
== 0 && (byte
& 0x40) == 0)
6079 || (value
== -1 && (byte
& 0x40) != 0));
6088 /* Calculate the checksum of a number in unsigned LEB128 format. */
6091 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6095 unsigned char byte
= (value
& 0x7f);
6098 /* More bytes to follow. */
6106 /* Checksum the context of the DIE. This adds the names of any
6107 surrounding namespaces or structures to the checksum. */
6110 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
6114 int tag
= die
->die_tag
;
6116 if (tag
!= DW_TAG_namespace
6117 && tag
!= DW_TAG_structure_type
6118 && tag
!= DW_TAG_class_type
)
6121 name
= get_AT_string (die
, DW_AT_name
);
6123 spec
= get_AT_ref (die
, DW_AT_specification
);
6127 if (die
->die_parent
!= NULL
)
6128 checksum_die_context (die
->die_parent
, ctx
);
6130 CHECKSUM_ULEB128 ('C');
6131 CHECKSUM_ULEB128 (tag
);
6133 CHECKSUM_STRING (name
);
6136 /* Calculate the checksum of a location expression. */
6139 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6141 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
6142 were emitted as a DW_FORM_sdata instead of a location expression. */
6143 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
6145 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6146 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
6150 /* Otherwise, just checksum the raw location expression. */
6153 inchash::hash hstate
;
6156 CHECKSUM_ULEB128 (loc
->dtprel
);
6157 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
6158 hash_loc_operands (loc
, hstate
);
6159 hash
= hstate
.end ();
6161 loc
= loc
->dw_loc_next
;
6165 /* Calculate the checksum of an attribute. */
6168 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
6169 struct md5_ctx
*ctx
, int *mark
)
6171 dw_loc_descr_ref loc
;
6174 if (AT_class (at
) == dw_val_class_die_ref
)
6176 dw_die_ref target_die
= AT_ref (at
);
6178 /* For pointer and reference types, we checksum only the (qualified)
6179 name of the target type (if there is a name). For friend entries,
6180 we checksum only the (qualified) name of the target type or function.
6181 This allows the checksum to remain the same whether the target type
6182 is complete or not. */
6183 if ((at
->dw_attr
== DW_AT_type
6184 && (tag
== DW_TAG_pointer_type
6185 || tag
== DW_TAG_reference_type
6186 || tag
== DW_TAG_rvalue_reference_type
6187 || tag
== DW_TAG_ptr_to_member_type
))
6188 || (at
->dw_attr
== DW_AT_friend
6189 && tag
== DW_TAG_friend
))
6191 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
6193 if (name_attr
!= NULL
)
6195 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
6199 CHECKSUM_ULEB128 ('N');
6200 CHECKSUM_ULEB128 (at
->dw_attr
);
6201 if (decl
->die_parent
!= NULL
)
6202 checksum_die_context (decl
->die_parent
, ctx
);
6203 CHECKSUM_ULEB128 ('E');
6204 CHECKSUM_STRING (AT_string (name_attr
));
6209 /* For all other references to another DIE, we check to see if the
6210 target DIE has already been visited. If it has, we emit a
6211 backward reference; if not, we descend recursively. */
6212 if (target_die
->die_mark
> 0)
6214 CHECKSUM_ULEB128 ('R');
6215 CHECKSUM_ULEB128 (at
->dw_attr
);
6216 CHECKSUM_ULEB128 (target_die
->die_mark
);
6220 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
6224 target_die
->die_mark
= ++(*mark
);
6225 CHECKSUM_ULEB128 ('T');
6226 CHECKSUM_ULEB128 (at
->dw_attr
);
6227 if (decl
->die_parent
!= NULL
)
6228 checksum_die_context (decl
->die_parent
, ctx
);
6229 die_checksum_ordered (target_die
, ctx
, mark
);
6234 CHECKSUM_ULEB128 ('A');
6235 CHECKSUM_ULEB128 (at
->dw_attr
);
6237 switch (AT_class (at
))
6239 case dw_val_class_const
:
6240 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6241 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
6244 case dw_val_class_unsigned_const
:
6245 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6246 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
6249 case dw_val_class_const_double
:
6250 CHECKSUM_ULEB128 (DW_FORM_block
);
6251 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
6252 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6255 case dw_val_class_wide_int
:
6256 CHECKSUM_ULEB128 (DW_FORM_block
);
6257 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6258 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
6259 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6260 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6261 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6264 case dw_val_class_vec
:
6265 CHECKSUM_ULEB128 (DW_FORM_block
);
6266 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
6267 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
6268 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6269 (at
->dw_attr_val
.v
.val_vec
.length
6270 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6273 case dw_val_class_flag
:
6274 CHECKSUM_ULEB128 (DW_FORM_flag
);
6275 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
6278 case dw_val_class_str
:
6279 CHECKSUM_ULEB128 (DW_FORM_string
);
6280 CHECKSUM_STRING (AT_string (at
));
6283 case dw_val_class_addr
:
6285 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6286 CHECKSUM_ULEB128 (DW_FORM_string
);
6287 CHECKSUM_STRING (XSTR (r
, 0));
6290 case dw_val_class_offset
:
6291 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6292 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
6295 case dw_val_class_loc
:
6296 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6297 loc_checksum_ordered (loc
, ctx
);
6300 case dw_val_class_fde_ref
:
6301 case dw_val_class_lbl_id
:
6302 case dw_val_class_lineptr
:
6303 case dw_val_class_macptr
:
6304 case dw_val_class_high_pc
:
6307 case dw_val_class_file
:
6308 CHECKSUM_ULEB128 (DW_FORM_string
);
6309 CHECKSUM_STRING (AT_file (at
)->filename
);
6312 case dw_val_class_data8
:
6313 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6321 struct checksum_attributes
6323 dw_attr_node
*at_name
;
6324 dw_attr_node
*at_type
;
6325 dw_attr_node
*at_friend
;
6326 dw_attr_node
*at_accessibility
;
6327 dw_attr_node
*at_address_class
;
6328 dw_attr_node
*at_allocated
;
6329 dw_attr_node
*at_artificial
;
6330 dw_attr_node
*at_associated
;
6331 dw_attr_node
*at_binary_scale
;
6332 dw_attr_node
*at_bit_offset
;
6333 dw_attr_node
*at_bit_size
;
6334 dw_attr_node
*at_bit_stride
;
6335 dw_attr_node
*at_byte_size
;
6336 dw_attr_node
*at_byte_stride
;
6337 dw_attr_node
*at_const_value
;
6338 dw_attr_node
*at_containing_type
;
6339 dw_attr_node
*at_count
;
6340 dw_attr_node
*at_data_location
;
6341 dw_attr_node
*at_data_member_location
;
6342 dw_attr_node
*at_decimal_scale
;
6343 dw_attr_node
*at_decimal_sign
;
6344 dw_attr_node
*at_default_value
;
6345 dw_attr_node
*at_digit_count
;
6346 dw_attr_node
*at_discr
;
6347 dw_attr_node
*at_discr_list
;
6348 dw_attr_node
*at_discr_value
;
6349 dw_attr_node
*at_encoding
;
6350 dw_attr_node
*at_endianity
;
6351 dw_attr_node
*at_explicit
;
6352 dw_attr_node
*at_is_optional
;
6353 dw_attr_node
*at_location
;
6354 dw_attr_node
*at_lower_bound
;
6355 dw_attr_node
*at_mutable
;
6356 dw_attr_node
*at_ordering
;
6357 dw_attr_node
*at_picture_string
;
6358 dw_attr_node
*at_prototyped
;
6359 dw_attr_node
*at_small
;
6360 dw_attr_node
*at_segment
;
6361 dw_attr_node
*at_string_length
;
6362 dw_attr_node
*at_threads_scaled
;
6363 dw_attr_node
*at_upper_bound
;
6364 dw_attr_node
*at_use_location
;
6365 dw_attr_node
*at_use_UTF8
;
6366 dw_attr_node
*at_variable_parameter
;
6367 dw_attr_node
*at_virtuality
;
6368 dw_attr_node
*at_visibility
;
6369 dw_attr_node
*at_vtable_elem_location
;
6372 /* Collect the attributes that we will want to use for the checksum. */
6375 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
6380 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6391 attrs
->at_friend
= a
;
6393 case DW_AT_accessibility
:
6394 attrs
->at_accessibility
= a
;
6396 case DW_AT_address_class
:
6397 attrs
->at_address_class
= a
;
6399 case DW_AT_allocated
:
6400 attrs
->at_allocated
= a
;
6402 case DW_AT_artificial
:
6403 attrs
->at_artificial
= a
;
6405 case DW_AT_associated
:
6406 attrs
->at_associated
= a
;
6408 case DW_AT_binary_scale
:
6409 attrs
->at_binary_scale
= a
;
6411 case DW_AT_bit_offset
:
6412 attrs
->at_bit_offset
= a
;
6414 case DW_AT_bit_size
:
6415 attrs
->at_bit_size
= a
;
6417 case DW_AT_bit_stride
:
6418 attrs
->at_bit_stride
= a
;
6420 case DW_AT_byte_size
:
6421 attrs
->at_byte_size
= a
;
6423 case DW_AT_byte_stride
:
6424 attrs
->at_byte_stride
= a
;
6426 case DW_AT_const_value
:
6427 attrs
->at_const_value
= a
;
6429 case DW_AT_containing_type
:
6430 attrs
->at_containing_type
= a
;
6433 attrs
->at_count
= a
;
6435 case DW_AT_data_location
:
6436 attrs
->at_data_location
= a
;
6438 case DW_AT_data_member_location
:
6439 attrs
->at_data_member_location
= a
;
6441 case DW_AT_decimal_scale
:
6442 attrs
->at_decimal_scale
= a
;
6444 case DW_AT_decimal_sign
:
6445 attrs
->at_decimal_sign
= a
;
6447 case DW_AT_default_value
:
6448 attrs
->at_default_value
= a
;
6450 case DW_AT_digit_count
:
6451 attrs
->at_digit_count
= a
;
6454 attrs
->at_discr
= a
;
6456 case DW_AT_discr_list
:
6457 attrs
->at_discr_list
= a
;
6459 case DW_AT_discr_value
:
6460 attrs
->at_discr_value
= a
;
6462 case DW_AT_encoding
:
6463 attrs
->at_encoding
= a
;
6465 case DW_AT_endianity
:
6466 attrs
->at_endianity
= a
;
6468 case DW_AT_explicit
:
6469 attrs
->at_explicit
= a
;
6471 case DW_AT_is_optional
:
6472 attrs
->at_is_optional
= a
;
6474 case DW_AT_location
:
6475 attrs
->at_location
= a
;
6477 case DW_AT_lower_bound
:
6478 attrs
->at_lower_bound
= a
;
6481 attrs
->at_mutable
= a
;
6483 case DW_AT_ordering
:
6484 attrs
->at_ordering
= a
;
6486 case DW_AT_picture_string
:
6487 attrs
->at_picture_string
= a
;
6489 case DW_AT_prototyped
:
6490 attrs
->at_prototyped
= a
;
6493 attrs
->at_small
= a
;
6496 attrs
->at_segment
= a
;
6498 case DW_AT_string_length
:
6499 attrs
->at_string_length
= a
;
6501 case DW_AT_threads_scaled
:
6502 attrs
->at_threads_scaled
= a
;
6504 case DW_AT_upper_bound
:
6505 attrs
->at_upper_bound
= a
;
6507 case DW_AT_use_location
:
6508 attrs
->at_use_location
= a
;
6510 case DW_AT_use_UTF8
:
6511 attrs
->at_use_UTF8
= a
;
6513 case DW_AT_variable_parameter
:
6514 attrs
->at_variable_parameter
= a
;
6516 case DW_AT_virtuality
:
6517 attrs
->at_virtuality
= a
;
6519 case DW_AT_visibility
:
6520 attrs
->at_visibility
= a
;
6522 case DW_AT_vtable_elem_location
:
6523 attrs
->at_vtable_elem_location
= a
;
6531 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6534 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6538 struct checksum_attributes attrs
;
6540 CHECKSUM_ULEB128 ('D');
6541 CHECKSUM_ULEB128 (die
->die_tag
);
6543 memset (&attrs
, 0, sizeof (attrs
));
6545 decl
= get_AT_ref (die
, DW_AT_specification
);
6547 collect_checksum_attributes (&attrs
, decl
);
6548 collect_checksum_attributes (&attrs
, die
);
6550 CHECKSUM_ATTR (attrs
.at_name
);
6551 CHECKSUM_ATTR (attrs
.at_accessibility
);
6552 CHECKSUM_ATTR (attrs
.at_address_class
);
6553 CHECKSUM_ATTR (attrs
.at_allocated
);
6554 CHECKSUM_ATTR (attrs
.at_artificial
);
6555 CHECKSUM_ATTR (attrs
.at_associated
);
6556 CHECKSUM_ATTR (attrs
.at_binary_scale
);
6557 CHECKSUM_ATTR (attrs
.at_bit_offset
);
6558 CHECKSUM_ATTR (attrs
.at_bit_size
);
6559 CHECKSUM_ATTR (attrs
.at_bit_stride
);
6560 CHECKSUM_ATTR (attrs
.at_byte_size
);
6561 CHECKSUM_ATTR (attrs
.at_byte_stride
);
6562 CHECKSUM_ATTR (attrs
.at_const_value
);
6563 CHECKSUM_ATTR (attrs
.at_containing_type
);
6564 CHECKSUM_ATTR (attrs
.at_count
);
6565 CHECKSUM_ATTR (attrs
.at_data_location
);
6566 CHECKSUM_ATTR (attrs
.at_data_member_location
);
6567 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
6568 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
6569 CHECKSUM_ATTR (attrs
.at_default_value
);
6570 CHECKSUM_ATTR (attrs
.at_digit_count
);
6571 CHECKSUM_ATTR (attrs
.at_discr
);
6572 CHECKSUM_ATTR (attrs
.at_discr_list
);
6573 CHECKSUM_ATTR (attrs
.at_discr_value
);
6574 CHECKSUM_ATTR (attrs
.at_encoding
);
6575 CHECKSUM_ATTR (attrs
.at_endianity
);
6576 CHECKSUM_ATTR (attrs
.at_explicit
);
6577 CHECKSUM_ATTR (attrs
.at_is_optional
);
6578 CHECKSUM_ATTR (attrs
.at_location
);
6579 CHECKSUM_ATTR (attrs
.at_lower_bound
);
6580 CHECKSUM_ATTR (attrs
.at_mutable
);
6581 CHECKSUM_ATTR (attrs
.at_ordering
);
6582 CHECKSUM_ATTR (attrs
.at_picture_string
);
6583 CHECKSUM_ATTR (attrs
.at_prototyped
);
6584 CHECKSUM_ATTR (attrs
.at_small
);
6585 CHECKSUM_ATTR (attrs
.at_segment
);
6586 CHECKSUM_ATTR (attrs
.at_string_length
);
6587 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
6588 CHECKSUM_ATTR (attrs
.at_upper_bound
);
6589 CHECKSUM_ATTR (attrs
.at_use_location
);
6590 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
6591 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
6592 CHECKSUM_ATTR (attrs
.at_virtuality
);
6593 CHECKSUM_ATTR (attrs
.at_visibility
);
6594 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
6595 CHECKSUM_ATTR (attrs
.at_type
);
6596 CHECKSUM_ATTR (attrs
.at_friend
);
6598 /* Checksum the child DIEs. */
6601 dw_attr_node
*name_attr
;
6604 name_attr
= get_AT (c
, DW_AT_name
);
6605 if (is_template_instantiation (c
))
6607 /* Ignore instantiations of member type and function templates. */
6609 else if (name_attr
!= NULL
6610 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
6612 /* Use a shallow checksum for named nested types and member
6614 CHECKSUM_ULEB128 ('S');
6615 CHECKSUM_ULEB128 (c
->die_tag
);
6616 CHECKSUM_STRING (AT_string (name_attr
));
6620 /* Use a deep checksum for other children. */
6621 /* Mark this DIE so it gets processed when unmarking. */
6622 if (c
->die_mark
== 0)
6624 die_checksum_ordered (c
, ctx
, mark
);
6626 } while (c
!= die
->die_child
);
6628 CHECKSUM_ULEB128 (0);
6631 /* Add a type name and tag to a hash. */
6633 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
6635 CHECKSUM_ULEB128 (tag
);
6636 CHECKSUM_STRING (name
);
6640 #undef CHECKSUM_STRING
6641 #undef CHECKSUM_ATTR
6642 #undef CHECKSUM_LEB128
6643 #undef CHECKSUM_ULEB128
6645 /* Generate the type signature for DIE. This is computed by generating an
6646 MD5 checksum over the DIE's tag, its relevant attributes, and its
6647 children. Attributes that are references to other DIEs are processed
6648 by recursion, using the MARK field to prevent infinite recursion.
6649 If the DIE is nested inside a namespace or another type, we also
6650 need to include that context in the signature. The lower 64 bits
6651 of the resulting MD5 checksum comprise the signature. */
6654 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
6658 unsigned char checksum
[16];
6663 name
= get_AT_string (die
, DW_AT_name
);
6664 decl
= get_AT_ref (die
, DW_AT_specification
);
6665 parent
= get_die_parent (die
);
6667 /* First, compute a signature for just the type name (and its surrounding
6668 context, if any. This is stored in the type unit DIE for link-time
6669 ODR (one-definition rule) checking. */
6671 if (is_cxx () && name
!= NULL
)
6673 md5_init_ctx (&ctx
);
6675 /* Checksum the names of surrounding namespaces and structures. */
6677 checksum_die_context (parent
, &ctx
);
6679 /* Checksum the current DIE. */
6680 die_odr_checksum (die
->die_tag
, name
, &ctx
);
6681 md5_finish_ctx (&ctx
, checksum
);
6683 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
6686 /* Next, compute the complete type signature. */
6688 md5_init_ctx (&ctx
);
6690 die
->die_mark
= mark
;
6692 /* Checksum the names of surrounding namespaces and structures. */
6694 checksum_die_context (parent
, &ctx
);
6696 /* Checksum the DIE and its children. */
6697 die_checksum_ordered (die
, &ctx
, &mark
);
6698 unmark_all_dies (die
);
6699 md5_finish_ctx (&ctx
, checksum
);
6701 /* Store the signature in the type node and link the type DIE and the
6702 type node together. */
6703 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
6704 DWARF_TYPE_SIGNATURE_SIZE
);
6705 die
->comdat_type_p
= true;
6706 die
->die_id
.die_type_node
= type_node
;
6707 type_node
->type_die
= die
;
6709 /* If the DIE is a specification, link its declaration to the type node
6713 decl
->comdat_type_p
= true;
6714 decl
->die_id
.die_type_node
= type_node
;
6718 /* Do the location expressions look same? */
6720 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
6722 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
6723 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
6724 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
6727 /* Do the values look the same? */
6729 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
6731 dw_loc_descr_ref loc1
, loc2
;
6734 if (v1
->val_class
!= v2
->val_class
)
6737 switch (v1
->val_class
)
6739 case dw_val_class_const
:
6740 return v1
->v
.val_int
== v2
->v
.val_int
;
6741 case dw_val_class_unsigned_const
:
6742 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
6743 case dw_val_class_const_double
:
6744 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
6745 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
6746 case dw_val_class_wide_int
:
6747 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
6748 case dw_val_class_vec
:
6749 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
6750 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
6752 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
6753 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
6756 case dw_val_class_flag
:
6757 return v1
->v
.val_flag
== v2
->v
.val_flag
;
6758 case dw_val_class_str
:
6759 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
6761 case dw_val_class_addr
:
6762 r1
= v1
->v
.val_addr
;
6763 r2
= v2
->v
.val_addr
;
6764 if (GET_CODE (r1
) != GET_CODE (r2
))
6766 return !rtx_equal_p (r1
, r2
);
6768 case dw_val_class_offset
:
6769 return v1
->v
.val_offset
== v2
->v
.val_offset
;
6771 case dw_val_class_loc
:
6772 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
6774 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
6775 if (!same_loc_p (loc1
, loc2
, mark
))
6777 return !loc1
&& !loc2
;
6779 case dw_val_class_die_ref
:
6780 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
6782 case dw_val_class_fde_ref
:
6783 case dw_val_class_vms_delta
:
6784 case dw_val_class_lbl_id
:
6785 case dw_val_class_lineptr
:
6786 case dw_val_class_macptr
:
6787 case dw_val_class_high_pc
:
6790 case dw_val_class_file
:
6791 return v1
->v
.val_file
== v2
->v
.val_file
;
6793 case dw_val_class_data8
:
6794 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
6801 /* Do the attributes look the same? */
6804 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
6806 if (at1
->dw_attr
!= at2
->dw_attr
)
6809 /* We don't care that this was compiled with a different compiler
6810 snapshot; if the output is the same, that's what matters. */
6811 if (at1
->dw_attr
== DW_AT_producer
)
6814 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
6817 /* Do the dies look the same? */
6820 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
6826 /* To avoid infinite recursion. */
6828 return die1
->die_mark
== die2
->die_mark
;
6829 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
6831 if (die1
->die_tag
!= die2
->die_tag
)
6834 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
6837 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
6838 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
6841 c1
= die1
->die_child
;
6842 c2
= die2
->die_child
;
6851 if (!same_die_p (c1
, c2
, mark
))
6855 if (c1
== die1
->die_child
)
6857 if (c2
== die2
->die_child
)
6867 /* Do the dies look the same? Wrapper around same_die_p. */
6870 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
6873 int ret
= same_die_p (die1
, die2
, &mark
);
6875 unmark_all_dies (die1
);
6876 unmark_all_dies (die2
);
6881 /* The prefix to attach to symbols on DIEs in the current comdat debug
6883 static const char *comdat_symbol_id
;
6885 /* The index of the current symbol within the current comdat CU. */
6886 static unsigned int comdat_symbol_number
;
6888 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6889 children, and set comdat_symbol_id accordingly. */
6892 compute_section_prefix (dw_die_ref unit_die
)
6894 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
6895 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
6896 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
6899 unsigned char checksum
[16];
6902 /* Compute the checksum of the DIE, then append part of it as hex digits to
6903 the name filename of the unit. */
6905 md5_init_ctx (&ctx
);
6907 die_checksum (unit_die
, &ctx
, &mark
);
6908 unmark_all_dies (unit_die
);
6909 md5_finish_ctx (&ctx
, checksum
);
6911 sprintf (name
, "%s.", base
);
6912 clean_symbol_name (name
);
6914 p
= name
+ strlen (name
);
6915 for (i
= 0; i
< 4; i
++)
6917 sprintf (p
, "%.2x", checksum
[i
]);
6921 comdat_symbol_id
= unit_die
->die_id
.die_symbol
= xstrdup (name
);
6922 comdat_symbol_number
= 0;
6925 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6928 is_type_die (dw_die_ref die
)
6930 switch (die
->die_tag
)
6932 case DW_TAG_array_type
:
6933 case DW_TAG_class_type
:
6934 case DW_TAG_interface_type
:
6935 case DW_TAG_enumeration_type
:
6936 case DW_TAG_pointer_type
:
6937 case DW_TAG_reference_type
:
6938 case DW_TAG_rvalue_reference_type
:
6939 case DW_TAG_string_type
:
6940 case DW_TAG_structure_type
:
6941 case DW_TAG_subroutine_type
:
6942 case DW_TAG_union_type
:
6943 case DW_TAG_ptr_to_member_type
:
6944 case DW_TAG_set_type
:
6945 case DW_TAG_subrange_type
:
6946 case DW_TAG_base_type
:
6947 case DW_TAG_const_type
:
6948 case DW_TAG_file_type
:
6949 case DW_TAG_packed_type
:
6950 case DW_TAG_volatile_type
:
6951 case DW_TAG_typedef
:
6958 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6959 Basically, we want to choose the bits that are likely to be shared between
6960 compilations (types) and leave out the bits that are specific to individual
6961 compilations (functions). */
6964 is_comdat_die (dw_die_ref c
)
6966 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6967 we do for stabs. The advantage is a greater likelihood of sharing between
6968 objects that don't include headers in the same order (and therefore would
6969 put the base types in a different comdat). jason 8/28/00 */
6971 if (c
->die_tag
== DW_TAG_base_type
)
6974 if (c
->die_tag
== DW_TAG_pointer_type
6975 || c
->die_tag
== DW_TAG_reference_type
6976 || c
->die_tag
== DW_TAG_rvalue_reference_type
6977 || c
->die_tag
== DW_TAG_const_type
6978 || c
->die_tag
== DW_TAG_volatile_type
)
6980 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
6982 return t
? is_comdat_die (t
) : 0;
6985 return is_type_die (c
);
6988 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6989 compilation unit. */
6992 is_symbol_die (dw_die_ref c
)
6994 return (is_type_die (c
)
6995 || is_declaration_die (c
)
6996 || c
->die_tag
== DW_TAG_namespace
6997 || c
->die_tag
== DW_TAG_module
);
7000 /* Returns true iff C is a compile-unit DIE. */
7003 is_cu_die (dw_die_ref c
)
7005 return c
&& c
->die_tag
== DW_TAG_compile_unit
;
7008 /* Returns true iff C is a unit DIE of some sort. */
7011 is_unit_die (dw_die_ref c
)
7013 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7014 || c
->die_tag
== DW_TAG_partial_unit
7015 || c
->die_tag
== DW_TAG_type_unit
);
7018 /* Returns true iff C is a namespace DIE. */
7021 is_namespace_die (dw_die_ref c
)
7023 return c
&& c
->die_tag
== DW_TAG_namespace
;
7026 /* Returns true iff C is a class or structure DIE. */
7029 is_class_die (dw_die_ref c
)
7031 return c
&& (c
->die_tag
== DW_TAG_class_type
7032 || c
->die_tag
== DW_TAG_structure_type
);
7035 /* Return non-zero if this DIE is a template parameter. */
7038 is_template_parameter (dw_die_ref die
)
7040 switch (die
->die_tag
)
7042 case DW_TAG_template_type_param
:
7043 case DW_TAG_template_value_param
:
7044 case DW_TAG_GNU_template_template_param
:
7045 case DW_TAG_GNU_template_parameter_pack
:
7052 /* Return non-zero if this DIE represents a template instantiation. */
7055 is_template_instantiation (dw_die_ref die
)
7059 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
7061 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
7066 gen_internal_sym (const char *prefix
)
7070 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
7071 return xstrdup (buf
);
7074 /* Assign symbols to all worthy DIEs under DIE. */
7077 assign_symbol_names (dw_die_ref die
)
7081 if (is_symbol_die (die
) && !die
->comdat_type_p
)
7083 if (comdat_symbol_id
)
7085 char *p
= XALLOCAVEC (char, strlen (comdat_symbol_id
) + 64);
7087 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
7088 comdat_symbol_id
, comdat_symbol_number
++);
7089 die
->die_id
.die_symbol
= xstrdup (p
);
7092 die
->die_id
.die_symbol
= gen_internal_sym ("LDIE");
7095 FOR_EACH_CHILD (die
, c
, assign_symbol_names (c
));
7098 struct cu_hash_table_entry
7101 unsigned min_comdat_num
, max_comdat_num
;
7102 struct cu_hash_table_entry
*next
;
7105 /* Helpers to manipulate hash table of CUs. */
7107 struct cu_hash_table_entry_hasher
: pointer_hash
<cu_hash_table_entry
>
7109 typedef die_struct
*compare_type
;
7110 static inline hashval_t
hash (const cu_hash_table_entry
*);
7111 static inline bool equal (const cu_hash_table_entry
*, const die_struct
*);
7112 static inline void remove (cu_hash_table_entry
*);
7116 cu_hash_table_entry_hasher::hash (const cu_hash_table_entry
*entry
)
7118 return htab_hash_string (entry
->cu
->die_id
.die_symbol
);
7122 cu_hash_table_entry_hasher::equal (const cu_hash_table_entry
*entry1
,
7123 const die_struct
*entry2
)
7125 return !strcmp (entry1
->cu
->die_id
.die_symbol
, entry2
->die_id
.die_symbol
);
7129 cu_hash_table_entry_hasher::remove (cu_hash_table_entry
*entry
)
7131 struct cu_hash_table_entry
*next
;
7141 typedef hash_table
<cu_hash_table_entry_hasher
> cu_hash_type
;
7143 /* Check whether we have already seen this CU and set up SYM_NUM
7146 check_duplicate_cu (dw_die_ref cu
, cu_hash_type
*htable
, unsigned int *sym_num
)
7148 struct cu_hash_table_entry dummy
;
7149 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
7151 dummy
.max_comdat_num
= 0;
7153 slot
= htable
->find_slot_with_hash (cu
,
7154 htab_hash_string (cu
->die_id
.die_symbol
),
7158 for (; entry
; last
= entry
, entry
= entry
->next
)
7160 if (same_die_p_wrap (cu
, entry
->cu
))
7166 *sym_num
= entry
->min_comdat_num
;
7170 entry
= XCNEW (struct cu_hash_table_entry
);
7172 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
7173 entry
->next
= *slot
;
7179 /* Record SYM_NUM to record of CU in HTABLE. */
7181 record_comdat_symbol_number (dw_die_ref cu
, cu_hash_type
*htable
,
7182 unsigned int sym_num
)
7184 struct cu_hash_table_entry
**slot
, *entry
;
7186 slot
= htable
->find_slot_with_hash (cu
,
7187 htab_hash_string (cu
->die_id
.die_symbol
),
7191 entry
->max_comdat_num
= sym_num
;
7194 /* Traverse the DIE (which is always comp_unit_die), and set up
7195 additional compilation units for each of the include files we see
7196 bracketed by BINCL/EINCL. */
7199 break_out_includes (dw_die_ref die
)
7202 dw_die_ref unit
= NULL
;
7203 limbo_die_node
*node
, **pnode
;
7207 dw_die_ref prev
= c
;
7209 while (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
7210 || (unit
&& is_comdat_die (c
)))
7212 dw_die_ref next
= c
->die_sib
;
7214 /* This DIE is for a secondary CU; remove it from the main one. */
7215 remove_child_with_prev (c
, prev
);
7217 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
7218 unit
= push_new_compile_unit (unit
, c
);
7219 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
7220 unit
= pop_compile_unit (unit
);
7222 add_child_die (unit
, c
);
7224 if (c
== die
->die_child
)
7227 } while (c
!= die
->die_child
);
7230 /* We can only use this in debugging, since the frontend doesn't check
7231 to make sure that we leave every include file we enter. */
7235 assign_symbol_names (die
);
7236 cu_hash_type
cu_hash_table (10);
7237 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
7243 compute_section_prefix (node
->die
);
7244 is_dupl
= check_duplicate_cu (node
->die
, &cu_hash_table
,
7245 &comdat_symbol_number
);
7246 assign_symbol_names (node
->die
);
7248 *pnode
= node
->next
;
7251 pnode
= &node
->next
;
7252 record_comdat_symbol_number (node
->die
, &cu_hash_table
,
7253 comdat_symbol_number
);
7258 /* Return non-zero if this DIE is a declaration. */
7261 is_declaration_die (dw_die_ref die
)
7266 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7267 if (a
->dw_attr
== DW_AT_declaration
)
7273 /* Return non-zero if this DIE is nested inside a subprogram. */
7276 is_nested_in_subprogram (dw_die_ref die
)
7278 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
7282 return local_scope_p (decl
);
7285 /* Return non-zero if this DIE contains a defining declaration of a
7289 contains_subprogram_definition (dw_die_ref die
)
7293 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
7295 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
7299 /* Return non-zero if this is a type DIE that should be moved to a
7300 COMDAT .debug_types section. */
7303 should_move_die_to_comdat (dw_die_ref die
)
7305 switch (die
->die_tag
)
7307 case DW_TAG_class_type
:
7308 case DW_TAG_structure_type
:
7309 case DW_TAG_enumeration_type
:
7310 case DW_TAG_union_type
:
7311 /* Don't move declarations, inlined instances, types nested in a
7312 subprogram, or types that contain subprogram definitions. */
7313 if (is_declaration_die (die
)
7314 || get_AT (die
, DW_AT_abstract_origin
)
7315 || is_nested_in_subprogram (die
)
7316 || contains_subprogram_definition (die
))
7319 case DW_TAG_array_type
:
7320 case DW_TAG_interface_type
:
7321 case DW_TAG_pointer_type
:
7322 case DW_TAG_reference_type
:
7323 case DW_TAG_rvalue_reference_type
:
7324 case DW_TAG_string_type
:
7325 case DW_TAG_subroutine_type
:
7326 case DW_TAG_ptr_to_member_type
:
7327 case DW_TAG_set_type
:
7328 case DW_TAG_subrange_type
:
7329 case DW_TAG_base_type
:
7330 case DW_TAG_const_type
:
7331 case DW_TAG_file_type
:
7332 case DW_TAG_packed_type
:
7333 case DW_TAG_volatile_type
:
7334 case DW_TAG_typedef
:
7340 /* Make a clone of DIE. */
7343 clone_die (dw_die_ref die
)
7349 clone
= ggc_cleared_alloc
<die_node
> ();
7350 clone
->die_tag
= die
->die_tag
;
7352 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7353 add_dwarf_attr (clone
, a
);
7358 /* Make a clone of the tree rooted at DIE. */
7361 clone_tree (dw_die_ref die
)
7364 dw_die_ref clone
= clone_die (die
);
7366 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
7371 /* Make a clone of DIE as a declaration. */
7374 clone_as_declaration (dw_die_ref die
)
7381 /* If the DIE is already a declaration, just clone it. */
7382 if (is_declaration_die (die
))
7383 return clone_die (die
);
7385 /* If the DIE is a specification, just clone its declaration DIE. */
7386 decl
= get_AT_ref (die
, DW_AT_specification
);
7389 clone
= clone_die (decl
);
7390 if (die
->comdat_type_p
)
7391 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7395 clone
= ggc_cleared_alloc
<die_node
> ();
7396 clone
->die_tag
= die
->die_tag
;
7398 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7400 /* We don't want to copy over all attributes.
7401 For example we don't want DW_AT_byte_size because otherwise we will no
7402 longer have a declaration and GDB will treat it as a definition. */
7406 case DW_AT_abstract_origin
:
7407 case DW_AT_artificial
:
7408 case DW_AT_containing_type
:
7409 case DW_AT_external
:
7412 case DW_AT_virtuality
:
7413 case DW_AT_linkage_name
:
7414 case DW_AT_MIPS_linkage_name
:
7415 add_dwarf_attr (clone
, a
);
7417 case DW_AT_byte_size
:
7423 if (die
->comdat_type_p
)
7424 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7426 add_AT_flag (clone
, DW_AT_declaration
, 1);
7431 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7433 struct decl_table_entry
7439 /* Helpers to manipulate hash table of copied declarations. */
7441 /* Hashtable helpers. */
7443 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
7445 typedef die_struct
*compare_type
;
7446 static inline hashval_t
hash (const decl_table_entry
*);
7447 static inline bool equal (const decl_table_entry
*, const die_struct
*);
7451 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
7453 return htab_hash_pointer (entry
->orig
);
7457 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
7458 const die_struct
*entry2
)
7460 return entry1
->orig
== entry2
;
7463 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
7465 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7466 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7467 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7468 to check if the ancestor has already been copied into UNIT. */
7471 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
7472 decl_hash_type
*decl_table
)
7474 dw_die_ref parent
= die
->die_parent
;
7475 dw_die_ref new_parent
= unit
;
7477 decl_table_entry
**slot
= NULL
;
7478 struct decl_table_entry
*entry
= NULL
;
7482 /* Check if the entry has already been copied to UNIT. */
7483 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
7485 if (*slot
!= HTAB_EMPTY_ENTRY
)
7491 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7492 entry
= XCNEW (struct decl_table_entry
);
7500 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
7503 if (!is_unit_die (parent
))
7504 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
7507 copy
= clone_as_declaration (die
);
7508 add_child_die (new_parent
, copy
);
7512 /* Record the pointer to the copy. */
7518 /* Copy the declaration context to the new type unit DIE. This includes
7519 any surrounding namespace or type declarations. If the DIE has an
7520 AT_specification attribute, it also includes attributes and children
7521 attached to the specification, and returns a pointer to the original
7522 parent of the declaration DIE. Returns NULL otherwise. */
7525 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
7528 dw_die_ref new_decl
;
7529 dw_die_ref orig_parent
= NULL
;
7531 decl
= get_AT_ref (die
, DW_AT_specification
);
7540 /* The original DIE will be changed to a declaration, and must
7541 be moved to be a child of the original declaration DIE. */
7542 orig_parent
= decl
->die_parent
;
7544 /* Copy the type node pointer from the new DIE to the original
7545 declaration DIE so we can forward references later. */
7546 decl
->comdat_type_p
= true;
7547 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
7549 remove_AT (die
, DW_AT_specification
);
7551 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
7553 if (a
->dw_attr
!= DW_AT_name
7554 && a
->dw_attr
!= DW_AT_declaration
7555 && a
->dw_attr
!= DW_AT_external
)
7556 add_dwarf_attr (die
, a
);
7559 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
7562 if (decl
->die_parent
!= NULL
7563 && !is_unit_die (decl
->die_parent
))
7565 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
7566 if (new_decl
!= NULL
)
7568 remove_AT (new_decl
, DW_AT_signature
);
7569 add_AT_specification (die
, new_decl
);
7576 /* Generate the skeleton ancestor tree for the given NODE, then clone
7577 the DIE and add the clone into the tree. */
7580 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
7582 if (node
->new_die
!= NULL
)
7585 node
->new_die
= clone_as_declaration (node
->old_die
);
7587 if (node
->parent
!= NULL
)
7589 generate_skeleton_ancestor_tree (node
->parent
);
7590 add_child_die (node
->parent
->new_die
, node
->new_die
);
7594 /* Generate a skeleton tree of DIEs containing any declarations that are
7595 found in the original tree. We traverse the tree looking for declaration
7596 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7599 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
7601 skeleton_chain_node node
;
7604 dw_die_ref prev
= NULL
;
7605 dw_die_ref next
= NULL
;
7607 node
.parent
= parent
;
7609 first
= c
= parent
->old_die
->die_child
;
7613 if (prev
== NULL
|| prev
->die_sib
== c
)
7616 next
= (c
== first
? NULL
: c
->die_sib
);
7618 node
.new_die
= NULL
;
7619 if (is_declaration_die (c
))
7621 if (is_template_instantiation (c
))
7623 /* Instantiated templates do not need to be cloned into the
7624 type unit. Just move the DIE and its children back to
7625 the skeleton tree (in the main CU). */
7626 remove_child_with_prev (c
, prev
);
7627 add_child_die (parent
->new_die
, c
);
7632 /* Clone the existing DIE, move the original to the skeleton
7633 tree (which is in the main CU), and put the clone, with
7634 all the original's children, where the original came from
7635 (which is about to be moved to the type unit). */
7636 dw_die_ref clone
= clone_die (c
);
7637 move_all_children (c
, clone
);
7639 /* If the original has a DW_AT_object_pointer attribute,
7640 it would now point to a child DIE just moved to the
7641 cloned tree, so we need to remove that attribute from
7643 remove_AT (c
, DW_AT_object_pointer
);
7645 replace_child (c
, clone
, prev
);
7646 generate_skeleton_ancestor_tree (parent
);
7647 add_child_die (parent
->new_die
, c
);
7652 generate_skeleton_bottom_up (&node
);
7653 } while (next
!= NULL
);
7656 /* Wrapper function for generate_skeleton_bottom_up. */
7659 generate_skeleton (dw_die_ref die
)
7661 skeleton_chain_node node
;
7664 node
.new_die
= NULL
;
7667 /* If this type definition is nested inside another type,
7668 and is not an instantiation of a template, always leave
7669 at least a declaration in its place. */
7670 if (die
->die_parent
!= NULL
7671 && is_type_die (die
->die_parent
)
7672 && !is_template_instantiation (die
))
7673 node
.new_die
= clone_as_declaration (die
);
7675 generate_skeleton_bottom_up (&node
);
7676 return node
.new_die
;
7679 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7680 declaration. The original DIE is moved to a new compile unit so that
7681 existing references to it follow it to the new location. If any of the
7682 original DIE's descendants is a declaration, we need to replace the
7683 original DIE with a skeleton tree and move the declarations back into the
7687 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
7690 dw_die_ref skeleton
, orig_parent
;
7692 /* Copy the declaration context to the type unit DIE. If the returned
7693 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7695 orig_parent
= copy_declaration_context (unit
, child
);
7697 skeleton
= generate_skeleton (child
);
7698 if (skeleton
== NULL
)
7699 remove_child_with_prev (child
, prev
);
7702 skeleton
->comdat_type_p
= true;
7703 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
7705 /* If the original DIE was a specification, we need to put
7706 the skeleton under the parent DIE of the declaration.
7707 This leaves the original declaration in the tree, but
7708 it will be pruned later since there are no longer any
7709 references to it. */
7710 if (orig_parent
!= NULL
)
7712 remove_child_with_prev (child
, prev
);
7713 add_child_die (orig_parent
, skeleton
);
7716 replace_child (child
, skeleton
, prev
);
7723 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
7724 comdat_type_node
*type_node
,
7725 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
7727 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
7728 procedure, put it under TYPE_NODE and return the copy. Continue looking for
7729 DWARF procedure references in the DW_AT_location attribute. */
7732 copy_dwarf_procedure (dw_die_ref die
,
7733 comdat_type_node
*type_node
,
7734 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
7736 /* We do this for COMDAT section, which is DWARFv4 specific, so
7737 DWARF procedure are always DW_TAG_dwarf_procedure DIEs (unlike
7738 DW_TAG_variable in DWARFv3). */
7739 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
7741 /* DWARF procedures are not supposed to have children... */
7742 gcc_assert (die
->die_child
== NULL
);
7744 /* ... and they are supposed to have only one attribute: DW_AT_location. */
7745 gcc_assert (vec_safe_length (die
->die_attr
) == 1
7746 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
7748 /* Do not copy more than once DWARF procedures. */
7750 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
7754 die_copy
= clone_die (die
);
7755 add_child_die (type_node
->root_die
, die_copy
);
7756 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
7760 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
7761 procedures in DIE's attributes. */
7764 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
7765 comdat_type_node
*type_node
,
7766 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
7771 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
7773 dw_loc_descr_ref loc
;
7775 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
7778 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
7780 switch (loc
->dw_loc_opc
)
7784 case DW_OP_call_ref
:
7785 gcc_assert (loc
->dw_loc_oprnd1
.val_class
7786 == dw_val_class_die_ref
);
7787 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
7788 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
7790 copied_dwarf_procs
);
7799 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
7800 rewrite references to point to the copies.
7802 References are looked for in DIE's attributes and recursively in all its
7803 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
7804 mapping from old DWARF procedures to their copy. It is used not to copy
7805 twice the same DWARF procedure under TYPE_NODE. */
7808 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
7809 comdat_type_node
*type_node
,
7810 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
7814 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
7815 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
7817 copied_dwarf_procs
));
7820 /* Traverse the DIE and set up additional .debug_types sections for each
7821 type worthy of being placed in a COMDAT section. */
7824 break_out_comdat_types (dw_die_ref die
)
7828 dw_die_ref prev
= NULL
;
7829 dw_die_ref next
= NULL
;
7830 dw_die_ref unit
= NULL
;
7832 first
= c
= die
->die_child
;
7836 if (prev
== NULL
|| prev
->die_sib
== c
)
7839 next
= (c
== first
? NULL
: c
->die_sib
);
7840 if (should_move_die_to_comdat (c
))
7842 dw_die_ref replacement
;
7843 comdat_type_node
*type_node
;
7845 /* Break out nested types into their own type units. */
7846 break_out_comdat_types (c
);
7848 /* Create a new type unit DIE as the root for the new tree, and
7849 add it to the list of comdat types. */
7850 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
7851 add_AT_unsigned (unit
, DW_AT_language
,
7852 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
7853 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
7854 type_node
->root_die
= unit
;
7855 type_node
->next
= comdat_type_list
;
7856 comdat_type_list
= type_node
;
7858 /* Generate the type signature. */
7859 generate_type_signature (c
, type_node
);
7861 /* Copy the declaration context, attributes, and children of the
7862 declaration into the new type unit DIE, then remove this DIE
7863 from the main CU (or replace it with a skeleton if necessary). */
7864 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
7865 type_node
->skeleton_die
= replacement
;
7867 /* Add the DIE to the new compunit. */
7868 add_child_die (unit
, c
);
7870 /* Types can reference DWARF procedures for type size or data location
7871 expressions. Calls in DWARF expressions cannot target procedures
7872 that are not in the same section. So we must copy DWARF procedures
7873 along with this type and then rewrite references to them. */
7874 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
7875 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
7877 if (replacement
!= NULL
)
7880 else if (c
->die_tag
== DW_TAG_namespace
7881 || c
->die_tag
== DW_TAG_class_type
7882 || c
->die_tag
== DW_TAG_structure_type
7883 || c
->die_tag
== DW_TAG_union_type
)
7885 /* Look for nested types that can be broken out. */
7886 break_out_comdat_types (c
);
7888 } while (next
!= NULL
);
7891 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
7892 Enter all the cloned children into the hash table decl_table. */
7895 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
7899 struct decl_table_entry
*entry
;
7900 decl_table_entry
**slot
;
7902 if (die
->die_tag
== DW_TAG_subprogram
)
7903 clone
= clone_as_declaration (die
);
7905 clone
= clone_die (die
);
7907 slot
= decl_table
->find_slot_with_hash (die
,
7908 htab_hash_pointer (die
), INSERT
);
7910 /* Assert that DIE isn't in the hash table yet. If it would be there
7911 before, the ancestors would be necessarily there as well, therefore
7912 clone_tree_partial wouldn't be called. */
7913 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
7915 entry
= XCNEW (struct decl_table_entry
);
7917 entry
->copy
= clone
;
7920 if (die
->die_tag
!= DW_TAG_subprogram
)
7921 FOR_EACH_CHILD (die
, c
,
7922 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
7927 /* Walk the DIE and its children, looking for references to incomplete
7928 or trivial types that are unmarked (i.e., that are not in the current
7932 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
7938 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7940 if (AT_class (a
) == dw_val_class_die_ref
)
7942 dw_die_ref targ
= AT_ref (a
);
7943 decl_table_entry
**slot
;
7944 struct decl_table_entry
*entry
;
7946 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
7949 slot
= decl_table
->find_slot_with_hash (targ
,
7950 htab_hash_pointer (targ
),
7953 if (*slot
!= HTAB_EMPTY_ENTRY
)
7955 /* TARG has already been copied, so we just need to
7956 modify the reference to point to the copy. */
7958 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
7962 dw_die_ref parent
= unit
;
7963 dw_die_ref copy
= clone_die (targ
);
7965 /* Record in DECL_TABLE that TARG has been copied.
7966 Need to do this now, before the recursive call,
7967 because DECL_TABLE may be expanded and SLOT
7968 would no longer be a valid pointer. */
7969 entry
= XCNEW (struct decl_table_entry
);
7974 /* If TARG is not a declaration DIE, we need to copy its
7976 if (!is_declaration_die (targ
))
7980 add_child_die (copy
,
7981 clone_tree_partial (c
, decl_table
)));
7984 /* Make sure the cloned tree is marked as part of the
7988 /* If TARG has surrounding context, copy its ancestor tree
7989 into the new type unit. */
7990 if (targ
->die_parent
!= NULL
7991 && !is_unit_die (targ
->die_parent
))
7992 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
7995 add_child_die (parent
, copy
);
7996 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
7998 /* Make sure the newly-copied DIE is walked. If it was
7999 installed in a previously-added context, it won't
8000 get visited otherwise. */
8003 /* Find the highest point of the newly-added tree,
8004 mark each node along the way, and walk from there. */
8005 parent
->die_mark
= 1;
8006 while (parent
->die_parent
8007 && parent
->die_parent
->die_mark
== 0)
8009 parent
= parent
->die_parent
;
8010 parent
->die_mark
= 1;
8012 copy_decls_walk (unit
, parent
, decl_table
);
8018 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8021 /* Copy declarations for "unworthy" types into the new comdat section.
8022 Incomplete types, modified types, and certain other types aren't broken
8023 out into comdat sections of their own, so they don't have a signature,
8024 and we need to copy the declaration into the same section so that we
8025 don't have an external reference. */
8028 copy_decls_for_unworthy_types (dw_die_ref unit
)
8031 decl_hash_type
decl_table (10);
8032 copy_decls_walk (unit
, unit
, &decl_table
);
8036 /* Traverse the DIE and add a sibling attribute if it may have the
8037 effect of speeding up access to siblings. To save some space,
8038 avoid generating sibling attributes for DIE's without children. */
8041 add_sibling_attributes (dw_die_ref die
)
8045 if (! die
->die_child
)
8048 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8049 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8051 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8054 /* Output all location lists for the DIE and its children. */
8057 output_location_lists (dw_die_ref die
)
8063 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8064 if (AT_class (a
) == dw_val_class_loc_list
)
8065 output_loc_list (AT_loc_list (a
));
8067 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
8070 /* We want to limit the number of external references, because they are
8071 larger than local references: a relocation takes multiple words, and
8072 even a sig8 reference is always eight bytes, whereas a local reference
8073 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
8074 So if we encounter multiple external references to the same type DIE, we
8075 make a local typedef stub for it and redirect all references there.
8077 This is the element of the hash table for keeping track of these
8087 /* Hashtable helpers. */
8089 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
8091 static inline hashval_t
hash (const external_ref
*);
8092 static inline bool equal (const external_ref
*, const external_ref
*);
8096 external_ref_hasher::hash (const external_ref
*r
)
8098 dw_die_ref die
= r
->type
;
8101 /* We can't use the address of the DIE for hashing, because
8102 that will make the order of the stub DIEs non-deterministic. */
8103 if (! die
->comdat_type_p
)
8104 /* We have a symbol; use it to compute a hash. */
8105 h
= htab_hash_string (die
->die_id
.die_symbol
);
8108 /* We have a type signature; use a subset of the bits as the hash.
8109 The 8-byte signature is at least as large as hashval_t. */
8110 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
8111 memcpy (&h
, type_node
->signature
, sizeof (h
));
8117 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
8119 return r1
->type
== r2
->type
;
8122 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
8124 /* Return a pointer to the external_ref for references to DIE. */
8126 static struct external_ref
*
8127 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
8129 struct external_ref ref
, *ref_p
;
8130 external_ref
**slot
;
8133 slot
= map
->find_slot (&ref
, INSERT
);
8134 if (*slot
!= HTAB_EMPTY_ENTRY
)
8137 ref_p
= XCNEW (struct external_ref
);
8143 /* Subroutine of optimize_external_refs, below.
8145 If we see a type skeleton, record it as our stub. If we see external
8146 references, remember how many we've seen. */
8149 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
8154 struct external_ref
*ref_p
;
8156 if (is_type_die (die
)
8157 && (c
= get_AT_ref (die
, DW_AT_signature
)))
8159 /* This is a local skeleton; use it for local references. */
8160 ref_p
= lookup_external_ref (map
, c
);
8164 /* Scan the DIE references, and remember any that refer to DIEs from
8165 other CUs (i.e. those which are not marked). */
8166 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8167 if (AT_class (a
) == dw_val_class_die_ref
8168 && (c
= AT_ref (a
))->die_mark
== 0
8171 ref_p
= lookup_external_ref (map
, c
);
8175 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
8178 /* htab_traverse callback function for optimize_external_refs, below. SLOT
8179 points to an external_ref, DATA is the CU we're processing. If we don't
8180 already have a local stub, and we have multiple refs, build a stub. */
8183 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
8185 struct external_ref
*ref_p
= *slot
;
8187 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
8189 /* We have multiple references to this type, so build a small stub.
8190 Both of these forms are a bit dodgy from the perspective of the
8191 DWARF standard, since technically they should have names. */
8192 dw_die_ref cu
= data
;
8193 dw_die_ref type
= ref_p
->type
;
8194 dw_die_ref stub
= NULL
;
8196 if (type
->comdat_type_p
)
8198 /* If we refer to this type via sig8, use AT_signature. */
8199 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
8200 add_AT_die_ref (stub
, DW_AT_signature
, type
);
8204 /* Otherwise, use a typedef with no name. */
8205 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
8206 add_AT_die_ref (stub
, DW_AT_type
, type
);
8215 /* DIE is a unit; look through all the DIE references to see if there are
8216 any external references to types, and if so, create local stubs for
8217 them which will be applied in build_abbrev_table. This is useful because
8218 references to local DIEs are smaller. */
8220 static external_ref_hash_type
*
8221 optimize_external_refs (dw_die_ref die
)
8223 external_ref_hash_type
*map
= new external_ref_hash_type (10);
8224 optimize_external_refs_1 (die
, map
);
8225 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
8229 /* The format of each DIE (and its attribute value pairs) is encoded in an
8230 abbreviation table. This routine builds the abbreviation table and assigns
8231 a unique abbreviation id for each abbreviation entry. The children of each
8232 die are visited recursively. */
8235 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
8237 unsigned long abbrev_id
;
8238 unsigned int n_alloc
;
8243 /* Scan the DIE references, and replace any that refer to
8244 DIEs from other CUs (i.e. those which are not marked) with
8245 the local stubs we built in optimize_external_refs. */
8246 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8247 if (AT_class (a
) == dw_val_class_die_ref
8248 && (c
= AT_ref (a
))->die_mark
== 0)
8250 struct external_ref
*ref_p
;
8251 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
8253 ref_p
= lookup_external_ref (extern_map
, c
);
8254 if (ref_p
->stub
&& ref_p
->stub
!= die
)
8255 change_AT_die_ref (a
, ref_p
->stub
);
8257 /* We aren't changing this reference, so mark it external. */
8258 set_AT_ref_external (a
, 1);
8261 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
8263 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
8264 dw_attr_node
*die_a
, *abbrev_a
;
8268 if (abbrev
->die_tag
!= die
->die_tag
)
8270 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
8273 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
8276 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
8278 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
8279 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
8280 || (value_format (abbrev_a
) != value_format (die_a
)))
8290 if (abbrev_id
>= abbrev_die_table_in_use
)
8292 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
8294 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
8295 abbrev_die_table
= GGC_RESIZEVEC (dw_die_ref
, abbrev_die_table
,
8298 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
8299 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
8300 abbrev_die_table_allocated
= n_alloc
;
8303 ++abbrev_die_table_in_use
;
8304 abbrev_die_table
[abbrev_id
] = die
;
8307 die
->die_abbrev
= abbrev_id
;
8308 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
8311 /* Return the power-of-two number of bytes necessary to represent VALUE. */
8314 constant_size (unsigned HOST_WIDE_INT value
)
8321 log
= floor_log2 (value
);
8324 log
= 1 << (floor_log2 (log
) + 1);
8329 /* Return the size of a DIE as it is represented in the
8330 .debug_info section. */
8332 static unsigned long
8333 size_of_die (dw_die_ref die
)
8335 unsigned long size
= 0;
8338 enum dwarf_form form
;
8340 size
+= size_of_uleb128 (die
->die_abbrev
);
8341 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8343 switch (AT_class (a
))
8345 case dw_val_class_addr
:
8346 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8348 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
8349 size
+= size_of_uleb128 (AT_index (a
));
8352 size
+= DWARF2_ADDR_SIZE
;
8354 case dw_val_class_offset
:
8355 size
+= DWARF_OFFSET_SIZE
;
8357 case dw_val_class_loc
:
8359 unsigned long lsize
= size_of_locs (AT_loc (a
));
8362 if (dwarf_version
>= 4)
8363 size
+= size_of_uleb128 (lsize
);
8365 size
+= constant_size (lsize
);
8369 case dw_val_class_loc_list
:
8370 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8372 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
8373 size
+= size_of_uleb128 (AT_index (a
));
8376 size
+= DWARF_OFFSET_SIZE
;
8378 case dw_val_class_range_list
:
8379 size
+= DWARF_OFFSET_SIZE
;
8381 case dw_val_class_const
:
8382 size
+= size_of_sleb128 (AT_int (a
));
8384 case dw_val_class_unsigned_const
:
8386 int csize
= constant_size (AT_unsigned (a
));
8387 if (dwarf_version
== 3
8388 && a
->dw_attr
== DW_AT_data_member_location
8390 size
+= size_of_uleb128 (AT_unsigned (a
));
8395 case dw_val_class_const_double
:
8396 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
8397 if (HOST_BITS_PER_WIDE_INT
>= 64)
8400 case dw_val_class_wide_int
:
8401 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
8402 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
8403 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
8407 case dw_val_class_vec
:
8408 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
8409 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
8410 + a
->dw_attr_val
.v
.val_vec
.length
8411 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
8413 case dw_val_class_flag
:
8414 if (dwarf_version
>= 4)
8415 /* Currently all add_AT_flag calls pass in 1 as last argument,
8416 so DW_FORM_flag_present can be used. If that ever changes,
8417 we'll need to use DW_FORM_flag and have some optimization
8418 in build_abbrev_table that will change those to
8419 DW_FORM_flag_present if it is set to 1 in all DIEs using
8420 the same abbrev entry. */
8421 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
8425 case dw_val_class_die_ref
:
8426 if (AT_ref_external (a
))
8428 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
8429 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
8430 is sized by target address length, whereas in DWARF3
8431 it's always sized as an offset. */
8432 if (use_debug_types
)
8433 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
8434 else if (dwarf_version
== 2)
8435 size
+= DWARF2_ADDR_SIZE
;
8437 size
+= DWARF_OFFSET_SIZE
;
8440 size
+= DWARF_OFFSET_SIZE
;
8442 case dw_val_class_fde_ref
:
8443 size
+= DWARF_OFFSET_SIZE
;
8445 case dw_val_class_lbl_id
:
8446 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8448 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
8449 size
+= size_of_uleb128 (AT_index (a
));
8452 size
+= DWARF2_ADDR_SIZE
;
8454 case dw_val_class_lineptr
:
8455 case dw_val_class_macptr
:
8456 size
+= DWARF_OFFSET_SIZE
;
8458 case dw_val_class_str
:
8459 form
= AT_string_form (a
);
8460 if (form
== DW_FORM_strp
)
8461 size
+= DWARF_OFFSET_SIZE
;
8462 else if (form
== DW_FORM_GNU_str_index
)
8463 size
+= size_of_uleb128 (AT_index (a
));
8465 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
8467 case dw_val_class_file
:
8468 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
8470 case dw_val_class_data8
:
8473 case dw_val_class_vms_delta
:
8474 size
+= DWARF_OFFSET_SIZE
;
8476 case dw_val_class_high_pc
:
8477 size
+= DWARF2_ADDR_SIZE
;
8479 case dw_val_class_discr_value
:
8480 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
8482 case dw_val_class_discr_list
:
8484 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
8486 /* This is a block, so we have the block length and then its
8488 size
+= constant_size (block_size
) + block_size
;
8499 /* Size the debugging information associated with a given DIE. Visits the
8500 DIE's children recursively. Updates the global variable next_die_offset, on
8501 each time through. Uses the current value of next_die_offset to update the
8502 die_offset field in each DIE. */
8505 calc_die_sizes (dw_die_ref die
)
8509 gcc_assert (die
->die_offset
== 0
8510 || (unsigned long int) die
->die_offset
== next_die_offset
);
8511 die
->die_offset
= next_die_offset
;
8512 next_die_offset
+= size_of_die (die
);
8514 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
8516 if (die
->die_child
!= NULL
)
8517 /* Count the null byte used to terminate sibling lists. */
8518 next_die_offset
+= 1;
8521 /* Size just the base type children at the start of the CU.
8522 This is needed because build_abbrev needs to size locs
8523 and sizing of type based stack ops needs to know die_offset
8524 values for the base types. */
8527 calc_base_type_die_sizes (void)
8529 unsigned long die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8531 dw_die_ref base_type
;
8532 #if ENABLE_ASSERT_CHECKING
8533 dw_die_ref prev
= comp_unit_die ()->die_child
;
8536 die_offset
+= size_of_die (comp_unit_die ());
8537 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
8539 #if ENABLE_ASSERT_CHECKING
8540 gcc_assert (base_type
->die_offset
== 0
8541 && prev
->die_sib
== base_type
8542 && base_type
->die_child
== NULL
8543 && base_type
->die_abbrev
);
8546 base_type
->die_offset
= die_offset
;
8547 die_offset
+= size_of_die (base_type
);
8551 /* Set the marks for a die and its children. We do this so
8552 that we know whether or not a reference needs to use FORM_ref_addr; only
8553 DIEs in the same CU will be marked. We used to clear out the offset
8554 and use that as the flag, but ran into ordering problems. */
8557 mark_dies (dw_die_ref die
)
8561 gcc_assert (!die
->die_mark
);
8564 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
8567 /* Clear the marks for a die and its children. */
8570 unmark_dies (dw_die_ref die
)
8574 if (! use_debug_types
)
8575 gcc_assert (die
->die_mark
);
8578 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
8581 /* Clear the marks for a die, its children and referred dies. */
8584 unmark_all_dies (dw_die_ref die
)
8594 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
8596 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8597 if (AT_class (a
) == dw_val_class_die_ref
)
8598 unmark_all_dies (AT_ref (a
));
8601 /* Calculate if the entry should appear in the final output file. It may be
8602 from a pruned a type. */
8605 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
8607 /* By limiting gnu pubnames to definitions only, gold can generate a
8608 gdb index without entries for declarations, which don't include
8609 enough information to be useful. */
8610 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
8613 if (table
== pubname_table
)
8615 /* Enumerator names are part of the pubname table, but the
8616 parent DW_TAG_enumeration_type die may have been pruned.
8617 Don't output them if that is the case. */
8618 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
8619 (p
->die
->die_parent
== NULL
8620 || !p
->die
->die_parent
->die_perennial_p
))
8623 /* Everything else in the pubname table is included. */
8627 /* The pubtypes table shouldn't include types that have been
8629 return (p
->die
->die_offset
!= 0
8630 || !flag_eliminate_unused_debug_types
);
8633 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8634 generated for the compilation unit. */
8636 static unsigned long
8637 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
8642 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
8644 size
= DWARF_PUBNAMES_HEADER_SIZE
;
8645 FOR_EACH_VEC_ELT (*names
, i
, p
)
8646 if (include_pubname_in_output (names
, p
))
8647 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
8649 size
+= DWARF_OFFSET_SIZE
;
8653 /* Return the size of the information in the .debug_aranges section. */
8655 static unsigned long
8656 size_of_aranges (void)
8660 size
= DWARF_ARANGES_HEADER_SIZE
;
8662 /* Count the address/length pair for this compilation unit. */
8663 if (text_section_used
)
8664 size
+= 2 * DWARF2_ADDR_SIZE
;
8665 if (cold_text_section_used
)
8666 size
+= 2 * DWARF2_ADDR_SIZE
;
8667 if (have_multiple_function_sections
)
8672 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
8674 if (DECL_IGNORED_P (fde
->decl
))
8676 if (!fde
->in_std_section
)
8677 size
+= 2 * DWARF2_ADDR_SIZE
;
8678 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
8679 size
+= 2 * DWARF2_ADDR_SIZE
;
8683 /* Count the two zero words used to terminated the address range table. */
8684 size
+= 2 * DWARF2_ADDR_SIZE
;
8688 /* Select the encoding of an attribute value. */
8690 static enum dwarf_form
8691 value_format (dw_attr_node
*a
)
8693 switch (AT_class (a
))
8695 case dw_val_class_addr
:
8696 /* Only very few attributes allow DW_FORM_addr. */
8701 case DW_AT_entry_pc
:
8702 case DW_AT_trampoline
:
8703 return (AT_index (a
) == NOT_INDEXED
8704 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8708 switch (DWARF2_ADDR_SIZE
)
8711 return DW_FORM_data1
;
8713 return DW_FORM_data2
;
8715 return DW_FORM_data4
;
8717 return DW_FORM_data8
;
8721 case dw_val_class_range_list
:
8722 case dw_val_class_loc_list
:
8723 if (dwarf_version
>= 4)
8724 return DW_FORM_sec_offset
;
8726 case dw_val_class_vms_delta
:
8727 case dw_val_class_offset
:
8728 switch (DWARF_OFFSET_SIZE
)
8731 return DW_FORM_data4
;
8733 return DW_FORM_data8
;
8737 case dw_val_class_loc
:
8738 if (dwarf_version
>= 4)
8739 return DW_FORM_exprloc
;
8740 switch (constant_size (size_of_locs (AT_loc (a
))))
8743 return DW_FORM_block1
;
8745 return DW_FORM_block2
;
8747 return DW_FORM_block4
;
8751 case dw_val_class_const
:
8752 return DW_FORM_sdata
;
8753 case dw_val_class_unsigned_const
:
8754 switch (constant_size (AT_unsigned (a
)))
8757 return DW_FORM_data1
;
8759 return DW_FORM_data2
;
8761 /* In DWARF3 DW_AT_data_member_location with
8762 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8763 constant, so we need to use DW_FORM_udata if we need
8764 a large constant. */
8765 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8766 return DW_FORM_udata
;
8767 return DW_FORM_data4
;
8769 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8770 return DW_FORM_udata
;
8771 return DW_FORM_data8
;
8775 case dw_val_class_const_double
:
8776 switch (HOST_BITS_PER_WIDE_INT
)
8779 return DW_FORM_data2
;
8781 return DW_FORM_data4
;
8783 return DW_FORM_data8
;
8786 return DW_FORM_block1
;
8788 case dw_val_class_wide_int
:
8789 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
8792 return DW_FORM_data1
;
8794 return DW_FORM_data2
;
8796 return DW_FORM_data4
;
8798 return DW_FORM_data8
;
8800 return DW_FORM_block1
;
8802 case dw_val_class_vec
:
8803 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
8804 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
8807 return DW_FORM_block1
;
8809 return DW_FORM_block2
;
8811 return DW_FORM_block4
;
8815 case dw_val_class_flag
:
8816 if (dwarf_version
>= 4)
8818 /* Currently all add_AT_flag calls pass in 1 as last argument,
8819 so DW_FORM_flag_present can be used. If that ever changes,
8820 we'll need to use DW_FORM_flag and have some optimization
8821 in build_abbrev_table that will change those to
8822 DW_FORM_flag_present if it is set to 1 in all DIEs using
8823 the same abbrev entry. */
8824 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
8825 return DW_FORM_flag_present
;
8827 return DW_FORM_flag
;
8828 case dw_val_class_die_ref
:
8829 if (AT_ref_external (a
))
8830 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
8833 case dw_val_class_fde_ref
:
8834 return DW_FORM_data
;
8835 case dw_val_class_lbl_id
:
8836 return (AT_index (a
) == NOT_INDEXED
8837 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8838 case dw_val_class_lineptr
:
8839 case dw_val_class_macptr
:
8840 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
8841 case dw_val_class_str
:
8842 return AT_string_form (a
);
8843 case dw_val_class_file
:
8844 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
8847 return DW_FORM_data1
;
8849 return DW_FORM_data2
;
8851 return DW_FORM_data4
;
8856 case dw_val_class_data8
:
8857 return DW_FORM_data8
;
8859 case dw_val_class_high_pc
:
8860 switch (DWARF2_ADDR_SIZE
)
8863 return DW_FORM_data1
;
8865 return DW_FORM_data2
;
8867 return DW_FORM_data4
;
8869 return DW_FORM_data8
;
8874 case dw_val_class_discr_value
:
8875 return (a
->dw_attr_val
.v
.val_discr_value
.pos
8878 case dw_val_class_discr_list
:
8879 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
8882 return DW_FORM_block1
;
8884 return DW_FORM_block2
;
8886 return DW_FORM_block4
;
8896 /* Output the encoding of an attribute value. */
8899 output_value_format (dw_attr_node
*a
)
8901 enum dwarf_form form
= value_format (a
);
8903 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
8906 /* Given a die and id, produce the appropriate abbreviations. */
8909 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
8912 dw_attr_node
*a_attr
;
8914 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
8915 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
8916 dwarf_tag_name (abbrev
->die_tag
));
8918 if (abbrev
->die_child
!= NULL
)
8919 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
8921 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
8923 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
8925 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
8926 dwarf_attr_name (a_attr
->dw_attr
));
8927 output_value_format (a_attr
);
8930 dw2_asm_output_data (1, 0, NULL
);
8931 dw2_asm_output_data (1, 0, NULL
);
8935 /* Output the .debug_abbrev section which defines the DIE abbreviation
8939 output_abbrev_section (void)
8941 unsigned long abbrev_id
;
8943 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
8944 output_die_abbrevs (abbrev_id
, abbrev_die_table
[abbrev_id
]);
8946 /* Terminate the table. */
8947 dw2_asm_output_data (1, 0, NULL
);
8950 /* Output a symbol we can use to refer to this DIE from another CU. */
8953 output_die_symbol (dw_die_ref die
)
8955 const char *sym
= die
->die_id
.die_symbol
;
8957 gcc_assert (!die
->comdat_type_p
);
8962 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
8963 /* We make these global, not weak; if the target doesn't support
8964 .linkonce, it doesn't support combining the sections, so debugging
8966 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
8968 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
8971 /* Return a new location list, given the begin and end range, and the
8974 static inline dw_loc_list_ref
8975 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
8976 const char *section
)
8978 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
8980 retlist
->begin
= begin
;
8981 retlist
->begin_entry
= NULL
;
8983 retlist
->expr
= expr
;
8984 retlist
->section
= section
;
8989 /* Generate a new internal symbol for this location list node, if it
8990 hasn't got one yet. */
8993 gen_llsym (dw_loc_list_ref list
)
8995 gcc_assert (!list
->ll_symbol
);
8996 list
->ll_symbol
= gen_internal_sym ("LLST");
8999 /* Output the location list given to us. */
9002 output_loc_list (dw_loc_list_ref list_head
)
9004 dw_loc_list_ref curr
= list_head
;
9006 if (list_head
->emitted
)
9008 list_head
->emitted
= true;
9010 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
9012 /* Walk the location list, and output each range + expression. */
9013 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
9016 /* Don't output an entry that starts and ends at the same address. */
9017 if (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
)
9019 size
= size_of_locs (curr
->expr
);
9020 /* If the expression is too large, drop it on the floor. We could
9021 perhaps put it into DW_TAG_dwarf_procedure and refer to that
9022 in the expression, but >= 64KB expressions for a single value
9023 in a single range are unlikely very useful. */
9026 if (dwarf_split_debug_info
)
9028 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
9029 "Location list start/length entry (%s)",
9030 list_head
->ll_symbol
);
9031 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
9032 "Location list range start index (%s)",
9034 /* The length field is 4 bytes. If we ever need to support
9035 an 8-byte length, we can add a new DW_LLE code or fall back
9036 to DW_LLE_GNU_start_end_entry. */
9037 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
9038 "Location list range length (%s)",
9039 list_head
->ll_symbol
);
9041 else if (!have_multiple_function_sections
)
9043 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
9044 "Location list begin address (%s)",
9045 list_head
->ll_symbol
);
9046 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
9047 "Location list end address (%s)",
9048 list_head
->ll_symbol
);
9052 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
9053 "Location list begin address (%s)",
9054 list_head
->ll_symbol
);
9055 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
9056 "Location list end address (%s)",
9057 list_head
->ll_symbol
);
9060 /* Output the block length for this list of location operations. */
9061 gcc_assert (size
<= 0xffff);
9062 dw2_asm_output_data (2, size
, "%s", "Location expression size");
9064 output_loc_sequence (curr
->expr
, -1);
9067 if (dwarf_split_debug_info
)
9068 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
9069 "Location list terminator (%s)",
9070 list_head
->ll_symbol
);
9073 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
9074 "Location list terminator begin (%s)",
9075 list_head
->ll_symbol
);
9076 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
9077 "Location list terminator end (%s)",
9078 list_head
->ll_symbol
);
9082 /* Output a range_list offset into the debug_range section. Emit a
9083 relocated reference if val_entry is NULL, otherwise, emit an
9084 indirect reference. */
9087 output_range_list_offset (dw_attr_node
*a
)
9089 const char *name
= dwarf_attr_name (a
->dw_attr
);
9091 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
9093 char *p
= strchr (ranges_section_label
, '\0');
9094 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
, a
->dw_attr_val
.v
.val_offset
);
9095 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
9096 debug_ranges_section
, "%s", name
);
9100 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
9101 "%s (offset from %s)", name
, ranges_section_label
);
9104 /* Output the offset into the debug_loc section. */
9107 output_loc_list_offset (dw_attr_node
*a
)
9109 char *sym
= AT_loc_list (a
)->ll_symbol
;
9112 if (dwarf_split_debug_info
)
9113 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
9114 "%s", dwarf_attr_name (a
->dw_attr
));
9116 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
9117 "%s", dwarf_attr_name (a
->dw_attr
));
9120 /* Output an attribute's index or value appropriately. */
9123 output_attr_index_or_value (dw_attr_node
*a
)
9125 const char *name
= dwarf_attr_name (a
->dw_attr
);
9127 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9129 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
9132 switch (AT_class (a
))
9134 case dw_val_class_addr
:
9135 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
9137 case dw_val_class_high_pc
:
9138 case dw_val_class_lbl_id
:
9139 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
9141 case dw_val_class_loc_list
:
9142 output_loc_list_offset (a
);
9149 /* Output a type signature. */
9152 output_signature (const char *sig
, const char *name
)
9156 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9157 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
9160 /* Output a discriminant value. */
9163 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
9165 if (discr_value
->pos
)
9166 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
9168 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
9171 /* Output the DIE and its attributes. Called recursively to generate
9172 the definitions of each child DIE. */
9175 output_die (dw_die_ref die
)
9182 /* If someone in another CU might refer to us, set up a symbol for
9183 them to point to. */
9184 if (! die
->comdat_type_p
&& die
->die_id
.die_symbol
)
9185 output_die_symbol (die
);
9187 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
9188 (unsigned long)die
->die_offset
,
9189 dwarf_tag_name (die
->die_tag
));
9191 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9193 const char *name
= dwarf_attr_name (a
->dw_attr
);
9195 switch (AT_class (a
))
9197 case dw_val_class_addr
:
9198 output_attr_index_or_value (a
);
9201 case dw_val_class_offset
:
9202 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
9206 case dw_val_class_range_list
:
9207 output_range_list_offset (a
);
9210 case dw_val_class_loc
:
9211 size
= size_of_locs (AT_loc (a
));
9213 /* Output the block length for this list of location operations. */
9214 if (dwarf_version
>= 4)
9215 dw2_asm_output_data_uleb128 (size
, "%s", name
);
9217 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
9219 output_loc_sequence (AT_loc (a
), -1);
9222 case dw_val_class_const
:
9223 /* ??? It would be slightly more efficient to use a scheme like is
9224 used for unsigned constants below, but gdb 4.x does not sign
9225 extend. Gdb 5.x does sign extend. */
9226 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
9229 case dw_val_class_unsigned_const
:
9231 int csize
= constant_size (AT_unsigned (a
));
9232 if (dwarf_version
== 3
9233 && a
->dw_attr
== DW_AT_data_member_location
9235 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
9237 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
9241 case dw_val_class_const_double
:
9243 unsigned HOST_WIDE_INT first
, second
;
9245 if (HOST_BITS_PER_WIDE_INT
>= 64)
9246 dw2_asm_output_data (1,
9247 HOST_BITS_PER_DOUBLE_INT
9248 / HOST_BITS_PER_CHAR
,
9251 if (WORDS_BIG_ENDIAN
)
9253 first
= a
->dw_attr_val
.v
.val_double
.high
;
9254 second
= a
->dw_attr_val
.v
.val_double
.low
;
9258 first
= a
->dw_attr_val
.v
.val_double
.low
;
9259 second
= a
->dw_attr_val
.v
.val_double
.high
;
9262 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
9264 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
9269 case dw_val_class_wide_int
:
9272 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
9273 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
9274 if (len
* HOST_BITS_PER_WIDE_INT
> 64)
9275 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
) * l
,
9278 if (WORDS_BIG_ENDIAN
)
9279 for (i
= len
- 1; i
>= 0; --i
)
9281 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
9286 for (i
= 0; i
< len
; ++i
)
9288 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
9295 case dw_val_class_vec
:
9297 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
9298 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
9302 dw2_asm_output_data (constant_size (len
* elt_size
),
9303 len
* elt_size
, "%s", name
);
9304 if (elt_size
> sizeof (HOST_WIDE_INT
))
9309 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
9312 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
9313 "fp or vector constant word %u", i
);
9317 case dw_val_class_flag
:
9318 if (dwarf_version
>= 4)
9320 /* Currently all add_AT_flag calls pass in 1 as last argument,
9321 so DW_FORM_flag_present can be used. If that ever changes,
9322 we'll need to use DW_FORM_flag and have some optimization
9323 in build_abbrev_table that will change those to
9324 DW_FORM_flag_present if it is set to 1 in all DIEs using
9325 the same abbrev entry. */
9326 gcc_assert (AT_flag (a
) == 1);
9328 fprintf (asm_out_file
, "\t\t\t%s %s\n",
9329 ASM_COMMENT_START
, name
);
9332 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
9335 case dw_val_class_loc_list
:
9336 output_attr_index_or_value (a
);
9339 case dw_val_class_die_ref
:
9340 if (AT_ref_external (a
))
9342 if (AT_ref (a
)->comdat_type_p
)
9344 comdat_type_node
*type_node
=
9345 AT_ref (a
)->die_id
.die_type_node
;
9347 gcc_assert (type_node
);
9348 output_signature (type_node
->signature
, name
);
9352 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
9356 /* In DWARF2, DW_FORM_ref_addr is sized by target address
9357 length, whereas in DWARF3 it's always sized as an
9359 if (dwarf_version
== 2)
9360 size
= DWARF2_ADDR_SIZE
;
9362 size
= DWARF_OFFSET_SIZE
;
9363 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
9369 gcc_assert (AT_ref (a
)->die_offset
);
9370 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
9375 case dw_val_class_fde_ref
:
9379 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
9380 a
->dw_attr_val
.v
.val_fde_index
* 2);
9381 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
9386 case dw_val_class_vms_delta
:
9387 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
9388 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
9389 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
9392 dw2_asm_output_delta (DWARF_OFFSET_SIZE
,
9393 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
9398 case dw_val_class_lbl_id
:
9399 output_attr_index_or_value (a
);
9402 case dw_val_class_lineptr
:
9403 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
9404 debug_line_section
, "%s", name
);
9407 case dw_val_class_macptr
:
9408 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
9409 debug_macinfo_section
, "%s", name
);
9412 case dw_val_class_str
:
9413 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
9414 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
9415 a
->dw_attr_val
.v
.val_str
->label
,
9417 "%s: \"%s\"", name
, AT_string (a
));
9418 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_GNU_str_index
)
9419 dw2_asm_output_data_uleb128 (AT_index (a
),
9420 "%s: \"%s\"", name
, AT_string (a
));
9422 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
9425 case dw_val_class_file
:
9427 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
9429 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
9430 a
->dw_attr_val
.v
.val_file
->filename
);
9434 case dw_val_class_data8
:
9438 for (i
= 0; i
< 8; i
++)
9439 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
9440 i
== 0 ? "%s" : NULL
, name
);
9444 case dw_val_class_high_pc
:
9445 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
9446 get_AT_low_pc (die
), "DW_AT_high_pc");
9449 case dw_val_class_discr_value
:
9450 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
9453 case dw_val_class_discr_list
:
9455 dw_discr_list_ref list
= AT_discr_list (a
);
9456 const int size
= size_of_discr_list (list
);
9458 /* This is a block, so output its length first. */
9459 dw2_asm_output_data (constant_size (size
), size
,
9460 "%s: block size", name
);
9462 for (; list
!= NULL
; list
= list
->dw_discr_next
)
9464 /* One byte for the discriminant value descriptor, and then as
9465 many LEB128 numbers as required. */
9466 if (list
->dw_discr_range
)
9467 dw2_asm_output_data (1, DW_DSC_range
,
9468 "%s: DW_DSC_range", name
);
9470 dw2_asm_output_data (1, DW_DSC_label
,
9471 "%s: DW_DSC_label", name
);
9473 output_discr_value (&list
->dw_discr_lower_bound
, name
);
9474 if (list
->dw_discr_range
)
9475 output_discr_value (&list
->dw_discr_upper_bound
, name
);
9485 FOR_EACH_CHILD (die
, c
, output_die (c
));
9487 /* Add null byte to terminate sibling list. */
9488 if (die
->die_child
!= NULL
)
9489 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
9490 (unsigned long) die
->die_offset
);
9493 /* Output the compilation unit that appears at the beginning of the
9494 .debug_info section, and precedes the DIE descriptions. */
9497 output_compilation_unit_header (void)
9499 /* We don't support actual DWARFv5 units yet, we just use some
9500 DWARFv5 draft DIE tags in DWARFv4 format. */
9501 int ver
= dwarf_version
< 5 ? dwarf_version
: 4;
9503 if (!XCOFF_DEBUGGING_INFO
)
9505 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9506 dw2_asm_output_data (4, 0xffffffff,
9507 "Initial length escape value indicating 64-bit DWARF extension");
9508 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9509 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
9510 "Length of Compilation Unit Info");
9513 dw2_asm_output_data (2, ver
, "DWARF version number");
9514 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
9515 debug_abbrev_section
,
9516 "Offset Into Abbrev. Section");
9517 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
9520 /* Output the compilation unit DIE and its children. */
9523 output_comp_unit (dw_die_ref die
, int output_if_empty
)
9525 const char *secname
, *oldsym
;
9528 /* Unless we are outputting main CU, we may throw away empty ones. */
9529 if (!output_if_empty
&& die
->die_child
== NULL
)
9532 /* Even if there are no children of this DIE, we must output the information
9533 about the compilation unit. Otherwise, on an empty translation unit, we
9534 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
9535 will then complain when examining the file. First mark all the DIEs in
9536 this CU so we know which get local refs. */
9539 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
9541 build_abbrev_table (die
, extern_map
);
9545 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9546 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
9547 calc_die_sizes (die
);
9549 oldsym
= die
->die_id
.die_symbol
;
9552 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
9554 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
9556 die
->die_id
.die_symbol
= NULL
;
9557 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
9561 switch_to_section (debug_info_section
);
9562 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
9563 info_section_emitted
= true;
9566 /* Output debugging information. */
9567 output_compilation_unit_header ();
9570 /* Leave the marks on the main CU, so we can check them in
9575 die
->die_id
.die_symbol
= oldsym
;
9579 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
9580 and .debug_pubtypes. This is configured per-target, but can be
9581 overridden by the -gpubnames or -gno-pubnames options. */
9584 want_pubnames (void)
9586 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9588 if (debug_generate_pub_sections
!= -1)
9589 return debug_generate_pub_sections
;
9590 return targetm
.want_debug_pub_sections
;
9593 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
9596 add_AT_pubnames (dw_die_ref die
)
9598 if (want_pubnames ())
9599 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
9602 /* Add a string attribute value to a skeleton DIE. */
9605 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
9609 struct indirect_string_node
*node
;
9611 if (! skeleton_debug_str_hash
)
9612 skeleton_debug_str_hash
9613 = hash_table
<indirect_string_hasher
>::create_ggc (10);
9615 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
9616 find_string_form (node
);
9617 if (node
->form
== DW_FORM_GNU_str_index
)
9618 node
->form
= DW_FORM_strp
;
9620 attr
.dw_attr
= attr_kind
;
9621 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
9622 attr
.dw_attr_val
.val_entry
= NULL
;
9623 attr
.dw_attr_val
.v
.val_str
= node
;
9624 add_dwarf_attr (die
, &attr
);
9627 /* Helper function to generate top-level dies for skeleton debug_info and
9631 add_top_level_skeleton_die_attrs (dw_die_ref die
)
9633 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
9634 const char *comp_dir
= comp_dir_string ();
9636 add_skeleton_AT_string (die
, DW_AT_GNU_dwo_name
, dwo_file_name
);
9637 if (comp_dir
!= NULL
)
9638 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
9639 add_AT_pubnames (die
);
9640 add_AT_lineptr (die
, DW_AT_GNU_addr_base
, debug_addr_section_label
);
9643 /* Output skeleton debug sections that point to the dwo file. */
9646 output_skeleton_debug_sections (dw_die_ref comp_unit
)
9648 /* We don't support actual DWARFv5 units yet, we just use some
9649 DWARFv5 draft DIE tags in DWARFv4 format. */
9650 int ver
= dwarf_version
< 5 ? dwarf_version
: 4;
9652 /* These attributes will be found in the full debug_info section. */
9653 remove_AT (comp_unit
, DW_AT_producer
);
9654 remove_AT (comp_unit
, DW_AT_language
);
9656 switch_to_section (debug_skeleton_info_section
);
9657 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
9659 /* Produce the skeleton compilation-unit header. This one differs enough from
9660 a normal CU header that it's better not to call output_compilation_unit
9662 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9663 dw2_asm_output_data (4, 0xffffffff,
9664 "Initial length escape value indicating 64-bit DWARF extension");
9666 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9667 DWARF_COMPILE_UNIT_HEADER_SIZE
9668 - DWARF_INITIAL_LENGTH_SIZE
9669 + size_of_die (comp_unit
),
9670 "Length of Compilation Unit Info");
9671 dw2_asm_output_data (2, ver
, "DWARF version number");
9672 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
9673 debug_abbrev_section
,
9674 "Offset Into Abbrev. Section");
9675 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
9677 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
9678 output_die (comp_unit
);
9680 /* Build the skeleton debug_abbrev section. */
9681 switch_to_section (debug_skeleton_abbrev_section
);
9682 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
9684 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
9686 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
9689 /* Output a comdat type unit DIE and its children. */
9692 output_comdat_type_unit (comdat_type_node
*node
)
9694 const char *secname
;
9697 #if defined (OBJECT_FORMAT_ELF)
9701 /* First mark all the DIEs in this CU so we know which get local refs. */
9702 mark_dies (node
->root_die
);
9704 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
9706 build_abbrev_table (node
->root_die
, extern_map
);
9711 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9712 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
9713 calc_die_sizes (node
->root_die
);
9715 #if defined (OBJECT_FORMAT_ELF)
9716 if (!dwarf_split_debug_info
)
9717 secname
= ".debug_types";
9719 secname
= ".debug_types.dwo";
9721 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9722 sprintf (tmp
, "wt.");
9723 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9724 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9725 comdat_key
= get_identifier (tmp
);
9726 targetm
.asm_out
.named_section (secname
,
9727 SECTION_DEBUG
| SECTION_LINKONCE
,
9730 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9731 sprintf (tmp
, ".gnu.linkonce.wt.");
9732 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9733 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9735 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
9738 /* Output debugging information. */
9739 output_compilation_unit_header ();
9740 output_signature (node
->signature
, "Type Signature");
9741 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
9742 "Offset to Type DIE");
9743 output_die (node
->root_die
);
9745 unmark_dies (node
->root_die
);
9748 /* Return the DWARF2/3 pubname associated with a decl. */
9751 dwarf2_name (tree decl
, int scope
)
9753 if (DECL_NAMELESS (decl
))
9755 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
9758 /* Add a new entry to .debug_pubnames if appropriate. */
9761 add_pubname_string (const char *str
, dw_die_ref die
)
9766 e
.name
= xstrdup (str
);
9767 vec_safe_push (pubname_table
, e
);
9771 add_pubname (tree decl
, dw_die_ref die
)
9773 if (!want_pubnames ())
9776 /* Don't add items to the table when we expect that the consumer will have
9777 just read the enclosing die. For example, if the consumer is looking at a
9778 class_member, it will either be inside the class already, or will have just
9779 looked up the class to find the member. Either way, searching the class is
9780 faster than searching the index. */
9781 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
9782 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9784 const char *name
= dwarf2_name (decl
, 1);
9787 add_pubname_string (name
, die
);
9791 /* Add an enumerator to the pubnames section. */
9794 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
9798 gcc_assert (scope_name
);
9799 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
9801 vec_safe_push (pubname_table
, e
);
9804 /* Add a new entry to .debug_pubtypes if appropriate. */
9807 add_pubtype (tree decl
, dw_die_ref die
)
9811 if (!want_pubnames ())
9814 if ((TREE_PUBLIC (decl
)
9815 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9816 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
9819 const char *scope_name
= "";
9820 const char *sep
= is_cxx () ? "::" : ".";
9823 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
9824 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
9826 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
9827 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
9828 scope_name
= concat (scope_name
, sep
, NULL
);
9834 name
= type_tag (decl
);
9836 name
= lang_hooks
.dwarf_name (decl
, 1);
9838 /* If we don't have a name for the type, there's no point in adding
9840 if (name
!= NULL
&& name
[0] != '\0')
9843 e
.name
= concat (scope_name
, name
, NULL
);
9844 vec_safe_push (pubtype_table
, e
);
9847 /* Although it might be more consistent to add the pubinfo for the
9848 enumerators as their dies are created, they should only be added if the
9849 enum type meets the criteria above. So rather than re-check the parent
9850 enum type whenever an enumerator die is created, just output them all
9851 here. This isn't protected by the name conditional because anonymous
9852 enums don't have names. */
9853 if (die
->die_tag
== DW_TAG_enumeration_type
)
9857 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
9862 /* Output a single entry in the pubnames table. */
9865 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
9867 dw_die_ref die
= entry
->die
;
9868 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
9870 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
9872 if (debug_generate_pub_sections
== 2)
9874 /* This logic follows gdb's method for determining the value of the flag
9876 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
9877 switch (die
->die_tag
)
9879 case DW_TAG_typedef
:
9880 case DW_TAG_base_type
:
9881 case DW_TAG_subrange_type
:
9882 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9883 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9885 case DW_TAG_enumerator
:
9886 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9887 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9888 if (!is_cxx () && !is_java ())
9889 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9891 case DW_TAG_subprogram
:
9892 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9893 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
9895 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9897 case DW_TAG_constant
:
9898 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9899 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9900 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9902 case DW_TAG_variable
:
9903 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9904 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9905 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9907 case DW_TAG_namespace
:
9908 case DW_TAG_imported_declaration
:
9909 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9911 case DW_TAG_class_type
:
9912 case DW_TAG_interface_type
:
9913 case DW_TAG_structure_type
:
9914 case DW_TAG_union_type
:
9915 case DW_TAG_enumeration_type
:
9916 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9917 if (!is_cxx () && !is_java ())
9918 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9921 /* An unusual tag. Leave the flag-byte empty. */
9924 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
9928 dw2_asm_output_nstring (entry
->name
, -1, "external name");
9932 /* Output the public names table used to speed up access to externally
9933 visible names; or the public types table used to find type definitions. */
9936 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9939 unsigned long pubnames_length
= size_of_pubnames (names
);
9942 if (!XCOFF_DEBUGGING_INFO
)
9944 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9945 dw2_asm_output_data (4, 0xffffffff,
9946 "Initial length escape value indicating 64-bit DWARF extension");
9947 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
9951 /* Version number for pubnames/pubtypes is independent of dwarf version. */
9952 dw2_asm_output_data (2, 2, "DWARF Version");
9954 if (dwarf_split_debug_info
)
9955 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9956 debug_skeleton_info_section
,
9957 "Offset of Compilation Unit Info");
9959 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9961 "Offset of Compilation Unit Info");
9962 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
9963 "Compilation Unit Length");
9965 FOR_EACH_VEC_ELT (*names
, i
, pub
)
9967 if (include_pubname_in_output (names
, pub
))
9969 dw_offset die_offset
= pub
->die
->die_offset
;
9971 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9972 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
9973 gcc_assert (pub
->die
->die_mark
);
9975 /* If we're putting types in their own .debug_types sections,
9976 the .debug_pubtypes table will still point to the compile
9977 unit (not the type unit), so we want to use the offset of
9978 the skeleton DIE (if there is one). */
9979 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
9981 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
9983 if (type_node
!= NULL
)
9984 die_offset
= (type_node
->skeleton_die
!= NULL
9985 ? type_node
->skeleton_die
->die_offset
9986 : comp_unit_die ()->die_offset
);
9989 output_pubname (die_offset
, pub
);
9993 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
9996 /* Output public names and types tables if necessary. */
9999 output_pubtables (void)
10001 if (!want_pubnames () || !info_section_emitted
)
10004 switch_to_section (debug_pubnames_section
);
10005 output_pubnames (pubname_table
);
10006 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
10007 It shouldn't hurt to emit it always, since pure DWARF2 consumers
10008 simply won't look for the section. */
10009 switch_to_section (debug_pubtypes_section
);
10010 output_pubnames (pubtype_table
);
10014 /* Output the information that goes into the .debug_aranges table.
10015 Namely, define the beginning and ending address range of the
10016 text section generated for this compilation unit. */
10019 output_aranges (void)
10022 unsigned long aranges_length
= size_of_aranges ();
10024 if (!XCOFF_DEBUGGING_INFO
)
10026 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10027 dw2_asm_output_data (4, 0xffffffff,
10028 "Initial length escape value indicating 64-bit DWARF extension");
10029 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
10030 "Length of Address Ranges Info");
10033 /* Version number for aranges is still 2, even up to DWARF5. */
10034 dw2_asm_output_data (2, 2, "DWARF Version");
10035 if (dwarf_split_debug_info
)
10036 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
10037 debug_skeleton_info_section
,
10038 "Offset of Compilation Unit Info");
10040 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
10041 debug_info_section
,
10042 "Offset of Compilation Unit Info");
10043 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
10044 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
10046 /* We need to align to twice the pointer size here. */
10047 if (DWARF_ARANGES_PAD_SIZE
)
10049 /* Pad using a 2 byte words so that padding is correct for any
10051 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
10052 2 * DWARF2_ADDR_SIZE
);
10053 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
10054 dw2_asm_output_data (2, 0, NULL
);
10057 /* It is necessary not to output these entries if the sections were
10058 not used; if the sections were not used, the length will be 0 and
10059 the address may end up as 0 if the section is discarded by ld
10060 --gc-sections, leaving an invalid (0, 0) entry that can be
10061 confused with the terminator. */
10062 if (text_section_used
)
10064 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
10065 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
10066 text_section_label
, "Length");
10068 if (cold_text_section_used
)
10070 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
10072 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
10073 cold_text_section_label
, "Length");
10076 if (have_multiple_function_sections
)
10081 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
10083 if (DECL_IGNORED_P (fde
->decl
))
10085 if (!fde
->in_std_section
)
10087 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
10089 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
10090 fde
->dw_fde_begin
, "Length");
10092 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
10094 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
10096 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
10097 fde
->dw_fde_second_begin
, "Length");
10102 /* Output the terminator words. */
10103 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
10104 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
10107 /* Add a new entry to .debug_ranges. Return the offset at which it
10110 static unsigned int
10111 add_ranges_num (int num
)
10113 unsigned int in_use
= ranges_table_in_use
;
10115 if (in_use
== ranges_table_allocated
)
10117 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
10118 ranges_table
= GGC_RESIZEVEC (dw_ranges
, ranges_table
,
10119 ranges_table_allocated
);
10120 memset (ranges_table
+ ranges_table_in_use
, 0,
10121 RANGES_TABLE_INCREMENT
* sizeof (dw_ranges
));
10124 ranges_table
[in_use
].num
= num
;
10125 ranges_table_in_use
= in_use
+ 1;
10127 return in_use
* 2 * DWARF2_ADDR_SIZE
;
10130 /* Add a new entry to .debug_ranges corresponding to a block, or a
10131 range terminator if BLOCK is NULL. */
10133 static unsigned int
10134 add_ranges (const_tree block
)
10136 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0);
10139 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
10140 When using dwarf_split_debug_info, address attributes in dies destined
10141 for the final executable should be direct references--setting the
10142 parameter force_direct ensures this behavior. */
10145 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
10146 bool *added
, bool force_direct
)
10148 unsigned int in_use
= ranges_by_label_in_use
;
10149 unsigned int offset
;
10151 if (in_use
== ranges_by_label_allocated
)
10153 ranges_by_label_allocated
+= RANGES_TABLE_INCREMENT
;
10154 ranges_by_label
= GGC_RESIZEVEC (dw_ranges_by_label
, ranges_by_label
,
10155 ranges_by_label_allocated
);
10156 memset (ranges_by_label
+ ranges_by_label_in_use
, 0,
10157 RANGES_TABLE_INCREMENT
* sizeof (dw_ranges_by_label
));
10160 ranges_by_label
[in_use
].begin
= begin
;
10161 ranges_by_label
[in_use
].end
= end
;
10162 ranges_by_label_in_use
= in_use
+ 1;
10164 offset
= add_ranges_num (-(int)in_use
- 1);
10167 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
10173 output_ranges (void)
10176 static const char *const start_fmt
= "Offset %#x";
10177 const char *fmt
= start_fmt
;
10179 for (i
= 0; i
< ranges_table_in_use
; i
++)
10181 int block_num
= ranges_table
[i
].num
;
10185 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
10186 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
10188 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
10189 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
10191 /* If all code is in the text section, then the compilation
10192 unit base address defaults to DW_AT_low_pc, which is the
10193 base of the text section. */
10194 if (!have_multiple_function_sections
)
10196 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
10197 text_section_label
,
10198 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
10199 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
10200 text_section_label
, NULL
);
10203 /* Otherwise, the compilation unit base address is zero,
10204 which allows us to use absolute addresses, and not worry
10205 about whether the target supports cross-section
10209 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
10210 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
10211 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
10217 /* Negative block_num stands for an index into ranges_by_label. */
10218 else if (block_num
< 0)
10220 int lab_idx
= - block_num
- 1;
10222 if (!have_multiple_function_sections
)
10224 gcc_unreachable ();
10226 /* If we ever use add_ranges_by_labels () for a single
10227 function section, all we have to do is to take out
10228 the #if 0 above. */
10229 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
10230 ranges_by_label
[lab_idx
].begin
,
10231 text_section_label
,
10232 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
10233 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
10234 ranges_by_label
[lab_idx
].end
,
10235 text_section_label
, NULL
);
10240 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
10241 ranges_by_label
[lab_idx
].begin
,
10242 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
10243 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
10244 ranges_by_label
[lab_idx
].end
,
10250 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
10251 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
10257 /* Data structure containing information about input files. */
10260 const char *path
; /* Complete file name. */
10261 const char *fname
; /* File name part. */
10262 int length
; /* Length of entire string. */
10263 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
10264 int dir_idx
; /* Index in directory table. */
10267 /* Data structure containing information about directories with source
10271 const char *path
; /* Path including directory name. */
10272 int length
; /* Path length. */
10273 int prefix
; /* Index of directory entry which is a prefix. */
10274 int count
; /* Number of files in this directory. */
10275 int dir_idx
; /* Index of directory used as base. */
10278 /* Callback function for file_info comparison. We sort by looking at
10279 the directories in the path. */
10282 file_info_cmp (const void *p1
, const void *p2
)
10284 const struct file_info
*const s1
= (const struct file_info
*) p1
;
10285 const struct file_info
*const s2
= (const struct file_info
*) p2
;
10286 const unsigned char *cp1
;
10287 const unsigned char *cp2
;
10289 /* Take care of file names without directories. We need to make sure that
10290 we return consistent values to qsort since some will get confused if
10291 we return the same value when identical operands are passed in opposite
10292 orders. So if neither has a directory, return 0 and otherwise return
10293 1 or -1 depending on which one has the directory. */
10294 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
10295 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
10297 cp1
= (const unsigned char *) s1
->path
;
10298 cp2
= (const unsigned char *) s2
->path
;
10304 /* Reached the end of the first path? If so, handle like above. */
10305 if ((cp1
== (const unsigned char *) s1
->fname
)
10306 || (cp2
== (const unsigned char *) s2
->fname
))
10307 return ((cp2
== (const unsigned char *) s2
->fname
)
10308 - (cp1
== (const unsigned char *) s1
->fname
));
10310 /* Character of current path component the same? */
10311 else if (*cp1
!= *cp2
)
10312 return *cp1
- *cp2
;
10316 struct file_name_acquire_data
10318 struct file_info
*files
;
10323 /* Traversal function for the hash table. */
10326 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
10328 struct dwarf_file_data
*d
= *slot
;
10329 struct file_info
*fi
;
10332 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
10334 if (! d
->emitted_number
)
10337 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
10339 fi
= fnad
->files
+ fnad
->used_files
++;
10341 /* Skip all leading "./". */
10343 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
10346 /* Create a new array entry. */
10348 fi
->length
= strlen (f
);
10351 /* Search for the file name part. */
10352 f
= strrchr (f
, DIR_SEPARATOR
);
10353 #if defined (DIR_SEPARATOR_2)
10355 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
10359 if (f
== NULL
|| f
< g
)
10365 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
10369 /* Output the directory table and the file name table. We try to minimize
10370 the total amount of memory needed. A heuristic is used to avoid large
10371 slowdowns with many input files. */
10374 output_file_names (void)
10376 struct file_name_acquire_data fnad
;
10378 struct file_info
*files
;
10379 struct dir_info
*dirs
;
10387 if (!last_emitted_file
)
10389 dw2_asm_output_data (1, 0, "End directory table");
10390 dw2_asm_output_data (1, 0, "End file name table");
10394 numfiles
= last_emitted_file
->emitted_number
;
10396 /* Allocate the various arrays we need. */
10397 files
= XALLOCAVEC (struct file_info
, numfiles
);
10398 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
10400 fnad
.files
= files
;
10401 fnad
.used_files
= 0;
10402 fnad
.max_files
= numfiles
;
10403 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
10404 gcc_assert (fnad
.used_files
== fnad
.max_files
);
10406 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
10408 /* Find all the different directories used. */
10409 dirs
[0].path
= files
[0].path
;
10410 dirs
[0].length
= files
[0].fname
- files
[0].path
;
10411 dirs
[0].prefix
= -1;
10413 dirs
[0].dir_idx
= 0;
10414 files
[0].dir_idx
= 0;
10417 for (i
= 1; i
< numfiles
; i
++)
10418 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
10419 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
10420 dirs
[ndirs
- 1].length
) == 0)
10422 /* Same directory as last entry. */
10423 files
[i
].dir_idx
= ndirs
- 1;
10424 ++dirs
[ndirs
- 1].count
;
10430 /* This is a new directory. */
10431 dirs
[ndirs
].path
= files
[i
].path
;
10432 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
10433 dirs
[ndirs
].count
= 1;
10434 dirs
[ndirs
].dir_idx
= ndirs
;
10435 files
[i
].dir_idx
= ndirs
;
10437 /* Search for a prefix. */
10438 dirs
[ndirs
].prefix
= -1;
10439 for (j
= 0; j
< ndirs
; j
++)
10440 if (dirs
[j
].length
< dirs
[ndirs
].length
10441 && dirs
[j
].length
> 1
10442 && (dirs
[ndirs
].prefix
== -1
10443 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
10444 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
10445 dirs
[ndirs
].prefix
= j
;
10450 /* Now to the actual work. We have to find a subset of the directories which
10451 allow expressing the file name using references to the directory table
10452 with the least amount of characters. We do not do an exhaustive search
10453 where we would have to check out every combination of every single
10454 possible prefix. Instead we use a heuristic which provides nearly optimal
10455 results in most cases and never is much off. */
10456 saved
= XALLOCAVEC (int, ndirs
);
10457 savehere
= XALLOCAVEC (int, ndirs
);
10459 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
10460 for (i
= 0; i
< ndirs
; i
++)
10465 /* We can always save some space for the current directory. But this
10466 does not mean it will be enough to justify adding the directory. */
10467 savehere
[i
] = dirs
[i
].length
;
10468 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
10470 for (j
= i
+ 1; j
< ndirs
; j
++)
10473 if (saved
[j
] < dirs
[i
].length
)
10475 /* Determine whether the dirs[i] path is a prefix of the
10479 k
= dirs
[j
].prefix
;
10480 while (k
!= -1 && k
!= (int) i
)
10481 k
= dirs
[k
].prefix
;
10485 /* Yes it is. We can possibly save some memory by
10486 writing the filenames in dirs[j] relative to
10488 savehere
[j
] = dirs
[i
].length
;
10489 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
10494 /* Check whether we can save enough to justify adding the dirs[i]
10496 if (total
> dirs
[i
].length
+ 1)
10498 /* It's worthwhile adding. */
10499 for (j
= i
; j
< ndirs
; j
++)
10500 if (savehere
[j
] > 0)
10502 /* Remember how much we saved for this directory so far. */
10503 saved
[j
] = savehere
[j
];
10505 /* Remember the prefix directory. */
10506 dirs
[j
].dir_idx
= i
;
10511 /* Emit the directory name table. */
10512 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
10513 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
10514 dw2_asm_output_nstring (dirs
[i
].path
,
10516 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
10517 "Directory Entry: %#x", i
+ idx_offset
);
10519 dw2_asm_output_data (1, 0, "End directory table");
10521 /* We have to emit them in the order of emitted_number since that's
10522 used in the debug info generation. To do this efficiently we
10523 generate a back-mapping of the indices first. */
10524 backmap
= XALLOCAVEC (int, numfiles
);
10525 for (i
= 0; i
< numfiles
; i
++)
10526 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
10528 /* Now write all the file names. */
10529 for (i
= 0; i
< numfiles
; i
++)
10531 int file_idx
= backmap
[i
];
10532 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
10534 #ifdef VMS_DEBUGGING_INFO
10535 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
10537 /* Setting these fields can lead to debugger miscomparisons,
10538 but VMS Debug requires them to be set correctly. */
10543 int maxfilelen
= strlen (files
[file_idx
].path
)
10544 + dirs
[dir_idx
].length
10545 + MAX_VMS_VERSION_LEN
+ 1;
10546 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
10548 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
10549 snprintf (filebuf
, maxfilelen
, "%s;%d",
10550 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
10552 dw2_asm_output_nstring
10553 (filebuf
, -1, "File Entry: %#x", (unsigned) i
+ 1);
10555 /* Include directory index. */
10556 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
10558 /* Modification time. */
10559 dw2_asm_output_data_uleb128
10560 ((vms_file_stats_name (files
[file_idx
].path
, &cdt
, 0, 0, 0) == 0)
10564 /* File length in bytes. */
10565 dw2_asm_output_data_uleb128
10566 ((vms_file_stats_name (files
[file_idx
].path
, 0, &siz
, 0, 0) == 0)
10570 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
10571 "File Entry: %#x", (unsigned) i
+ 1);
10573 /* Include directory index. */
10574 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
10576 /* Modification time. */
10577 dw2_asm_output_data_uleb128 (0, NULL
);
10579 /* File length in bytes. */
10580 dw2_asm_output_data_uleb128 (0, NULL
);
10581 #endif /* VMS_DEBUGGING_INFO */
10584 dw2_asm_output_data (1, 0, "End file name table");
10588 /* Output one line number table into the .debug_line section. */
10591 output_one_line_info_table (dw_line_info_table
*table
)
10593 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10594 unsigned int current_line
= 1;
10595 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
10596 dw_line_info_entry
*ent
;
10599 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
10601 switch (ent
->opcode
)
10603 case LI_set_address
:
10604 /* ??? Unfortunately, we have little choice here currently, and
10605 must always use the most general form. GCC does not know the
10606 address delta itself, so we can't use DW_LNS_advance_pc. Many
10607 ports do have length attributes which will give an upper bound
10608 on the address range. We could perhaps use length attributes
10609 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
10610 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
10612 /* This can handle any delta. This takes
10613 4+DWARF2_ADDR_SIZE bytes. */
10614 dw2_asm_output_data (1, 0, "set address %s", line_label
);
10615 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10616 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10617 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
10621 if (ent
->val
== current_line
)
10623 /* We still need to start a new row, so output a copy insn. */
10624 dw2_asm_output_data (1, DW_LNS_copy
,
10625 "copy line %u", current_line
);
10629 int line_offset
= ent
->val
- current_line
;
10630 int line_delta
= line_offset
- DWARF_LINE_BASE
;
10632 current_line
= ent
->val
;
10633 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
10635 /* This can handle deltas from -10 to 234, using the current
10636 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
10637 This takes 1 byte. */
10638 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
10639 "line %u", current_line
);
10643 /* This can handle any delta. This takes at least 4 bytes,
10644 depending on the value being encoded. */
10645 dw2_asm_output_data (1, DW_LNS_advance_line
,
10646 "advance to line %u", current_line
);
10647 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
10648 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
10654 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
10655 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
10658 case LI_set_column
:
10659 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
10660 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
10663 case LI_negate_stmt
:
10664 current_is_stmt
= !current_is_stmt
;
10665 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
10666 "is_stmt %d", current_is_stmt
);
10669 case LI_set_prologue_end
:
10670 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
10671 "set prologue end");
10674 case LI_set_epilogue_begin
:
10675 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
10676 "set epilogue begin");
10679 case LI_set_discriminator
:
10680 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
10681 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
10682 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
10683 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
10688 /* Emit debug info for the address of the end of the table. */
10689 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
10690 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10691 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10692 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
10694 dw2_asm_output_data (1, 0, "end sequence");
10695 dw2_asm_output_data_uleb128 (1, NULL
);
10696 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
10699 /* Output the source line number correspondence information. This
10700 information goes into the .debug_line section. */
10703 output_line_info (bool prologue_only
)
10705 char l1
[20], l2
[20], p1
[20], p2
[20];
10706 /* We don't support DWARFv5 line tables yet. */
10707 int ver
= dwarf_version
< 5 ? dwarf_version
: 4;
10708 bool saw_one
= false;
10711 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
10712 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
10713 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
10714 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
10716 if (!XCOFF_DEBUGGING_INFO
)
10718 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10719 dw2_asm_output_data (4, 0xffffffff,
10720 "Initial length escape value indicating 64-bit DWARF extension");
10721 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
10722 "Length of Source Line Info");
10725 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
10727 dw2_asm_output_data (2, ver
, "DWARF Version");
10728 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
10729 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
10731 /* Define the architecture-dependent minimum instruction length (in bytes).
10732 In this implementation of DWARF, this field is used for information
10733 purposes only. Since GCC generates assembly language, we have no
10734 a priori knowledge of how many instruction bytes are generated for each
10735 source line, and therefore can use only the DW_LNE_set_address and
10736 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
10737 this as '1', which is "correct enough" for all architectures,
10738 and don't let the target override. */
10739 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
10742 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
10743 "Maximum Operations Per Instruction");
10744 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
10745 "Default is_stmt_start flag");
10746 dw2_asm_output_data (1, DWARF_LINE_BASE
,
10747 "Line Base Value (Special Opcodes)");
10748 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
10749 "Line Range Value (Special Opcodes)");
10750 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
10751 "Special Opcode Base");
10753 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
10758 case DW_LNS_advance_pc
:
10759 case DW_LNS_advance_line
:
10760 case DW_LNS_set_file
:
10761 case DW_LNS_set_column
:
10762 case DW_LNS_fixed_advance_pc
:
10763 case DW_LNS_set_isa
:
10771 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
10775 /* Write out the information about the files we use. */
10776 output_file_names ();
10777 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
10780 /* Output the marker for the end of the line number info. */
10781 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10785 if (separate_line_info
)
10787 dw_line_info_table
*table
;
10790 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
10793 output_one_line_info_table (table
);
10797 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
10799 output_one_line_info_table (cold_text_section_line_info
);
10803 /* ??? Some Darwin linkers crash on a .debug_line section with no
10804 sequences. Further, merely a DW_LNE_end_sequence entry is not
10805 sufficient -- the address column must also be initialized.
10806 Make sure to output at least one set_address/end_sequence pair,
10807 choosing .text since that section is always present. */
10808 if (text_section_line_info
->in_use
|| !saw_one
)
10809 output_one_line_info_table (text_section_line_info
);
10811 /* Output the marker for the end of the line number info. */
10812 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10815 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
10818 need_endianity_attribute_p (bool reverse
)
10820 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
10823 /* Given a pointer to a tree node for some base type, return a pointer to
10824 a DIE that describes the given type. REVERSE is true if the type is
10825 to be interpreted in the reverse storage order wrt the target order.
10827 This routine must only be called for GCC type nodes that correspond to
10828 Dwarf base (fundamental) types. */
10831 base_type_die (tree type
, bool reverse
)
10833 dw_die_ref base_type_result
;
10834 enum dwarf_type encoding
;
10835 bool fpt_used
= false;
10836 struct fixed_point_type_info fpt_info
;
10837 tree type_bias
= NULL_TREE
;
10839 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
10842 /* If this is a subtype that should not be emitted as a subrange type,
10843 use the base type. See subrange_type_for_debug_p. */
10844 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
10845 type
= TREE_TYPE (type
);
10847 switch (TREE_CODE (type
))
10850 if ((dwarf_version
>= 4 || !dwarf_strict
)
10851 && TYPE_NAME (type
)
10852 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10853 && DECL_IS_BUILTIN (TYPE_NAME (type
))
10854 && DECL_NAME (TYPE_NAME (type
)))
10856 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
10857 if (strcmp (name
, "char16_t") == 0
10858 || strcmp (name
, "char32_t") == 0)
10860 encoding
= DW_ATE_UTF
;
10864 if ((dwarf_version
>= 3 || !dwarf_strict
)
10865 && lang_hooks
.types
.get_fixed_point_type_info
)
10867 memset (&fpt_info
, 0, sizeof (fpt_info
));
10868 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
10871 encoding
= ((TYPE_UNSIGNED (type
))
10872 ? DW_ATE_unsigned_fixed
10873 : DW_ATE_signed_fixed
);
10877 if (TYPE_STRING_FLAG (type
))
10879 if (TYPE_UNSIGNED (type
))
10880 encoding
= DW_ATE_unsigned_char
;
10882 encoding
= DW_ATE_signed_char
;
10884 else if (TYPE_UNSIGNED (type
))
10885 encoding
= DW_ATE_unsigned
;
10887 encoding
= DW_ATE_signed
;
10890 && lang_hooks
.types
.get_type_bias
)
10891 type_bias
= lang_hooks
.types
.get_type_bias (type
);
10895 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
10897 if (dwarf_version
>= 3 || !dwarf_strict
)
10898 encoding
= DW_ATE_decimal_float
;
10900 encoding
= DW_ATE_lo_user
;
10903 encoding
= DW_ATE_float
;
10906 case FIXED_POINT_TYPE
:
10907 if (!(dwarf_version
>= 3 || !dwarf_strict
))
10908 encoding
= DW_ATE_lo_user
;
10909 else if (TYPE_UNSIGNED (type
))
10910 encoding
= DW_ATE_unsigned_fixed
;
10912 encoding
= DW_ATE_signed_fixed
;
10915 /* Dwarf2 doesn't know anything about complex ints, so use
10916 a user defined type for it. */
10918 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
10919 encoding
= DW_ATE_complex_float
;
10921 encoding
= DW_ATE_lo_user
;
10925 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10926 encoding
= DW_ATE_boolean
;
10930 /* No other TREE_CODEs are Dwarf fundamental types. */
10931 gcc_unreachable ();
10934 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die (), type
);
10936 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
10937 int_size_in_bytes (type
));
10938 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
10940 if (need_endianity_attribute_p (reverse
))
10941 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
10942 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
10946 switch (fpt_info
.scale_factor_kind
)
10948 case fixed_point_scale_factor_binary
:
10949 add_AT_int (base_type_result
, DW_AT_binary_scale
,
10950 fpt_info
.scale_factor
.binary
);
10953 case fixed_point_scale_factor_decimal
:
10954 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
10955 fpt_info
.scale_factor
.decimal
);
10958 case fixed_point_scale_factor_arbitrary
:
10959 /* Arbitrary scale factors cannot be described in standard DWARF,
10963 /* Describe the scale factor as a rational constant. */
10964 const dw_die_ref scale_factor
10965 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
10967 add_AT_unsigned (scale_factor
, DW_AT_GNU_numerator
,
10968 fpt_info
.scale_factor
.arbitrary
.numerator
);
10969 add_AT_int (scale_factor
, DW_AT_GNU_denominator
,
10970 fpt_info
.scale_factor
.arbitrary
.denominator
);
10972 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
10977 gcc_unreachable ();
10982 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
10983 dw_scalar_form_constant
10984 | dw_scalar_form_exprloc
10985 | dw_scalar_form_reference
,
10988 add_pubtype (type
, base_type_result
);
10990 return base_type_result
;
10993 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
10994 named 'auto' in its type: return true for it, false otherwise. */
10997 is_cxx_auto (tree type
)
11001 tree name
= TYPE_IDENTIFIER (type
);
11002 if (name
== get_identifier ("auto")
11003 || name
== get_identifier ("decltype(auto)"))
11009 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
11010 given input type is a Dwarf "fundamental" type. Otherwise return null. */
11013 is_base_type (tree type
)
11015 switch (TREE_CODE (type
))
11021 case FIXED_POINT_TYPE
:
11024 case POINTER_BOUNDS_TYPE
:
11030 case QUAL_UNION_TYPE
:
11031 case ENUMERAL_TYPE
:
11032 case FUNCTION_TYPE
:
11035 case REFERENCE_TYPE
:
11043 if (is_cxx_auto (type
))
11045 gcc_unreachable ();
11051 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
11052 node, return the size in bits for the type if it is a constant, or else
11053 return the alignment for the type if the type's size is not constant, or
11054 else return BITS_PER_WORD if the type actually turns out to be an
11055 ERROR_MARK node. */
11057 static inline unsigned HOST_WIDE_INT
11058 simple_type_size_in_bits (const_tree type
)
11060 if (TREE_CODE (type
) == ERROR_MARK
)
11061 return BITS_PER_WORD
;
11062 else if (TYPE_SIZE (type
) == NULL_TREE
)
11064 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
11065 return tree_to_uhwi (TYPE_SIZE (type
));
11067 return TYPE_ALIGN (type
);
11070 /* Similarly, but return an offset_int instead of UHWI. */
11072 static inline offset_int
11073 offset_int_type_size_in_bits (const_tree type
)
11075 if (TREE_CODE (type
) == ERROR_MARK
)
11076 return BITS_PER_WORD
;
11077 else if (TYPE_SIZE (type
) == NULL_TREE
)
11079 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
11080 return wi::to_offset (TYPE_SIZE (type
));
11082 return TYPE_ALIGN (type
);
11085 /* Given a pointer to a tree node for a subrange type, return a pointer
11086 to a DIE that describes the given type. */
11089 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
11090 dw_die_ref context_die
)
11092 dw_die_ref subrange_die
;
11093 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
11095 if (context_die
== NULL
)
11096 context_die
= comp_unit_die ();
11098 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
11100 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
11102 /* The size of the subrange type and its base type do not match,
11103 so we need to generate a size attribute for the subrange type. */
11104 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
11108 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
11110 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
11111 if (bias
&& !dwarf_strict
)
11112 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
11113 dw_scalar_form_constant
11114 | dw_scalar_form_exprloc
11115 | dw_scalar_form_reference
,
11118 return subrange_die
;
11121 /* Returns the (const and/or volatile) cv_qualifiers associated with
11122 the decl node. This will normally be augmented with the
11123 cv_qualifiers of the underlying type in add_type_attribute. */
11126 decl_quals (const_tree decl
)
11128 return ((TREE_READONLY (decl
)
11129 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
11130 | (TREE_THIS_VOLATILE (decl
)
11131 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
11134 /* Determine the TYPE whose qualifiers match the largest strict subset
11135 of the given TYPE_QUALS, and return its qualifiers. Ignore all
11136 qualifiers outside QUAL_MASK. */
11139 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
11142 int best_rank
= 0, best_qual
= 0, max_rank
;
11144 type_quals
&= qual_mask
;
11145 max_rank
= popcount_hwi (type_quals
) - 1;
11147 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
11148 t
= TYPE_NEXT_VARIANT (t
))
11150 int q
= TYPE_QUALS (t
) & qual_mask
;
11152 if ((q
& type_quals
) == q
&& q
!= type_quals
11153 && check_base_type (t
, type
))
11155 int rank
= popcount_hwi (q
);
11157 if (rank
> best_rank
)
11168 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
11169 static const dwarf_qual_info_t dwarf_qual_info
[] =
11171 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
11172 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
11173 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
11174 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
11176 static const unsigned int dwarf_qual_info_size
11177 = sizeof (dwarf_qual_info
) / sizeof (dwarf_qual_info
[0]);
11179 /* If DIE is a qualified DIE of some base DIE with the same parent,
11180 return the base DIE, otherwise return NULL. Set MASK to the
11181 qualifiers added compared to the returned DIE. */
11184 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
11187 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
11188 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
11190 if (i
== dwarf_qual_info_size
)
11192 if (vec_safe_length (die
->die_attr
) != 1)
11194 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
11195 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
11197 *mask
|= dwarf_qual_info
[i
].q
;
11200 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
11207 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
11208 entry that chains the modifiers specified by CV_QUALS in front of the
11209 given type. REVERSE is true if the type is to be interpreted in the
11210 reverse storage order wrt the target order. */
11213 modified_type_die (tree type
, int cv_quals
, bool reverse
,
11214 dw_die_ref context_die
)
11216 enum tree_code code
= TREE_CODE (type
);
11217 dw_die_ref mod_type_die
;
11218 dw_die_ref sub_die
= NULL
;
11219 tree item_type
= NULL
;
11220 tree qualified_type
;
11221 tree name
, low
, high
;
11222 dw_die_ref mod_scope
;
11223 /* Only these cv-qualifiers are currently handled. */
11224 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
11225 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
);
11227 if (code
== ERROR_MARK
)
11230 if (lang_hooks
.types
.get_debug_type
)
11232 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
11234 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
11235 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
11238 cv_quals
&= cv_qual_mask
;
11240 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
11241 tag modifier (and not an attribute) old consumers won't be able
11243 if (dwarf_version
< 3)
11244 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
11246 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
11247 if (dwarf_version
< 5)
11248 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
11250 /* See if we already have the appropriately qualified variant of
11252 qualified_type
= get_qualified_type (type
, cv_quals
);
11254 if (qualified_type
== sizetype
11255 && TYPE_NAME (qualified_type
)
11256 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
11258 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
11260 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
11261 && TYPE_PRECISION (t
)
11262 == TYPE_PRECISION (qualified_type
)
11263 && TYPE_UNSIGNED (t
)
11264 == TYPE_UNSIGNED (qualified_type
));
11265 qualified_type
= t
;
11268 /* If we do, then we can just use its DIE, if it exists. */
11269 if (qualified_type
)
11271 mod_type_die
= lookup_type_die (qualified_type
);
11273 /* DW_AT_endianity doesn't come from a qualifier on the type. */
11275 && (!need_endianity_attribute_p (reverse
)
11276 || !is_base_type (type
)
11277 || get_AT_unsigned (mod_type_die
, DW_AT_endianity
)))
11278 return mod_type_die
;
11281 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
11283 /* Handle C typedef types. */
11284 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
11285 && !DECL_ARTIFICIAL (name
))
11287 tree dtype
= TREE_TYPE (name
);
11289 if (qualified_type
== dtype
)
11291 /* For a named type, use the typedef. */
11292 gen_type_die (qualified_type
, context_die
);
11293 return lookup_type_die (qualified_type
);
11297 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
11298 dquals
&= cv_qual_mask
;
11299 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
11300 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
11301 /* cv-unqualified version of named type. Just use
11302 the unnamed type to which it refers. */
11303 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
11304 reverse
, context_die
);
11305 /* Else cv-qualified version of named type; fall through. */
11309 mod_scope
= scope_die_for (type
, context_die
);
11313 int sub_quals
= 0, first_quals
= 0;
11315 dw_die_ref first
= NULL
, last
= NULL
;
11317 /* Determine a lesser qualified type that most closely matches
11318 this one. Then generate DW_TAG_* entries for the remaining
11320 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
11322 if (sub_quals
&& use_debug_types
)
11324 bool needed
= false;
11325 /* If emitting type units, make sure the order of qualifiers
11326 is canonical. Thus, start from unqualified type if
11327 an earlier qualifier is missing in sub_quals, but some later
11328 one is present there. */
11329 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
11330 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
11332 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
11338 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
11339 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
11341 /* As not all intermediate qualified DIEs have corresponding
11342 tree types, ensure that qualified DIEs in the same scope
11343 as their DW_AT_type are emitted after their DW_AT_type,
11344 only with other qualified DIEs for the same type possibly
11345 in between them. Determine the range of such qualified
11346 DIEs now (first being the base type, last being corresponding
11347 last qualified DIE for it). */
11348 unsigned int count
= 0;
11349 first
= qualified_die_p (mod_type_die
, &first_quals
,
11350 dwarf_qual_info_size
);
11352 first
= mod_type_die
;
11353 gcc_assert ((first_quals
& ~sub_quals
) == 0);
11354 for (count
= 0, last
= first
;
11355 count
< (1U << dwarf_qual_info_size
);
11356 count
++, last
= last
->die_sib
)
11359 if (last
== mod_scope
->die_child
)
11361 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
11367 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
11368 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
11371 if (first
&& first
!= last
)
11373 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
11376 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
11377 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
11393 d
= ggc_cleared_alloc
<die_node
> ();
11394 d
->die_tag
= dwarf_qual_info
[i
].t
;
11395 add_child_die_after (mod_scope
, d
, last
);
11399 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
11401 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
11403 first_quals
|= dwarf_qual_info
[i
].q
;
11406 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
11408 dwarf_tag tag
= DW_TAG_pointer_type
;
11409 if (code
== REFERENCE_TYPE
)
11411 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
11412 tag
= DW_TAG_rvalue_reference_type
;
11414 tag
= DW_TAG_reference_type
;
11416 mod_type_die
= new_die (tag
, mod_scope
, type
);
11418 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
11419 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
11420 item_type
= TREE_TYPE (type
);
11422 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
11423 if (!ADDR_SPACE_GENERIC_P (as
))
11425 int action
= targetm
.addr_space
.debug (as
);
11428 /* Positive values indicate an address_class. */
11429 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
11433 /* Negative values indicate an (inverted) segment base reg. */
11435 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
11436 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
11440 else if (code
== INTEGER_TYPE
11441 && TREE_TYPE (type
) != NULL_TREE
11442 && subrange_type_for_debug_p (type
, &low
, &high
))
11444 tree bias
= NULL_TREE
;
11445 if (lang_hooks
.types
.get_type_bias
)
11446 bias
= lang_hooks
.types
.get_type_bias (type
);
11447 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
11448 item_type
= TREE_TYPE (type
);
11450 else if (is_base_type (type
))
11451 mod_type_die
= base_type_die (type
, reverse
);
11454 gen_type_die (type
, context_die
);
11456 /* We have to get the type_main_variant here (and pass that to the
11457 `lookup_type_die' routine) because the ..._TYPE node we have
11458 might simply be a *copy* of some original type node (where the
11459 copy was created to help us keep track of typedef names) and
11460 that copy might have a different TYPE_UID from the original
11462 if (TREE_CODE (type
) != VECTOR_TYPE
)
11463 return lookup_type_die (type_main_variant (type
));
11465 /* Vectors have the debugging information in the type,
11466 not the main variant. */
11467 return lookup_type_die (type
);
11470 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
11471 don't output a DW_TAG_typedef, since there isn't one in the
11472 user's program; just attach a DW_AT_name to the type.
11473 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
11474 if the base type already has the same name. */
11476 && ((TREE_CODE (name
) != TYPE_DECL
11477 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
11478 || (cv_quals
== TYPE_UNQUALIFIED
)))
11479 || (TREE_CODE (name
) == TYPE_DECL
11480 && TREE_TYPE (name
) == qualified_type
11481 && DECL_NAME (name
))))
11483 if (TREE_CODE (name
) == TYPE_DECL
)
11484 /* Could just call add_name_and_src_coords_attributes here,
11485 but since this is a builtin type it doesn't have any
11486 useful source coordinates anyway. */
11487 name
= DECL_NAME (name
);
11488 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
11490 /* This probably indicates a bug. */
11491 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
11493 name
= TYPE_IDENTIFIER (type
);
11494 add_name_attribute (mod_type_die
,
11495 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
11498 if (qualified_type
)
11499 equate_type_number_to_die (qualified_type
, mod_type_die
);
11502 /* We must do this after the equate_type_number_to_die call, in case
11503 this is a recursive type. This ensures that the modified_type_die
11504 recursion will terminate even if the type is recursive. Recursive
11505 types are possible in Ada. */
11506 sub_die
= modified_type_die (item_type
,
11507 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
11511 if (sub_die
!= NULL
)
11512 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
11514 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
11515 if (TYPE_ARTIFICIAL (type
))
11516 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
11518 return mod_type_die
;
11521 /* Generate DIEs for the generic parameters of T.
11522 T must be either a generic type or a generic function.
11523 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
11526 gen_generic_params_dies (tree t
)
11530 dw_die_ref die
= NULL
;
11533 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
11537 die
= lookup_type_die (t
);
11538 else if (DECL_P (t
))
11539 die
= lookup_decl_die (t
);
11543 parms
= lang_hooks
.get_innermost_generic_parms (t
);
11545 /* T has no generic parameter. It means T is neither a generic type
11546 or function. End of story. */
11549 parms_num
= TREE_VEC_LENGTH (parms
);
11550 args
= lang_hooks
.get_innermost_generic_args (t
);
11551 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
11552 non_default
= int_cst_value (TREE_CHAIN (args
));
11554 non_default
= TREE_VEC_LENGTH (args
);
11555 for (i
= 0; i
< parms_num
; i
++)
11557 tree parm
, arg
, arg_pack_elems
;
11558 dw_die_ref parm_die
;
11560 parm
= TREE_VEC_ELT (parms
, i
);
11561 arg
= TREE_VEC_ELT (args
, i
);
11562 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
11563 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
11565 if (parm
&& TREE_VALUE (parm
) && arg
)
11567 /* If PARM represents a template parameter pack,
11568 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
11569 by DW_TAG_template_*_parameter DIEs for the argument
11570 pack elements of ARG. Note that ARG would then be
11571 an argument pack. */
11572 if (arg_pack_elems
)
11573 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
11577 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
11578 true /* emit name */, die
);
11579 if (i
>= non_default
)
11580 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
11585 /* Create and return a DIE for PARM which should be
11586 the representation of a generic type parameter.
11587 For instance, in the C++ front end, PARM would be a template parameter.
11588 ARG is the argument to PARM.
11589 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
11591 PARENT_DIE is the parent DIE which the new created DIE should be added to,
11592 as a child node. */
11595 generic_parameter_die (tree parm
, tree arg
,
11597 dw_die_ref parent_die
)
11599 dw_die_ref tmpl_die
= NULL
;
11600 const char *name
= NULL
;
11602 if (!parm
|| !DECL_NAME (parm
) || !arg
)
11605 /* We support non-type generic parameters and arguments,
11606 type generic parameters and arguments, as well as
11607 generic generic parameters (a.k.a. template template parameters in C++)
11609 if (TREE_CODE (parm
) == PARM_DECL
)
11610 /* PARM is a nontype generic parameter */
11611 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
11612 else if (TREE_CODE (parm
) == TYPE_DECL
)
11613 /* PARM is a type generic parameter. */
11614 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
11615 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
11616 /* PARM is a generic generic parameter.
11617 Its DIE is a GNU extension. It shall have a
11618 DW_AT_name attribute to represent the name of the template template
11619 parameter, and a DW_AT_GNU_template_name attribute to represent the
11620 name of the template template argument. */
11621 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
11624 gcc_unreachable ();
11630 /* If PARM is a generic parameter pack, it means we are
11631 emitting debug info for a template argument pack element.
11632 In other terms, ARG is a template argument pack element.
11633 In that case, we don't emit any DW_AT_name attribute for
11637 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
11639 add_AT_string (tmpl_die
, DW_AT_name
, name
);
11642 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
11644 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
11645 TMPL_DIE should have a child DW_AT_type attribute that is set
11646 to the type of the argument to PARM, which is ARG.
11647 If PARM is a type generic parameter, TMPL_DIE should have a
11648 child DW_AT_type that is set to ARG. */
11649 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
11650 add_type_attribute (tmpl_die
, tmpl_type
,
11651 (TREE_THIS_VOLATILE (tmpl_type
)
11652 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
11653 false, parent_die
);
11657 /* So TMPL_DIE is a DIE representing a
11658 a generic generic template parameter, a.k.a template template
11659 parameter in C++ and arg is a template. */
11661 /* The DW_AT_GNU_template_name attribute of the DIE must be set
11662 to the name of the argument. */
11663 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
11665 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
11668 if (TREE_CODE (parm
) == PARM_DECL
)
11669 /* So PARM is a non-type generic parameter.
11670 DWARF3 5.6.8 says we must set a DW_AT_const_value child
11671 attribute of TMPL_DIE which value represents the value
11673 We must be careful here:
11674 The value of ARG might reference some function decls.
11675 We might currently be emitting debug info for a generic
11676 type and types are emitted before function decls, we don't
11677 know if the function decls referenced by ARG will actually be
11678 emitted after cgraph computations.
11679 So must defer the generation of the DW_AT_const_value to
11680 after cgraph is ready. */
11681 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
11687 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
11688 PARM_PACK must be a template parameter pack. The returned DIE
11689 will be child DIE of PARENT_DIE. */
11692 template_parameter_pack_die (tree parm_pack
,
11693 tree parm_pack_args
,
11694 dw_die_ref parent_die
)
11699 gcc_assert (parent_die
&& parm_pack
);
11701 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
11702 add_name_and_src_coords_attributes (die
, parm_pack
);
11703 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
11704 generic_parameter_die (parm_pack
,
11705 TREE_VEC_ELT (parm_pack_args
, j
),
11706 false /* Don't emit DW_AT_name */,
11711 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
11712 an enumerated type. */
11715 type_is_enum (const_tree type
)
11717 return TREE_CODE (type
) == ENUMERAL_TYPE
;
11720 /* Return the DBX register number described by a given RTL node. */
11722 static unsigned int
11723 dbx_reg_number (const_rtx rtl
)
11725 unsigned regno
= REGNO (rtl
);
11727 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
11729 #ifdef LEAF_REG_REMAP
11730 if (crtl
->uses_only_leaf_regs
)
11732 int leaf_reg
= LEAF_REG_REMAP (regno
);
11733 if (leaf_reg
!= -1)
11734 regno
= (unsigned) leaf_reg
;
11738 regno
= DBX_REGISTER_NUMBER (regno
);
11739 gcc_assert (regno
!= INVALID_REGNUM
);
11743 /* Optionally add a DW_OP_piece term to a location description expression.
11744 DW_OP_piece is only added if the location description expression already
11745 doesn't end with DW_OP_piece. */
11748 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
11750 dw_loc_descr_ref loc
;
11752 if (*list_head
!= NULL
)
11754 /* Find the end of the chain. */
11755 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
11758 if (loc
->dw_loc_opc
!= DW_OP_piece
)
11759 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
11763 /* Return a location descriptor that designates a machine register or
11764 zero if there is none. */
11766 static dw_loc_descr_ref
11767 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
11771 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
11774 /* We only use "frame base" when we're sure we're talking about the
11775 post-prologue local stack frame. We do this by *not* running
11776 register elimination until this point, and recognizing the special
11777 argument pointer and soft frame pointer rtx's.
11778 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
11779 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
11780 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
11782 dw_loc_descr_ref result
= NULL
;
11784 if (dwarf_version
>= 4 || !dwarf_strict
)
11786 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
11789 add_loc_descr (&result
,
11790 new_loc_descr (DW_OP_stack_value
, 0, 0));
11795 regs
= targetm
.dwarf_register_span (rtl
);
11797 if (REG_NREGS (rtl
) > 1 || regs
)
11798 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
11801 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
11802 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
11804 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
11808 /* Return a location descriptor that designates a machine register for
11809 a given hard register number. */
11811 static dw_loc_descr_ref
11812 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
11814 dw_loc_descr_ref reg_loc_descr
;
11818 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
11820 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
11822 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11823 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11825 return reg_loc_descr
;
11828 /* Given an RTL of a register, return a location descriptor that
11829 designates a value that spans more than one register. */
11831 static dw_loc_descr_ref
11832 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
11833 enum var_init_status initialized
)
11836 dw_loc_descr_ref loc_result
= NULL
;
11838 /* Simple, contiguous registers. */
11839 if (regs
== NULL_RTX
)
11841 unsigned reg
= REGNO (rtl
);
11844 #ifdef LEAF_REG_REMAP
11845 if (crtl
->uses_only_leaf_regs
)
11847 int leaf_reg
= LEAF_REG_REMAP (reg
);
11848 if (leaf_reg
!= -1)
11849 reg
= (unsigned) leaf_reg
;
11853 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
11854 nregs
= REG_NREGS (rtl
);
11856 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
11861 dw_loc_descr_ref t
;
11863 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
11864 VAR_INIT_STATUS_INITIALIZED
);
11865 add_loc_descr (&loc_result
, t
);
11866 add_loc_descr_op_piece (&loc_result
, size
);
11872 /* Now onto stupid register sets in non contiguous locations. */
11874 gcc_assert (GET_CODE (regs
) == PARALLEL
);
11876 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
11879 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
11881 dw_loc_descr_ref t
;
11883 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
11884 VAR_INIT_STATUS_INITIALIZED
);
11885 add_loc_descr (&loc_result
, t
);
11886 add_loc_descr_op_piece (&loc_result
, size
);
11889 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11890 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11894 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
11896 /* Return a location descriptor that designates a constant i,
11897 as a compound operation from constant (i >> shift), constant shift
11900 static dw_loc_descr_ref
11901 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11903 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
11904 add_loc_descr (&ret
, int_loc_descriptor (shift
));
11905 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
11909 /* Return a location descriptor that designates a constant. */
11911 static dw_loc_descr_ref
11912 int_loc_descriptor (HOST_WIDE_INT i
)
11914 enum dwarf_location_atom op
;
11916 /* Pick the smallest representation of a constant, rather than just
11917 defaulting to the LEB encoding. */
11920 int clz
= clz_hwi (i
);
11921 int ctz
= ctz_hwi (i
);
11923 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
11924 else if (i
<= 0xff)
11925 op
= DW_OP_const1u
;
11926 else if (i
<= 0xffff)
11927 op
= DW_OP_const2u
;
11928 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11929 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11930 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
11931 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
11932 while DW_OP_const4u is 5 bytes. */
11933 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
11934 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11935 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11936 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
11937 while DW_OP_const4u is 5 bytes. */
11938 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11939 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11940 op
= DW_OP_const4u
;
11941 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11942 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11943 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
11944 while DW_OP_constu of constant >= 0x100000000 takes at least
11946 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11947 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11948 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
11949 >= HOST_BITS_PER_WIDE_INT
)
11950 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
11951 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
11952 while DW_OP_constu takes in this case at least 6 bytes. */
11953 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
11954 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11955 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11956 && size_of_uleb128 (i
) > 6)
11957 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
11958 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
11965 op
= DW_OP_const1s
;
11966 else if (i
>= -0x8000)
11967 op
= DW_OP_const2s
;
11968 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11970 if (size_of_int_loc_descriptor (i
) < 5)
11972 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11973 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11976 op
= DW_OP_const4s
;
11980 if (size_of_int_loc_descriptor (i
)
11981 < (unsigned long) 1 + size_of_sleb128 (i
))
11983 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11984 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11991 return new_loc_descr (op
, i
, 0);
11994 /* Likewise, for unsigned constants. */
11996 static dw_loc_descr_ref
11997 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
11999 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
12000 const unsigned HOST_WIDE_INT max_uint
12001 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
12003 /* If possible, use the clever signed constants handling. */
12005 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
12007 /* Here, we are left with positive numbers that cannot be represented as
12008 HOST_WIDE_INT, i.e.:
12009 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
12011 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
12012 whereas may be better to output a negative integer: thanks to integer
12013 wrapping, we know that:
12014 x = x - 2 ** DWARF2_ADDR_SIZE
12015 = x - 2 * (max (HOST_WIDE_INT) + 1)
12016 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
12017 small negative integers. Let's try that in cases it will clearly improve
12018 the encoding: there is no gain turning DW_OP_const4u into
12020 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
12021 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
12022 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
12024 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
12026 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
12027 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
12028 const HOST_WIDE_INT second_shift
12029 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
12031 /* So we finally have:
12032 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
12033 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
12034 return int_loc_descriptor (second_shift
);
12037 /* Last chance: fallback to a simple constant operation. */
12038 return new_loc_descr
12039 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
12045 /* Generate and return a location description that computes the unsigned
12046 comparison of the two stack top entries (a OP b where b is the top-most
12047 entry and a is the second one). The KIND of comparison can be LT_EXPR,
12048 LE_EXPR, GT_EXPR or GE_EXPR. */
12050 static dw_loc_descr_ref
12051 uint_comparison_loc_list (enum tree_code kind
)
12053 enum dwarf_location_atom op
, flip_op
;
12054 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
12071 gcc_unreachable ();
12074 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
12075 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
12077 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
12078 possible to perform unsigned comparisons: we just have to distinguish
12081 1. when a and b have the same sign (as signed integers); then we should
12082 return: a OP(signed) b;
12084 2. when a is a negative signed integer while b is a positive one, then a
12085 is a greater unsigned integer than b; likewise when a and b's roles
12088 So first, compare the sign of the two operands. */
12089 ret
= new_loc_descr (DW_OP_over
, 0, 0);
12090 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12091 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
12092 /* If they have different signs (i.e. they have different sign bits), then
12093 the stack top value has now the sign bit set and thus it's smaller than
12095 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
12096 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
12097 add_loc_descr (&ret
, bra_node
);
12099 /* We are in case 1. At this point, we know both operands have the same
12100 sign, to it's safe to use the built-in signed comparison. */
12101 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
12102 add_loc_descr (&ret
, jmp_node
);
12104 /* We are in case 2. Here, we know both operands do not have the same sign,
12105 so we have to flip the signed comparison. */
12106 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
12107 tmp
= new_loc_descr (flip_op
, 0, 0);
12108 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12109 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
12110 add_loc_descr (&ret
, tmp
);
12112 /* This dummy operation is necessary to make the two branches join. */
12113 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
12114 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12115 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
12116 add_loc_descr (&ret
, tmp
);
12121 /* Likewise, but takes the location description lists (might be destructive on
12122 them). Return NULL if either is NULL or if concatenation fails. */
12124 static dw_loc_list_ref
12125 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
12126 enum tree_code kind
)
12128 if (left
== NULL
|| right
== NULL
)
12131 add_loc_list (&left
, right
);
12135 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
12139 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
12140 without actually allocating it. */
12142 static unsigned long
12143 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
12145 return size_of_int_loc_descriptor (i
>> shift
)
12146 + size_of_int_loc_descriptor (shift
)
12150 /* Return size_of_locs (int_loc_descriptor (i)) without
12151 actually allocating it. */
12153 static unsigned long
12154 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
12163 else if (i
<= 0xff)
12165 else if (i
<= 0xffff)
12169 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
12170 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
12171 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
12173 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
12174 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
12175 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
12177 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
12179 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
12180 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
12181 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
12182 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
12184 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
12185 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
12186 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
12188 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
12189 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
12191 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
12200 else if (i
>= -0x8000)
12202 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
12204 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
12206 s
= size_of_int_loc_descriptor (-i
) + 1;
12214 unsigned long r
= 1 + size_of_sleb128 (i
);
12215 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
12217 s
= size_of_int_loc_descriptor (-i
) + 1;
12226 /* Return loc description representing "address" of integer value.
12227 This can appear only as toplevel expression. */
12229 static dw_loc_descr_ref
12230 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
12233 dw_loc_descr_ref loc_result
= NULL
;
12235 if (!(dwarf_version
>= 4 || !dwarf_strict
))
12238 litsize
= size_of_int_loc_descriptor (i
);
12239 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
12240 is more compact. For DW_OP_stack_value we need:
12241 litsize + 1 (DW_OP_stack_value)
12242 and for DW_OP_implicit_value:
12243 1 (DW_OP_implicit_value) + 1 (length) + size. */
12244 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
12246 loc_result
= int_loc_descriptor (i
);
12247 add_loc_descr (&loc_result
,
12248 new_loc_descr (DW_OP_stack_value
, 0, 0));
12252 loc_result
= new_loc_descr (DW_OP_implicit_value
,
12254 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
12255 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
12259 /* Return a location descriptor that designates a base+offset location. */
12261 static dw_loc_descr_ref
12262 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
12263 enum var_init_status initialized
)
12265 unsigned int regno
;
12266 dw_loc_descr_ref result
;
12267 dw_fde_ref fde
= cfun
->fde
;
12269 /* We only use "frame base" when we're sure we're talking about the
12270 post-prologue local stack frame. We do this by *not* running
12271 register elimination until this point, and recognizing the special
12272 argument pointer and soft frame pointer rtx's. */
12273 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
12275 rtx elim
= (ira_use_lra_p
12276 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
12277 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
12281 if (GET_CODE (elim
) == PLUS
)
12283 offset
+= INTVAL (XEXP (elim
, 1));
12284 elim
= XEXP (elim
, 0);
12286 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
12287 && (elim
== hard_frame_pointer_rtx
12288 || elim
== stack_pointer_rtx
))
12289 || elim
== (frame_pointer_needed
12290 ? hard_frame_pointer_rtx
12291 : stack_pointer_rtx
));
12293 /* If drap register is used to align stack, use frame
12294 pointer + offset to access stack variables. If stack
12295 is aligned without drap, use stack pointer + offset to
12296 access stack variables. */
12297 if (crtl
->stack_realign_tried
12298 && reg
== frame_pointer_rtx
)
12301 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
12302 ? HARD_FRAME_POINTER_REGNUM
12304 return new_reg_loc_descr (base_reg
, offset
);
12307 gcc_assert (frame_pointer_fb_offset_valid
);
12308 offset
+= frame_pointer_fb_offset
;
12309 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
12313 regno
= REGNO (reg
);
12314 #ifdef LEAF_REG_REMAP
12315 if (crtl
->uses_only_leaf_regs
)
12317 int leaf_reg
= LEAF_REG_REMAP (regno
);
12318 if (leaf_reg
!= -1)
12319 regno
= (unsigned) leaf_reg
;
12322 regno
= DWARF_FRAME_REGNUM (regno
);
12324 if (!optimize
&& fde
12325 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
))
12327 /* Use cfa+offset to represent the location of arguments passed
12328 on the stack when drap is used to align stack.
12329 Only do this when not optimizing, for optimized code var-tracking
12330 is supposed to track where the arguments live and the register
12331 used as vdrap or drap in some spot might be used for something
12332 else in other part of the routine. */
12333 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
12337 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
12340 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
12342 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
12343 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
12348 /* Return true if this RTL expression describes a base+offset calculation. */
12351 is_based_loc (const_rtx rtl
)
12353 return (GET_CODE (rtl
) == PLUS
12354 && ((REG_P (XEXP (rtl
, 0))
12355 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
12356 && CONST_INT_P (XEXP (rtl
, 1)))));
12359 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
12362 static dw_loc_descr_ref
12363 tls_mem_loc_descriptor (rtx mem
)
12366 dw_loc_descr_ref loc_result
;
12368 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
12371 base
= get_base_address (MEM_EXPR (mem
));
12373 || TREE_CODE (base
) != VAR_DECL
12374 || !DECL_THREAD_LOCAL_P (base
))
12377 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
12378 if (loc_result
== NULL
)
12381 if (MEM_OFFSET (mem
))
12382 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
12387 /* Output debug info about reason why we failed to expand expression as dwarf
12391 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
12393 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
12395 fprintf (dump_file
, "Failed to expand as dwarf: ");
12397 print_generic_expr (dump_file
, expr
, dump_flags
);
12400 fprintf (dump_file
, "\n");
12401 print_rtl (dump_file
, rtl
);
12403 fprintf (dump_file
, "\nReason: %s\n", reason
);
12407 /* Helper function for const_ok_for_output. */
12410 const_ok_for_output_1 (rtx rtl
)
12412 if (GET_CODE (rtl
) == UNSPEC
)
12414 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
12415 we can't express it in the debug info. */
12416 /* Don't complain about TLS UNSPECs, those are just too hard to
12417 delegitimize. Note this could be a non-decl SYMBOL_REF such as
12418 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
12419 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
12421 && (XVECLEN (rtl
, 0) == 0
12422 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
12423 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
12424 inform (current_function_decl
12425 ? DECL_SOURCE_LOCATION (current_function_decl
)
12426 : UNKNOWN_LOCATION
,
12427 #if NUM_UNSPEC_VALUES > 0
12428 "non-delegitimized UNSPEC %s (%d) found in variable location",
12429 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
12430 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
12433 "non-delegitimized UNSPEC %d found in variable location",
12436 expansion_failed (NULL_TREE
, rtl
,
12437 "UNSPEC hasn't been delegitimized.\n");
12441 if (targetm
.const_not_ok_for_debug_p (rtl
))
12443 expansion_failed (NULL_TREE
, rtl
,
12444 "Expression rejected for debug by the backend.\n");
12448 /* FIXME: Refer to PR60655. It is possible for simplification
12449 of rtl expressions in var tracking to produce such expressions.
12450 We should really identify / validate expressions
12451 enclosed in CONST that can be handled by assemblers on various
12452 targets and only handle legitimate cases here. */
12453 if (GET_CODE (rtl
) != SYMBOL_REF
)
12455 if (GET_CODE (rtl
) == NOT
)
12460 if (CONSTANT_POOL_ADDRESS_P (rtl
))
12463 get_pool_constant_mark (rtl
, &marked
);
12464 /* If all references to this pool constant were optimized away,
12465 it was not output and thus we can't represent it. */
12468 expansion_failed (NULL_TREE
, rtl
,
12469 "Constant was removed from constant pool.\n");
12474 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
12477 /* Avoid references to external symbols in debug info, on several targets
12478 the linker might even refuse to link when linking a shared library,
12479 and in many other cases the relocations for .debug_info/.debug_loc are
12480 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
12481 to be defined within the same shared library or executable are fine. */
12482 if (SYMBOL_REF_EXTERNAL_P (rtl
))
12484 tree decl
= SYMBOL_REF_DECL (rtl
);
12486 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
12488 expansion_failed (NULL_TREE
, rtl
,
12489 "Symbol not defined in current TU.\n");
12497 /* Return true if constant RTL can be emitted in DW_OP_addr or
12498 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
12499 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
12502 const_ok_for_output (rtx rtl
)
12504 if (GET_CODE (rtl
) == SYMBOL_REF
)
12505 return const_ok_for_output_1 (rtl
);
12507 if (GET_CODE (rtl
) == CONST
)
12509 subrtx_var_iterator::array_type array
;
12510 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
12511 if (!const_ok_for_output_1 (*iter
))
12519 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
12520 if possible, NULL otherwise. */
12523 base_type_for_mode (machine_mode mode
, bool unsignedp
)
12525 dw_die_ref type_die
;
12526 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
12530 switch (TREE_CODE (type
))
12538 type_die
= lookup_type_die (type
);
12540 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
12542 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
12547 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
12548 type matching MODE, or, if MODE is narrower than or as wide as
12549 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
12552 static dw_loc_descr_ref
12553 convert_descriptor_to_mode (machine_mode mode
, dw_loc_descr_ref op
)
12555 machine_mode outer_mode
= mode
;
12556 dw_die_ref type_die
;
12557 dw_loc_descr_ref cvt
;
12559 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12561 add_loc_descr (&op
, new_loc_descr (DW_OP_GNU_convert
, 0, 0));
12564 type_die
= base_type_for_mode (outer_mode
, 1);
12565 if (type_die
== NULL
)
12567 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12568 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12569 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12570 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12571 add_loc_descr (&op
, cvt
);
12575 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
12577 static dw_loc_descr_ref
12578 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
12579 dw_loc_descr_ref op1
)
12581 dw_loc_descr_ref ret
= op0
;
12582 add_loc_descr (&ret
, op1
);
12583 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
12584 if (STORE_FLAG_VALUE
!= 1)
12586 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
12587 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
12592 /* Return location descriptor for signed comparison OP RTL. */
12594 static dw_loc_descr_ref
12595 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
12596 machine_mode mem_mode
)
12598 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
12599 dw_loc_descr_ref op0
, op1
;
12602 if (op_mode
== VOIDmode
)
12603 op_mode
= GET_MODE (XEXP (rtl
, 1));
12604 if (op_mode
== VOIDmode
)
12608 && (!SCALAR_INT_MODE_P (op_mode
)
12609 || GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
))
12612 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
12613 VAR_INIT_STATUS_INITIALIZED
);
12614 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
12615 VAR_INIT_STATUS_INITIALIZED
);
12617 if (op0
== NULL
|| op1
== NULL
)
12620 if (!SCALAR_INT_MODE_P (op_mode
)
12621 || GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
12622 return compare_loc_descriptor (op
, op0
, op1
);
12624 if (GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
12626 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
12627 dw_loc_descr_ref cvt
;
12629 if (type_die
== NULL
)
12631 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12632 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12633 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12634 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12635 add_loc_descr (&op0
, cvt
);
12636 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12637 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12638 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12639 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12640 add_loc_descr (&op1
, cvt
);
12641 return compare_loc_descriptor (op
, op0
, op1
);
12644 shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
12645 /* For eq/ne, if the operands are known to be zero-extended,
12646 there is no need to do the fancy shifting up. */
12647 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
12649 dw_loc_descr_ref last0
, last1
;
12650 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
12652 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
12654 /* deref_size zero extends, and for constants we can check
12655 whether they are zero extended or not. */
12656 if (((last0
->dw_loc_opc
== DW_OP_deref_size
12657 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
12658 || (CONST_INT_P (XEXP (rtl
, 0))
12659 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
12660 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
12661 && ((last1
->dw_loc_opc
== DW_OP_deref_size
12662 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
12663 || (CONST_INT_P (XEXP (rtl
, 1))
12664 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
12665 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
12666 return compare_loc_descriptor (op
, op0
, op1
);
12668 /* EQ/NE comparison against constant in narrower type than
12669 DWARF2_ADDR_SIZE can be performed either as
12670 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
12673 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
12674 DW_OP_{eq,ne}. Pick whatever is shorter. */
12675 if (CONST_INT_P (XEXP (rtl
, 1))
12676 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
12677 && (size_of_int_loc_descriptor (shift
) + 1
12678 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
)
12679 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
12680 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
12681 & GET_MODE_MASK (op_mode
))))
12683 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
12684 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
12685 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
12686 & GET_MODE_MASK (op_mode
));
12687 return compare_loc_descriptor (op
, op0
, op1
);
12690 add_loc_descr (&op0
, int_loc_descriptor (shift
));
12691 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
12692 if (CONST_INT_P (XEXP (rtl
, 1)))
12693 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
);
12696 add_loc_descr (&op1
, int_loc_descriptor (shift
));
12697 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
12699 return compare_loc_descriptor (op
, op0
, op1
);
12702 /* Return location descriptor for unsigned comparison OP RTL. */
12704 static dw_loc_descr_ref
12705 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
12706 machine_mode mem_mode
)
12708 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
12709 dw_loc_descr_ref op0
, op1
;
12711 if (op_mode
== VOIDmode
)
12712 op_mode
= GET_MODE (XEXP (rtl
, 1));
12713 if (op_mode
== VOIDmode
)
12715 if (!SCALAR_INT_MODE_P (op_mode
))
12718 if (dwarf_strict
&& GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
12721 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
12722 VAR_INIT_STATUS_INITIALIZED
);
12723 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
12724 VAR_INIT_STATUS_INITIALIZED
);
12726 if (op0
== NULL
|| op1
== NULL
)
12729 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
12731 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
12732 dw_loc_descr_ref last0
, last1
;
12733 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
12735 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
12737 if (CONST_INT_P (XEXP (rtl
, 0)))
12738 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
12739 /* deref_size zero extends, so no need to mask it again. */
12740 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
12741 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
12743 add_loc_descr (&op0
, int_loc_descriptor (mask
));
12744 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
12746 if (CONST_INT_P (XEXP (rtl
, 1)))
12747 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
12748 /* deref_size zero extends, so no need to mask it again. */
12749 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
12750 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
12752 add_loc_descr (&op1
, int_loc_descriptor (mask
));
12753 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
12756 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
12758 HOST_WIDE_INT bias
= 1;
12759 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
12760 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
12761 if (CONST_INT_P (XEXP (rtl
, 1)))
12762 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
12763 + INTVAL (XEXP (rtl
, 1)));
12765 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
12768 return compare_loc_descriptor (op
, op0
, op1
);
12771 /* Return location descriptor for {U,S}{MIN,MAX}. */
12773 static dw_loc_descr_ref
12774 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
12775 machine_mode mem_mode
)
12777 enum dwarf_location_atom op
;
12778 dw_loc_descr_ref op0
, op1
, ret
;
12779 dw_loc_descr_ref bra_node
, drop_node
;
12782 && (!SCALAR_INT_MODE_P (mode
)
12783 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
))
12786 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12787 VAR_INIT_STATUS_INITIALIZED
);
12788 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12789 VAR_INIT_STATUS_INITIALIZED
);
12791 if (op0
== NULL
|| op1
== NULL
)
12794 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
12795 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
12796 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
12797 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
12799 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
12801 HOST_WIDE_INT mask
= GET_MODE_MASK (mode
);
12802 add_loc_descr (&op0
, int_loc_descriptor (mask
));
12803 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
12804 add_loc_descr (&op1
, int_loc_descriptor (mask
));
12805 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
12807 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
12809 HOST_WIDE_INT bias
= 1;
12810 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
12811 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
12812 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
12815 else if (!SCALAR_INT_MODE_P (mode
)
12816 && GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
12818 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (mode
)) * BITS_PER_UNIT
;
12819 add_loc_descr (&op0
, int_loc_descriptor (shift
));
12820 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
12821 add_loc_descr (&op1
, int_loc_descriptor (shift
));
12822 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
12824 else if (SCALAR_INT_MODE_P (mode
)
12825 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12827 dw_die_ref type_die
= base_type_for_mode (mode
, 0);
12828 dw_loc_descr_ref cvt
;
12829 if (type_die
== NULL
)
12831 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12832 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12833 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12834 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12835 add_loc_descr (&op0
, cvt
);
12836 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12837 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12838 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12839 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12840 add_loc_descr (&op1
, cvt
);
12843 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
12848 add_loc_descr (&ret
, op1
);
12849 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
12850 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
12851 add_loc_descr (&ret
, bra_node
);
12852 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12853 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
12854 add_loc_descr (&ret
, drop_node
);
12855 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12856 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
12857 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
12858 && SCALAR_INT_MODE_P (mode
)
12859 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12860 ret
= convert_descriptor_to_mode (mode
, ret
);
12864 /* Helper function for mem_loc_descriptor. Perform OP binary op,
12865 but after converting arguments to type_die, afterwards
12866 convert back to unsigned. */
12868 static dw_loc_descr_ref
12869 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
12870 machine_mode mode
, machine_mode mem_mode
)
12872 dw_loc_descr_ref cvt
, op0
, op1
;
12874 if (type_die
== NULL
)
12876 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12877 VAR_INIT_STATUS_INITIALIZED
);
12878 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12879 VAR_INIT_STATUS_INITIALIZED
);
12880 if (op0
== NULL
|| op1
== NULL
)
12882 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12883 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12884 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12885 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12886 add_loc_descr (&op0
, cvt
);
12887 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12888 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12889 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12890 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12891 add_loc_descr (&op1
, cvt
);
12892 add_loc_descr (&op0
, op1
);
12893 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
12894 return convert_descriptor_to_mode (mode
, op0
);
12897 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
12898 const0 is DW_OP_lit0 or corresponding typed constant,
12899 const1 is DW_OP_lit1 or corresponding typed constant
12900 and constMSB is constant with just the MSB bit set
12902 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
12903 L1: const0 DW_OP_swap
12904 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
12905 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12910 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
12911 L1: const0 DW_OP_swap
12912 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
12913 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12918 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
12919 L1: const1 DW_OP_swap
12920 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
12921 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12925 static dw_loc_descr_ref
12926 clz_loc_descriptor (rtx rtl
, machine_mode mode
,
12927 machine_mode mem_mode
)
12929 dw_loc_descr_ref op0
, ret
, tmp
;
12930 HOST_WIDE_INT valv
;
12931 dw_loc_descr_ref l1jump
, l1label
;
12932 dw_loc_descr_ref l2jump
, l2label
;
12933 dw_loc_descr_ref l3jump
, l3label
;
12934 dw_loc_descr_ref l4jump
, l4label
;
12937 if (!SCALAR_INT_MODE_P (mode
)
12938 || GET_MODE (XEXP (rtl
, 0)) != mode
)
12941 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12942 VAR_INIT_STATUS_INITIALIZED
);
12946 if (GET_CODE (rtl
) == CLZ
)
12948 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
12949 valv
= GET_MODE_BITSIZE (mode
);
12951 else if (GET_CODE (rtl
) == FFS
)
12953 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
12954 valv
= GET_MODE_BITSIZE (mode
);
12955 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12956 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12957 add_loc_descr (&ret
, l1jump
);
12958 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
12959 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
12960 VAR_INIT_STATUS_INITIALIZED
);
12963 add_loc_descr (&ret
, tmp
);
12964 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12965 add_loc_descr (&ret
, l4jump
);
12966 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
12967 ? const1_rtx
: const0_rtx
,
12969 VAR_INIT_STATUS_INITIALIZED
);
12970 if (l1label
== NULL
)
12972 add_loc_descr (&ret
, l1label
);
12973 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12974 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
12975 add_loc_descr (&ret
, l2label
);
12976 if (GET_CODE (rtl
) != CLZ
)
12978 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
12979 msb
= GEN_INT (HOST_WIDE_INT_1U
12980 << (GET_MODE_BITSIZE (mode
) - 1));
12982 msb
= immed_wide_int_const
12983 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
12984 GET_MODE_PRECISION (mode
)), mode
);
12985 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
12986 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12987 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
12988 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
12990 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
12991 VAR_INIT_STATUS_INITIALIZED
);
12994 add_loc_descr (&ret
, tmp
);
12995 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12996 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12997 add_loc_descr (&ret
, l3jump
);
12998 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12999 VAR_INIT_STATUS_INITIALIZED
);
13002 add_loc_descr (&ret
, tmp
);
13003 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
13004 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
13005 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13006 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
13007 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13008 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
13009 add_loc_descr (&ret
, l2jump
);
13010 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
13011 add_loc_descr (&ret
, l3label
);
13012 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
13013 add_loc_descr (&ret
, l4label
);
13014 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13015 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
13016 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13017 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
13018 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13019 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
13020 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13021 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
13025 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
13026 const1 is DW_OP_lit1 or corresponding typed constant):
13028 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
13029 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
13033 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
13034 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
13037 static dw_loc_descr_ref
13038 popcount_loc_descriptor (rtx rtl
, machine_mode mode
,
13039 machine_mode mem_mode
)
13041 dw_loc_descr_ref op0
, ret
, tmp
;
13042 dw_loc_descr_ref l1jump
, l1label
;
13043 dw_loc_descr_ref l2jump
, l2label
;
13045 if (!SCALAR_INT_MODE_P (mode
)
13046 || GET_MODE (XEXP (rtl
, 0)) != mode
)
13049 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13050 VAR_INIT_STATUS_INITIALIZED
);
13054 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
13055 VAR_INIT_STATUS_INITIALIZED
);
13058 add_loc_descr (&ret
, tmp
);
13059 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13060 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
13061 add_loc_descr (&ret
, l1label
);
13062 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
13063 add_loc_descr (&ret
, l2jump
);
13064 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
13065 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
13066 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
13067 VAR_INIT_STATUS_INITIALIZED
);
13070 add_loc_descr (&ret
, tmp
);
13071 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
13072 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
13073 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
13074 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13075 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
13076 VAR_INIT_STATUS_INITIALIZED
);
13077 add_loc_descr (&ret
, tmp
);
13078 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
13079 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
13080 add_loc_descr (&ret
, l1jump
);
13081 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
13082 add_loc_descr (&ret
, l2label
);
13083 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13084 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
13085 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13086 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
13090 /* BSWAP (constS is initial shift count, either 56 or 24):
13092 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
13093 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
13094 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
13095 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
13096 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
13098 static dw_loc_descr_ref
13099 bswap_loc_descriptor (rtx rtl
, machine_mode mode
,
13100 machine_mode mem_mode
)
13102 dw_loc_descr_ref op0
, ret
, tmp
;
13103 dw_loc_descr_ref l1jump
, l1label
;
13104 dw_loc_descr_ref l2jump
, l2label
;
13106 if (!SCALAR_INT_MODE_P (mode
)
13107 || BITS_PER_UNIT
!= 8
13108 || (GET_MODE_BITSIZE (mode
) != 32
13109 && GET_MODE_BITSIZE (mode
) != 64))
13112 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13113 VAR_INIT_STATUS_INITIALIZED
);
13118 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
13120 VAR_INIT_STATUS_INITIALIZED
);
13123 add_loc_descr (&ret
, tmp
);
13124 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
13125 VAR_INIT_STATUS_INITIALIZED
);
13128 add_loc_descr (&ret
, tmp
);
13129 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
13130 add_loc_descr (&ret
, l1label
);
13131 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
13133 VAR_INIT_STATUS_INITIALIZED
);
13134 add_loc_descr (&ret
, tmp
);
13135 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
13136 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
13137 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
13138 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
13139 VAR_INIT_STATUS_INITIALIZED
);
13142 add_loc_descr (&ret
, tmp
);
13143 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
13144 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
13145 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
13146 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
13147 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13148 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
13149 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
13150 VAR_INIT_STATUS_INITIALIZED
);
13151 add_loc_descr (&ret
, tmp
);
13152 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
13153 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
13154 add_loc_descr (&ret
, l2jump
);
13155 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
13156 VAR_INIT_STATUS_INITIALIZED
);
13157 add_loc_descr (&ret
, tmp
);
13158 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
13159 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13160 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
13161 add_loc_descr (&ret
, l1jump
);
13162 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
13163 add_loc_descr (&ret
, l2label
);
13164 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13165 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
13166 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13167 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
13168 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13169 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
13173 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
13174 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
13175 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
13176 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
13178 ROTATERT is similar:
13179 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
13180 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
13181 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
13183 static dw_loc_descr_ref
13184 rotate_loc_descriptor (rtx rtl
, machine_mode mode
,
13185 machine_mode mem_mode
)
13187 rtx rtlop1
= XEXP (rtl
, 1);
13188 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
13191 if (!SCALAR_INT_MODE_P (mode
))
13194 if (GET_MODE (rtlop1
) != VOIDmode
13195 && GET_MODE_BITSIZE (GET_MODE (rtlop1
)) < GET_MODE_BITSIZE (mode
))
13196 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
13197 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13198 VAR_INIT_STATUS_INITIALIZED
);
13199 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
13200 VAR_INIT_STATUS_INITIALIZED
);
13201 if (op0
== NULL
|| op1
== NULL
)
13203 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
13204 for (i
= 0; i
< 2; i
++)
13206 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
13207 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
13209 VAR_INIT_STATUS_INITIALIZED
);
13210 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
13211 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
13213 : HOST_BITS_PER_WIDE_INT
== 64
13214 ? DW_OP_const8u
: DW_OP_constu
,
13215 GET_MODE_MASK (mode
), 0);
13218 if (mask
[i
] == NULL
)
13220 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
13223 add_loc_descr (&ret
, op1
);
13224 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
13225 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
13226 if (GET_CODE (rtl
) == ROTATERT
)
13228 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13229 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
13230 GET_MODE_BITSIZE (mode
), 0));
13232 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
13233 if (mask
[0] != NULL
)
13234 add_loc_descr (&ret
, mask
[0]);
13235 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
13236 if (mask
[1] != NULL
)
13238 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13239 add_loc_descr (&ret
, mask
[1]);
13240 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
13242 if (GET_CODE (rtl
) == ROTATE
)
13244 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13245 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
13246 GET_MODE_BITSIZE (mode
), 0));
13248 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
13249 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
13253 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
13254 for DEBUG_PARAMETER_REF RTL. */
13256 static dw_loc_descr_ref
13257 parameter_ref_descriptor (rtx rtl
)
13259 dw_loc_descr_ref ret
;
13264 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
13265 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
13266 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
13269 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13270 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
13271 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13275 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
13276 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
13281 /* The following routine converts the RTL for a variable or parameter
13282 (resident in memory) into an equivalent Dwarf representation of a
13283 mechanism for getting the address of that same variable onto the top of a
13284 hypothetical "address evaluation" stack.
13286 When creating memory location descriptors, we are effectively transforming
13287 the RTL for a memory-resident object into its Dwarf postfix expression
13288 equivalent. This routine recursively descends an RTL tree, turning
13289 it into Dwarf postfix code as it goes.
13291 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
13293 MEM_MODE is the mode of the memory reference, needed to handle some
13294 autoincrement addressing modes.
13296 Return 0 if we can't represent the location. */
13299 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
13300 machine_mode mem_mode
,
13301 enum var_init_status initialized
)
13303 dw_loc_descr_ref mem_loc_result
= NULL
;
13304 enum dwarf_location_atom op
;
13305 dw_loc_descr_ref op0
, op1
;
13306 rtx inner
= NULL_RTX
;
13308 if (mode
== VOIDmode
)
13309 mode
= GET_MODE (rtl
);
13311 /* Note that for a dynamically sized array, the location we will generate a
13312 description of here will be the lowest numbered location which is
13313 actually within the array. That's *not* necessarily the same as the
13314 zeroth element of the array. */
13316 rtl
= targetm
.delegitimize_address (rtl
);
13318 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
13321 switch (GET_CODE (rtl
))
13326 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
13329 /* The case of a subreg may arise when we have a local (register)
13330 variable or a formal (register) parameter which doesn't quite fill
13331 up an entire register. For now, just assume that it is
13332 legitimate to make the Dwarf info refer to the whole register which
13333 contains the given subreg. */
13334 if (!subreg_lowpart_p (rtl
))
13336 inner
= SUBREG_REG (rtl
);
13338 if (inner
== NULL_RTX
)
13339 inner
= XEXP (rtl
, 0);
13340 if (SCALAR_INT_MODE_P (mode
)
13341 && SCALAR_INT_MODE_P (GET_MODE (inner
))
13342 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
13343 #ifdef POINTERS_EXTEND_UNSIGNED
13344 || (mode
== Pmode
&& mem_mode
!= VOIDmode
)
13347 && GET_MODE_SIZE (GET_MODE (inner
)) <= DWARF2_ADDR_SIZE
)
13349 mem_loc_result
= mem_loc_descriptor (inner
,
13351 mem_mode
, initialized
);
13356 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (inner
)))
13358 if (GET_MODE_SIZE (mode
) != GET_MODE_SIZE (GET_MODE (inner
))
13359 && (!SCALAR_INT_MODE_P (mode
)
13360 || !SCALAR_INT_MODE_P (GET_MODE (inner
))))
13364 dw_die_ref type_die
;
13365 dw_loc_descr_ref cvt
;
13367 mem_loc_result
= mem_loc_descriptor (inner
,
13369 mem_mode
, initialized
);
13370 if (mem_loc_result
== NULL
)
13372 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
13373 if (type_die
== NULL
)
13375 mem_loc_result
= NULL
;
13378 if (GET_MODE_SIZE (mode
)
13379 != GET_MODE_SIZE (GET_MODE (inner
)))
13380 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13382 cvt
= new_loc_descr (DW_OP_GNU_reinterpret
, 0, 0);
13383 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13384 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13385 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13386 add_loc_descr (&mem_loc_result
, cvt
);
13387 if (SCALAR_INT_MODE_P (mode
)
13388 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
13390 /* Convert it to untyped afterwards. */
13391 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13392 add_loc_descr (&mem_loc_result
, cvt
);
13398 if (! SCALAR_INT_MODE_P (mode
)
13399 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
13400 && rtl
!= arg_pointer_rtx
13401 && rtl
!= frame_pointer_rtx
13402 #ifdef POINTERS_EXTEND_UNSIGNED
13403 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
13407 dw_die_ref type_die
;
13408 unsigned int dbx_regnum
;
13412 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
13414 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
13415 if (type_die
== NULL
)
13418 dbx_regnum
= dbx_reg_number (rtl
);
13419 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
13421 mem_loc_result
= new_loc_descr (DW_OP_GNU_regval_type
,
13423 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
13424 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
13425 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
13428 /* Whenever a register number forms a part of the description of the
13429 method for calculating the (dynamic) address of a memory resident
13430 object, DWARF rules require the register number be referred to as
13431 a "base register". This distinction is not based in any way upon
13432 what category of register the hardware believes the given register
13433 belongs to. This is strictly DWARF terminology we're dealing with
13434 here. Note that in cases where the location of a memory-resident
13435 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
13436 OP_CONST (0)) the actual DWARF location descriptor that we generate
13437 may just be OP_BASEREG (basereg). This may look deceptively like
13438 the object in question was allocated to a register (rather than in
13439 memory) so DWARF consumers need to be aware of the subtle
13440 distinction between OP_REG and OP_BASEREG. */
13441 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
13442 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
13443 else if (stack_realign_drap
13445 && crtl
->args
.internal_arg_pointer
== rtl
13446 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
13448 /* If RTL is internal_arg_pointer, which has been optimized
13449 out, use DRAP instead. */
13450 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
13451 VAR_INIT_STATUS_INITIALIZED
);
13457 if (!SCALAR_INT_MODE_P (mode
))
13459 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
13460 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13463 else if (GET_CODE (rtl
) == ZERO_EXTEND
13464 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
13465 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
13466 < HOST_BITS_PER_WIDE_INT
13467 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
13468 to expand zero extend as two shifts instead of
13470 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= 4)
13472 machine_mode imode
= GET_MODE (XEXP (rtl
, 0));
13473 mem_loc_result
= op0
;
13474 add_loc_descr (&mem_loc_result
,
13475 int_loc_descriptor (GET_MODE_MASK (imode
)));
13476 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
13478 else if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
13480 int shift
= DWARF2_ADDR_SIZE
13481 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
13482 shift
*= BITS_PER_UNIT
;
13483 if (GET_CODE (rtl
) == SIGN_EXTEND
)
13487 mem_loc_result
= op0
;
13488 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
13489 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
13490 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
13491 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13493 else if (!dwarf_strict
)
13495 dw_die_ref type_die1
, type_die2
;
13496 dw_loc_descr_ref cvt
;
13498 type_die1
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
13499 GET_CODE (rtl
) == ZERO_EXTEND
);
13500 if (type_die1
== NULL
)
13502 type_die2
= base_type_for_mode (mode
, 1);
13503 if (type_die2
== NULL
)
13505 mem_loc_result
= op0
;
13506 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13507 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13508 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
13509 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13510 add_loc_descr (&mem_loc_result
, cvt
);
13511 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13512 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13513 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
13514 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13515 add_loc_descr (&mem_loc_result
, cvt
);
13521 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
13522 if (new_rtl
!= rtl
)
13524 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
13526 if (mem_loc_result
!= NULL
)
13527 return mem_loc_result
;
13530 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
13531 get_address_mode (rtl
), mode
,
13532 VAR_INIT_STATUS_INITIALIZED
);
13533 if (mem_loc_result
== NULL
)
13534 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
13535 if (mem_loc_result
!= NULL
)
13537 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
13538 || !SCALAR_INT_MODE_P(mode
))
13540 dw_die_ref type_die
;
13541 dw_loc_descr_ref deref
;
13546 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
13547 if (type_die
== NULL
)
13549 deref
= new_loc_descr (DW_OP_GNU_deref_type
,
13550 GET_MODE_SIZE (mode
), 0);
13551 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
13552 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
13553 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
13554 add_loc_descr (&mem_loc_result
, deref
);
13556 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
13557 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
13559 add_loc_descr (&mem_loc_result
,
13560 new_loc_descr (DW_OP_deref_size
,
13561 GET_MODE_SIZE (mode
), 0));
13566 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
13569 /* Some ports can transform a symbol ref into a label ref, because
13570 the symbol ref is too far away and has to be dumped into a constant
13574 if (!SCALAR_INT_MODE_P (mode
)
13575 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
13576 #ifdef POINTERS_EXTEND_UNSIGNED
13577 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
13581 if (GET_CODE (rtl
) == SYMBOL_REF
13582 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
13584 dw_loc_descr_ref temp
;
13586 /* If this is not defined, we have no way to emit the data. */
13587 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
13590 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
13592 mem_loc_result
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
13593 add_loc_descr (&mem_loc_result
, temp
);
13598 if (!const_ok_for_output (rtl
))
13600 if (GET_CODE (rtl
) == CONST
)
13601 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13607 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
13608 vec_safe_push (used_rtx_array
, rtl
);
13614 case DEBUG_IMPLICIT_PTR
:
13615 expansion_failed (NULL_TREE
, rtl
,
13616 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
13622 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
13624 if (!SCALAR_INT_MODE_P (mode
)
13625 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
13626 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
13627 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13630 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
13631 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
13633 op0
= one_reg_loc_descriptor (dbx_regnum
,
13634 VAR_INIT_STATUS_INITIALIZED
);
13637 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
13638 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
13640 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
13641 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13642 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
13646 gcc_unreachable ();
13649 mem_loc_result
= new_loc_descr (DW_OP_GNU_entry_value
, 0, 0);
13650 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13651 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
13654 case DEBUG_PARAMETER_REF
:
13655 mem_loc_result
= parameter_ref_descriptor (rtl
);
13659 /* Extract the PLUS expression nested inside and fall into
13660 PLUS code below. */
13661 rtl
= XEXP (rtl
, 1);
13666 /* Turn these into a PLUS expression and fall into the PLUS code
13668 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
13669 gen_int_mode (GET_CODE (rtl
) == PRE_INC
13670 ? GET_MODE_UNIT_SIZE (mem_mode
)
13671 : -GET_MODE_UNIT_SIZE (mem_mode
),
13674 /* ... fall through ... */
13678 if (is_based_loc (rtl
)
13679 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
13680 || XEXP (rtl
, 0) == arg_pointer_rtx
13681 || XEXP (rtl
, 0) == frame_pointer_rtx
)
13682 && SCALAR_INT_MODE_P (mode
))
13683 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
13684 INTVAL (XEXP (rtl
, 1)),
13685 VAR_INIT_STATUS_INITIALIZED
);
13688 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13689 VAR_INIT_STATUS_INITIALIZED
);
13690 if (mem_loc_result
== 0)
13693 if (CONST_INT_P (XEXP (rtl
, 1))
13694 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
13695 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
13698 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
13699 VAR_INIT_STATUS_INITIALIZED
);
13702 add_loc_descr (&mem_loc_result
, op1
);
13703 add_loc_descr (&mem_loc_result
,
13704 new_loc_descr (DW_OP_plus
, 0, 0));
13709 /* If a pseudo-reg is optimized away, it is possible for it to
13710 be replaced with a MEM containing a multiply or shift. */
13721 && SCALAR_INT_MODE_P (mode
)
13722 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
13724 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
13725 base_type_for_mode (mode
, 0),
13749 if (!SCALAR_INT_MODE_P (mode
))
13751 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13752 VAR_INIT_STATUS_INITIALIZED
);
13754 rtx rtlop1
= XEXP (rtl
, 1);
13755 if (GET_MODE (rtlop1
) != VOIDmode
13756 && GET_MODE_BITSIZE (GET_MODE (rtlop1
))
13757 < GET_MODE_BITSIZE (mode
))
13758 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
13759 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
13760 VAR_INIT_STATUS_INITIALIZED
);
13763 if (op0
== 0 || op1
== 0)
13766 mem_loc_result
= op0
;
13767 add_loc_descr (&mem_loc_result
, op1
);
13768 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13784 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13785 VAR_INIT_STATUS_INITIALIZED
);
13786 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
13787 VAR_INIT_STATUS_INITIALIZED
);
13789 if (op0
== 0 || op1
== 0)
13792 mem_loc_result
= op0
;
13793 add_loc_descr (&mem_loc_result
, op1
);
13794 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13798 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
&& !dwarf_strict
)
13800 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
13801 base_type_for_mode (mode
, 0),
13806 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13807 VAR_INIT_STATUS_INITIALIZED
);
13808 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
13809 VAR_INIT_STATUS_INITIALIZED
);
13811 if (op0
== 0 || op1
== 0)
13814 mem_loc_result
= op0
;
13815 add_loc_descr (&mem_loc_result
, op1
);
13816 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
13817 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
13818 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
13819 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
13820 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
13824 if (!dwarf_strict
&& SCALAR_INT_MODE_P (mode
))
13826 if (GET_MODE_CLASS (mode
) > DWARF2_ADDR_SIZE
)
13831 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
13832 base_type_for_mode (mode
, 1),
13850 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
13851 VAR_INIT_STATUS_INITIALIZED
);
13856 mem_loc_result
= op0
;
13857 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13861 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
13862 #ifdef POINTERS_EXTEND_UNSIGNED
13864 && mem_mode
!= VOIDmode
13865 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
13869 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
13873 && (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
13874 || GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_DOUBLE_INT
))
13876 dw_die_ref type_die
= base_type_for_mode (mode
, 1);
13877 machine_mode amode
;
13878 if (type_die
== NULL
)
13880 amode
= mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
,
13882 if (INTVAL (rtl
) >= 0
13883 && amode
!= BLKmode
13884 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
13885 /* const DW_OP_GNU_convert <XXX> vs.
13886 DW_OP_GNU_const_type <XXX, 1, const>. */
13887 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
13888 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode
))
13890 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
13891 op0
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13892 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13893 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13894 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13895 add_loc_descr (&mem_loc_result
, op0
);
13896 return mem_loc_result
;
13898 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0,
13900 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13901 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13902 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13903 if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
13904 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13907 mem_loc_result
->dw_loc_oprnd2
.val_class
13908 = dw_val_class_const_double
;
13909 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
13910 = double_int::from_shwi (INTVAL (rtl
));
13918 dw_die_ref type_die
;
13920 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
13921 CONST_DOUBLE rtx could represent either a large integer
13922 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
13923 the value is always a floating point constant.
13925 When it is an integer, a CONST_DOUBLE is used whenever
13926 the constant requires 2 HWIs to be adequately represented.
13927 We output CONST_DOUBLEs as blocks. */
13928 if (mode
== VOIDmode
13929 || (GET_MODE (rtl
) == VOIDmode
13930 && GET_MODE_BITSIZE (mode
) != HOST_BITS_PER_DOUBLE_INT
))
13932 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
13933 if (type_die
== NULL
)
13935 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
13936 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13937 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13938 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13939 #if TARGET_SUPPORTS_WIDE_INT == 0
13940 if (!SCALAR_FLOAT_MODE_P (mode
))
13942 mem_loc_result
->dw_loc_oprnd2
.val_class
13943 = dw_val_class_const_double
;
13944 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
13945 = rtx_to_double_int (rtl
);
13950 unsigned int length
= GET_MODE_SIZE (mode
);
13951 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
13953 insert_float (rtl
, array
);
13954 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13955 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
13956 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
13957 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13962 case CONST_WIDE_INT
:
13965 dw_die_ref type_die
;
13967 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
13968 if (type_die
== NULL
)
13970 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
13971 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13972 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13973 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13974 mem_loc_result
->dw_loc_oprnd2
.val_class
13975 = dw_val_class_wide_int
;
13976 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
13977 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= std::make_pair (rtl
, mode
);
13982 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
13986 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
13990 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
13994 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
13998 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
14002 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
14006 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
14010 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
14014 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
14018 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
14023 if (!SCALAR_INT_MODE_P (mode
))
14028 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
14033 if (CONST_INT_P (XEXP (rtl
, 1))
14034 && CONST_INT_P (XEXP (rtl
, 2))
14035 && ((unsigned) INTVAL (XEXP (rtl
, 1))
14036 + (unsigned) INTVAL (XEXP (rtl
, 2))
14037 <= GET_MODE_BITSIZE (mode
))
14038 && SCALAR_INT_MODE_P (mode
)
14039 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
14040 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
14043 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
14044 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
14047 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
14051 mem_loc_result
= op0
;
14052 size
= INTVAL (XEXP (rtl
, 1));
14053 shift
= INTVAL (XEXP (rtl
, 2));
14054 if (BITS_BIG_ENDIAN
)
14055 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
14057 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
14059 add_loc_descr (&mem_loc_result
,
14060 int_loc_descriptor (DWARF2_ADDR_SIZE
14062 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
14064 if (size
!= (int) DWARF2_ADDR_SIZE
)
14066 add_loc_descr (&mem_loc_result
,
14067 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
14068 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
14075 dw_loc_descr_ref op2
, bra_node
, drop_node
;
14076 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
14077 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
14078 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
14079 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
14080 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14081 VAR_INIT_STATUS_INITIALIZED
);
14082 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
14083 VAR_INIT_STATUS_INITIALIZED
);
14084 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
14087 mem_loc_result
= op1
;
14088 add_loc_descr (&mem_loc_result
, op2
);
14089 add_loc_descr (&mem_loc_result
, op0
);
14090 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14091 add_loc_descr (&mem_loc_result
, bra_node
);
14092 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
14093 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
14094 add_loc_descr (&mem_loc_result
, drop_node
);
14095 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14096 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
14101 case FLOAT_TRUNCATE
:
14103 case UNSIGNED_FLOAT
:
14108 dw_die_ref type_die
;
14109 dw_loc_descr_ref cvt
;
14111 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
14112 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
14115 if (SCALAR_INT_MODE_P (GET_MODE (XEXP (rtl
, 0)))
14116 && (GET_CODE (rtl
) == FLOAT
14117 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)))
14118 <= DWARF2_ADDR_SIZE
))
14120 type_die
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
14121 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
14122 if (type_die
== NULL
)
14124 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
14125 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14126 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14127 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14128 add_loc_descr (&op0
, cvt
);
14130 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
14131 if (type_die
== NULL
)
14133 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
14134 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14135 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14136 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14137 add_loc_descr (&op0
, cvt
);
14138 if (SCALAR_INT_MODE_P (mode
)
14139 && (GET_CODE (rtl
) == FIX
14140 || GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
))
14142 op0
= convert_descriptor_to_mode (mode
, op0
);
14146 mem_loc_result
= op0
;
14153 mem_loc_result
= clz_loc_descriptor (rtl
, mode
, mem_mode
);
14158 mem_loc_result
= popcount_loc_descriptor (rtl
, mode
, mem_mode
);
14162 mem_loc_result
= bswap_loc_descriptor (rtl
, mode
, mem_mode
);
14167 mem_loc_result
= rotate_loc_descriptor (rtl
, mode
, mem_mode
);
14171 /* In theory, we could implement the above. */
14172 /* DWARF cannot represent the unsigned compare operations
14197 case FRACT_CONVERT
:
14198 case UNSIGNED_FRACT_CONVERT
:
14200 case UNSIGNED_SAT_FRACT
:
14206 case VEC_DUPLICATE
:
14210 case STRICT_LOW_PART
:
14215 /* If delegitimize_address couldn't do anything with the UNSPEC, we
14216 can't express it in the debug info. This can happen e.g. with some
14221 resolve_one_addr (&rtl
);
14227 print_rtl (stderr
, rtl
);
14228 gcc_unreachable ();
14233 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14234 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14236 return mem_loc_result
;
14239 /* Return a descriptor that describes the concatenation of two locations.
14240 This is typically a complex variable. */
14242 static dw_loc_descr_ref
14243 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
14245 dw_loc_descr_ref cc_loc_result
= NULL
;
14246 dw_loc_descr_ref x0_ref
14247 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
14248 dw_loc_descr_ref x1_ref
14249 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
14251 if (x0_ref
== 0 || x1_ref
== 0)
14254 cc_loc_result
= x0_ref
;
14255 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
14257 add_loc_descr (&cc_loc_result
, x1_ref
);
14258 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
14260 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14261 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14263 return cc_loc_result
;
14266 /* Return a descriptor that describes the concatenation of N
14269 static dw_loc_descr_ref
14270 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
14273 dw_loc_descr_ref cc_loc_result
= NULL
;
14274 unsigned int n
= XVECLEN (concatn
, 0);
14276 for (i
= 0; i
< n
; ++i
)
14278 dw_loc_descr_ref ref
;
14279 rtx x
= XVECEXP (concatn
, 0, i
);
14281 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
14285 add_loc_descr (&cc_loc_result
, ref
);
14286 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
14289 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14290 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14292 return cc_loc_result
;
14295 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
14296 for DEBUG_IMPLICIT_PTR RTL. */
14298 static dw_loc_descr_ref
14299 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
14301 dw_loc_descr_ref ret
;
14306 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
14307 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
14308 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
14309 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
14310 ret
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
14311 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
14314 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14315 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
14316 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14320 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
14321 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
14326 /* Output a proper Dwarf location descriptor for a variable or parameter
14327 which is either allocated in a register or in a memory location. For a
14328 register, we just generate an OP_REG and the register number. For a
14329 memory location we provide a Dwarf postfix expression describing how to
14330 generate the (dynamic) address of the object onto the address stack.
14332 MODE is mode of the decl if this loc_descriptor is going to be used in
14333 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
14334 allowed, VOIDmode otherwise.
14336 If we don't know how to describe it, return 0. */
14338 static dw_loc_descr_ref
14339 loc_descriptor (rtx rtl
, machine_mode mode
,
14340 enum var_init_status initialized
)
14342 dw_loc_descr_ref loc_result
= NULL
;
14344 switch (GET_CODE (rtl
))
14347 /* The case of a subreg may arise when we have a local (register)
14348 variable or a formal (register) parameter which doesn't quite fill
14349 up an entire register. For now, just assume that it is
14350 legitimate to make the Dwarf info refer to the whole register which
14351 contains the given subreg. */
14352 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
14353 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
14354 GET_MODE (SUBREG_REG (rtl
)), initialized
);
14360 loc_result
= reg_loc_descriptor (rtl
, initialized
);
14364 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
14365 GET_MODE (rtl
), initialized
);
14366 if (loc_result
== NULL
)
14367 loc_result
= tls_mem_loc_descriptor (rtl
);
14368 if (loc_result
== NULL
)
14370 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
14371 if (new_rtl
!= rtl
)
14372 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
14377 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
14382 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
14387 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
14389 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
14390 if (GET_CODE (loc
) == EXPR_LIST
)
14391 loc
= XEXP (loc
, 0);
14392 loc_result
= loc_descriptor (loc
, mode
, initialized
);
14396 rtl
= XEXP (rtl
, 1);
14401 rtvec par_elems
= XVEC (rtl
, 0);
14402 int num_elem
= GET_NUM_ELEM (par_elems
);
14406 /* Create the first one, so we have something to add to. */
14407 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
14408 VOIDmode
, initialized
);
14409 if (loc_result
== NULL
)
14411 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
14412 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
14413 for (i
= 1; i
< num_elem
; i
++)
14415 dw_loc_descr_ref temp
;
14417 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
14418 VOIDmode
, initialized
);
14421 add_loc_descr (&loc_result
, temp
);
14422 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
14423 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
14429 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
14430 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
14435 if (mode
== VOIDmode
)
14436 mode
= GET_MODE (rtl
);
14438 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
14440 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
14442 /* Note that a CONST_DOUBLE rtx could represent either an integer
14443 or a floating-point constant. A CONST_DOUBLE is used whenever
14444 the constant requires more than one word in order to be
14445 adequately represented. We output CONST_DOUBLEs as blocks. */
14446 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14447 GET_MODE_SIZE (mode
), 0);
14448 #if TARGET_SUPPORTS_WIDE_INT == 0
14449 if (!SCALAR_FLOAT_MODE_P (mode
))
14451 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
14452 loc_result
->dw_loc_oprnd2
.v
.val_double
14453 = rtx_to_double_int (rtl
);
14458 unsigned int length
= GET_MODE_SIZE (mode
);
14459 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
14461 insert_float (rtl
, array
);
14462 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
14463 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
14464 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
14465 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
14470 case CONST_WIDE_INT
:
14471 if (mode
== VOIDmode
)
14472 mode
= GET_MODE (rtl
);
14474 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
14476 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14477 GET_MODE_SIZE (mode
), 0);
14478 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
14479 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
14480 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= std::make_pair (rtl
, mode
);
14485 if (mode
== VOIDmode
)
14486 mode
= GET_MODE (rtl
);
14488 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
14490 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
14491 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
14492 unsigned char *array
14493 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
14496 machine_mode imode
= GET_MODE_INNER (mode
);
14498 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
14499 switch (GET_MODE_CLASS (mode
))
14501 case MODE_VECTOR_INT
:
14502 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
14504 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
14505 insert_wide_int (std::make_pair (elt
, imode
), p
, elt_size
);
14509 case MODE_VECTOR_FLOAT
:
14510 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
14512 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
14513 insert_float (elt
, p
);
14518 gcc_unreachable ();
14521 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14522 length
* elt_size
, 0);
14523 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
14524 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
14525 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
14526 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
14531 if (mode
== VOIDmode
14532 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
14533 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
14534 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
14536 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
14541 if (!const_ok_for_output (rtl
))
14544 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
14545 && (dwarf_version
>= 4 || !dwarf_strict
))
14547 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
14548 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14549 vec_safe_push (used_rtx_array
, rtl
);
14553 case DEBUG_IMPLICIT_PTR
:
14554 loc_result
= implicit_ptr_descriptor (rtl
, 0);
14558 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
14559 && CONST_INT_P (XEXP (rtl
, 1)))
14562 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
14568 if ((SCALAR_INT_MODE_P (mode
)
14569 && GET_MODE (rtl
) == mode
14570 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
14571 && dwarf_version
>= 4)
14572 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
14574 /* Value expression. */
14575 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
14577 add_loc_descr (&loc_result
,
14578 new_loc_descr (DW_OP_stack_value
, 0, 0));
14586 /* We need to figure out what section we should use as the base for the
14587 address ranges where a given location is valid.
14588 1. If this particular DECL has a section associated with it, use that.
14589 2. If this function has a section associated with it, use that.
14590 3. Otherwise, use the text section.
14591 XXX: If you split a variable across multiple sections, we won't notice. */
14593 static const char *
14594 secname_for_decl (const_tree decl
)
14596 const char *secname
;
14598 if (VAR_OR_FUNCTION_DECL_P (decl
)
14599 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
14600 && DECL_SECTION_NAME (decl
))
14601 secname
= DECL_SECTION_NAME (decl
);
14602 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
14603 secname
= DECL_SECTION_NAME (current_function_decl
);
14604 else if (cfun
&& in_cold_section_p
)
14605 secname
= crtl
->subsections
.cold_section_label
;
14607 secname
= text_section_label
;
14612 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
14615 decl_by_reference_p (tree decl
)
14617 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
14618 || TREE_CODE (decl
) == VAR_DECL
)
14619 && DECL_BY_REFERENCE (decl
));
14622 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
14625 static dw_loc_descr_ref
14626 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
14627 enum var_init_status initialized
)
14629 int have_address
= 0;
14630 dw_loc_descr_ref descr
;
14633 if (want_address
!= 2)
14635 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
14637 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
14639 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
14640 if (GET_CODE (varloc
) == EXPR_LIST
)
14641 varloc
= XEXP (varloc
, 0);
14642 mode
= GET_MODE (varloc
);
14643 if (MEM_P (varloc
))
14645 rtx addr
= XEXP (varloc
, 0);
14646 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
14647 mode
, initialized
);
14652 rtx x
= avoid_constant_pool_reference (varloc
);
14654 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
14659 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
14666 if (GET_CODE (varloc
) == VAR_LOCATION
)
14667 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
14669 mode
= DECL_MODE (loc
);
14670 descr
= loc_descriptor (varloc
, mode
, initialized
);
14677 if (want_address
== 2 && !have_address
14678 && (dwarf_version
>= 4 || !dwarf_strict
))
14680 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
14682 expansion_failed (loc
, NULL_RTX
,
14683 "DWARF address size mismatch");
14686 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14689 /* Show if we can't fill the request for an address. */
14690 if (want_address
&& !have_address
)
14692 expansion_failed (loc
, NULL_RTX
,
14693 "Want address and only have value");
14697 /* If we've got an address and don't want one, dereference. */
14698 if (!want_address
&& have_address
)
14700 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
14701 enum dwarf_location_atom op
;
14703 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
14705 expansion_failed (loc
, NULL_RTX
,
14706 "DWARF address size mismatch");
14709 else if (size
== DWARF2_ADDR_SIZE
)
14712 op
= DW_OP_deref_size
;
14714 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
14720 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
14721 if it is not possible. */
14723 static dw_loc_descr_ref
14724 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
14726 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
14727 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
14728 else if (dwarf_version
>= 3 || !dwarf_strict
)
14729 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
14734 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
14735 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
14737 static dw_loc_descr_ref
14738 dw_sra_loc_expr (tree decl
, rtx loc
)
14741 unsigned HOST_WIDE_INT padsize
= 0;
14742 dw_loc_descr_ref descr
, *descr_tail
;
14743 unsigned HOST_WIDE_INT decl_size
;
14745 enum var_init_status initialized
;
14747 if (DECL_SIZE (decl
) == NULL
14748 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
14751 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
14753 descr_tail
= &descr
;
14755 for (p
= loc
; p
; p
= XEXP (p
, 1))
14757 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
14758 rtx loc_note
= *decl_piece_varloc_ptr (p
);
14759 dw_loc_descr_ref cur_descr
;
14760 dw_loc_descr_ref
*tail
, last
= NULL
;
14761 unsigned HOST_WIDE_INT opsize
= 0;
14763 if (loc_note
== NULL_RTX
14764 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
14766 padsize
+= bitsize
;
14769 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
14770 varloc
= NOTE_VAR_LOCATION (loc_note
);
14771 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
14772 if (cur_descr
== NULL
)
14774 padsize
+= bitsize
;
14778 /* Check that cur_descr either doesn't use
14779 DW_OP_*piece operations, or their sum is equal
14780 to bitsize. Otherwise we can't embed it. */
14781 for (tail
= &cur_descr
; *tail
!= NULL
;
14782 tail
= &(*tail
)->dw_loc_next
)
14783 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
14785 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
14789 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
14791 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
14795 if (last
!= NULL
&& opsize
!= bitsize
)
14797 padsize
+= bitsize
;
14798 /* Discard the current piece of the descriptor and release any
14799 addr_table entries it uses. */
14800 remove_loc_list_addr_table_entries (cur_descr
);
14804 /* If there is a hole, add DW_OP_*piece after empty DWARF
14805 expression, which means that those bits are optimized out. */
14808 if (padsize
> decl_size
)
14810 remove_loc_list_addr_table_entries (cur_descr
);
14811 goto discard_descr
;
14813 decl_size
-= padsize
;
14814 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
14815 if (*descr_tail
== NULL
)
14817 remove_loc_list_addr_table_entries (cur_descr
);
14818 goto discard_descr
;
14820 descr_tail
= &(*descr_tail
)->dw_loc_next
;
14823 *descr_tail
= cur_descr
;
14825 if (bitsize
> decl_size
)
14826 goto discard_descr
;
14827 decl_size
-= bitsize
;
14830 HOST_WIDE_INT offset
= 0;
14831 if (GET_CODE (varloc
) == VAR_LOCATION
14832 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
14834 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
14835 if (GET_CODE (varloc
) == EXPR_LIST
)
14836 varloc
= XEXP (varloc
, 0);
14840 if (GET_CODE (varloc
) == CONST
14841 || GET_CODE (varloc
) == SIGN_EXTEND
14842 || GET_CODE (varloc
) == ZERO_EXTEND
)
14843 varloc
= XEXP (varloc
, 0);
14844 else if (GET_CODE (varloc
) == SUBREG
)
14845 varloc
= SUBREG_REG (varloc
);
14850 /* DW_OP_bit_size offset should be zero for register
14851 or implicit location descriptions and empty location
14852 descriptions, but for memory addresses needs big endian
14854 if (MEM_P (varloc
))
14856 unsigned HOST_WIDE_INT memsize
14857 = MEM_SIZE (varloc
) * BITS_PER_UNIT
;
14858 if (memsize
!= bitsize
)
14860 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
14861 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
14862 goto discard_descr
;
14863 if (memsize
< bitsize
)
14864 goto discard_descr
;
14865 if (BITS_BIG_ENDIAN
)
14866 offset
= memsize
- bitsize
;
14870 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
14871 if (*descr_tail
== NULL
)
14872 goto discard_descr
;
14873 descr_tail
= &(*descr_tail
)->dw_loc_next
;
14877 /* If there were any non-empty expressions, add padding till the end of
14879 if (descr
!= NULL
&& decl_size
!= 0)
14881 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
14882 if (*descr_tail
== NULL
)
14883 goto discard_descr
;
14888 /* Discard the descriptor and release any addr_table entries it uses. */
14889 remove_loc_list_addr_table_entries (descr
);
14893 /* Return the dwarf representation of the location list LOC_LIST of
14894 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
14897 static dw_loc_list_ref
14898 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
14900 const char *endname
, *secname
;
14902 enum var_init_status initialized
;
14903 struct var_loc_node
*node
;
14904 dw_loc_descr_ref descr
;
14905 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
14906 dw_loc_list_ref list
= NULL
;
14907 dw_loc_list_ref
*listp
= &list
;
14909 /* Now that we know what section we are using for a base,
14910 actually construct the list of locations.
14911 The first location information is what is passed to the
14912 function that creates the location list, and the remaining
14913 locations just get added on to that list.
14914 Note that we only know the start address for a location
14915 (IE location changes), so to build the range, we use
14916 the range [current location start, next location start].
14917 This means we have to special case the last node, and generate
14918 a range of [last location start, end of function label]. */
14920 secname
= secname_for_decl (decl
);
14922 for (node
= loc_list
->first
; node
; node
= node
->next
)
14923 if (GET_CODE (node
->loc
) == EXPR_LIST
14924 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
14926 if (GET_CODE (node
->loc
) == EXPR_LIST
)
14928 /* This requires DW_OP_{,bit_}piece, which is not usable
14929 inside DWARF expressions. */
14930 if (want_address
!= 2)
14932 descr
= dw_sra_loc_expr (decl
, node
->loc
);
14938 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
14939 varloc
= NOTE_VAR_LOCATION (node
->loc
);
14940 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
14944 bool range_across_switch
= false;
14945 /* If section switch happens in between node->label
14946 and node->next->label (or end of function) and
14947 we can't emit it as a single entry list,
14948 emit two ranges, first one ending at the end
14949 of first partition and second one starting at the
14950 beginning of second partition. */
14951 if (node
== loc_list
->last_before_switch
14952 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
14953 && current_function_decl
)
14955 endname
= cfun
->fde
->dw_fde_end
;
14956 range_across_switch
= true;
14958 /* The variable has a location between NODE->LABEL and
14959 NODE->NEXT->LABEL. */
14960 else if (node
->next
)
14961 endname
= node
->next
->label
;
14962 /* If the variable has a location at the last label
14963 it keeps its location until the end of function. */
14964 else if (!current_function_decl
)
14965 endname
= text_end_label
;
14968 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
14969 current_function_funcdef_no
);
14970 endname
= ggc_strdup (label_id
);
14973 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
14974 if (TREE_CODE (decl
) == PARM_DECL
14975 && node
== loc_list
->first
14976 && NOTE_P (node
->loc
)
14977 && strcmp (node
->label
, endname
) == 0)
14978 (*listp
)->force
= true;
14979 listp
= &(*listp
)->dw_loc_next
;
14981 if (range_across_switch
)
14983 if (GET_CODE (node
->loc
) == EXPR_LIST
)
14984 descr
= dw_sra_loc_expr (decl
, node
->loc
);
14987 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
14988 varloc
= NOTE_VAR_LOCATION (node
->loc
);
14989 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
14992 gcc_assert (descr
);
14993 /* The variable has a location between NODE->LABEL and
14994 NODE->NEXT->LABEL. */
14996 endname
= node
->next
->label
;
14998 endname
= cfun
->fde
->dw_fde_second_end
;
14999 *listp
= new_loc_list (descr
,
15000 cfun
->fde
->dw_fde_second_begin
,
15002 listp
= &(*listp
)->dw_loc_next
;
15007 /* Try to avoid the overhead of a location list emitting a location
15008 expression instead, but only if we didn't have more than one
15009 location entry in the first place. If some entries were not
15010 representable, we don't want to pretend a single entry that was
15011 applies to the entire scope in which the variable is
15013 if (list
&& loc_list
->first
->next
)
15019 /* Return if the loc_list has only single element and thus can be represented
15020 as location description. */
15023 single_element_loc_list_p (dw_loc_list_ref list
)
15025 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
15026 return !list
->ll_symbol
;
15029 /* To each location in list LIST add loc descr REF. */
15032 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
15034 dw_loc_descr_ref copy
;
15035 add_loc_descr (&list
->expr
, ref
);
15036 list
= list
->dw_loc_next
;
15039 copy
= ggc_alloc
<dw_loc_descr_node
> ();
15040 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
15041 add_loc_descr (&list
->expr
, copy
);
15042 while (copy
->dw_loc_next
)
15044 dw_loc_descr_ref new_copy
= ggc_alloc
<dw_loc_descr_node
> ();
15045 memcpy (new_copy
, copy
->dw_loc_next
, sizeof (dw_loc_descr_node
));
15046 copy
->dw_loc_next
= new_copy
;
15049 list
= list
->dw_loc_next
;
15053 /* Given two lists RET and LIST
15054 produce location list that is result of adding expression in LIST
15055 to expression in RET on each position in program.
15056 Might be destructive on both RET and LIST.
15058 TODO: We handle only simple cases of RET or LIST having at most one
15059 element. General case would inolve sorting the lists in program order
15060 and merging them that will need some additional work.
15061 Adding that will improve quality of debug info especially for SRA-ed
15065 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
15074 if (!list
->dw_loc_next
)
15076 add_loc_descr_to_each (*ret
, list
->expr
);
15079 if (!(*ret
)->dw_loc_next
)
15081 add_loc_descr_to_each (list
, (*ret
)->expr
);
15085 expansion_failed (NULL_TREE
, NULL_RTX
,
15086 "Don't know how to merge two non-trivial"
15087 " location lists.\n");
15092 /* LOC is constant expression. Try a luck, look it up in constant
15093 pool and return its loc_descr of its address. */
15095 static dw_loc_descr_ref
15096 cst_pool_loc_descr (tree loc
)
15098 /* Get an RTL for this, if something has been emitted. */
15099 rtx rtl
= lookup_constant_def (loc
);
15101 if (!rtl
|| !MEM_P (rtl
))
15106 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
15108 /* TODO: We might get more coverage if we was actually delaying expansion
15109 of all expressions till end of compilation when constant pools are fully
15111 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
15113 expansion_failed (loc
, NULL_RTX
,
15114 "CST value in contant pool but not marked.");
15117 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
15118 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
15121 /* Return dw_loc_list representing address of addr_expr LOC
15122 by looking for inner INDIRECT_REF expression and turning
15123 it into simple arithmetics.
15125 See loc_list_from_tree for the meaning of CONTEXT. */
15127 static dw_loc_list_ref
15128 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
15129 const loc_descr_context
*context
)
15132 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
15134 int unsignedp
, reversep
, volatilep
= 0;
15135 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
15137 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
15138 &bitsize
, &bitpos
, &offset
, &mode
,
15139 &unsignedp
, &reversep
, &volatilep
);
15141 if (bitpos
% BITS_PER_UNIT
)
15143 expansion_failed (loc
, NULL_RTX
, "bitfield access");
15146 if (!INDIRECT_REF_P (obj
))
15148 expansion_failed (obj
,
15149 NULL_RTX
, "no indirect ref in inner refrence");
15152 if (!offset
&& !bitpos
)
15153 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
15156 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
15157 && (dwarf_version
>= 4 || !dwarf_strict
))
15159 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
15164 /* Variable offset. */
15165 list_ret1
= loc_list_from_tree (offset
, 0, context
);
15166 if (list_ret1
== 0)
15168 add_loc_list (&list_ret
, list_ret1
);
15171 add_loc_descr_to_each (list_ret
,
15172 new_loc_descr (DW_OP_plus
, 0, 0));
15174 bytepos
= bitpos
/ BITS_PER_UNIT
;
15176 add_loc_descr_to_each (list_ret
,
15177 new_loc_descr (DW_OP_plus_uconst
,
15179 else if (bytepos
< 0)
15180 loc_list_plus_const (list_ret
, bytepos
);
15181 add_loc_descr_to_each (list_ret
,
15182 new_loc_descr (DW_OP_stack_value
, 0, 0));
15187 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
15188 all operations from LOC are nops, move to the last one. Insert in NOPS all
15189 operations that are skipped. */
15192 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
15193 hash_set
<dw_loc_descr_ref
> &nops
)
15195 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
15198 loc
= loc
->dw_loc_next
;
15202 /* Helper for loc_descr_without_nops: free the location description operation
15206 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
15212 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
15216 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
15218 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
15221 /* Set of all DW_OP_nop operations we remove. */
15222 hash_set
<dw_loc_descr_ref
> nops
;
15224 /* First, strip all prefix NOP operations in order to keep the head of the
15225 operations list. */
15226 loc_descr_to_next_no_nop (loc
, nops
);
15228 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
15230 /* For control flow operations: strip "prefix" nops in destination
15232 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
15233 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
15234 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
15235 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
15237 /* Do the same for the operations that follow, then move to the next
15239 if (cur
->dw_loc_next
!= NULL
)
15240 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
15241 cur
= cur
->dw_loc_next
;
15244 nops
.traverse
<void *, free_loc_descr
> (NULL
);
15248 struct dwarf_procedure_info
;
15250 /* Helper structure for location descriptions generation. */
15251 struct loc_descr_context
15253 /* The type that is implicitly referenced by DW_OP_push_object_address, or
15254 NULL_TREE if DW_OP_push_object_address in invalid for this location
15255 description. This is used when processing PLACEHOLDER_EXPR nodes. */
15257 /* The ..._DECL node that should be translated as a
15258 DW_OP_push_object_address operation. */
15260 /* Information about the DWARF procedure we are currently generating. NULL if
15261 we are not generating a DWARF procedure. */
15262 struct dwarf_procedure_info
*dpi
;
15265 /* DWARF procedures generation
15267 DWARF expressions (aka. location descriptions) are used to encode variable
15268 things such as sizes or offsets. Such computations can have redundant parts
15269 that can be factorized in order to reduce the size of the output debug
15270 information. This is the whole point of DWARF procedures.
15272 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
15273 already factorized into functions ("size functions") in order to handle very
15274 big and complex types. Such functions are quite simple: they have integral
15275 arguments, they return an integral result and their body contains only a
15276 return statement with arithmetic expressions. This is the only kind of
15277 function we are interested in translating into DWARF procedures, here.
15279 DWARF expressions and DWARF procedure are executed using a stack, so we have
15280 to define some calling convention for them to interact. Let's say that:
15282 - Before calling a DWARF procedure, DWARF expressions must push on the stack
15283 all arguments in reverse order (right-to-left) so that when the DWARF
15284 procedure execution starts, the first argument is the top of the stack.
15286 - Then, when returning, the DWARF procedure must have consumed all arguments
15287 on the stack, must have pushed the result and touched nothing else.
15289 - Each integral argument and the result are integral types can be hold in a
15292 - We call "frame offset" the number of stack slots that are "under DWARF
15293 procedure control": it includes the arguments slots, the temporaries and
15294 the result slot. Thus, it is equal to the number of arguments when the
15295 procedure execution starts and must be equal to one (the result) when it
15298 /* Helper structure used when generating operations for a DWARF procedure. */
15299 struct dwarf_procedure_info
15301 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
15302 currently translated. */
15304 /* The number of arguments FNDECL takes. */
15305 unsigned args_count
;
15308 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
15309 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
15310 equate it to this DIE. */
15313 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
15314 dw_die_ref parent_die
)
15316 const bool dwarf_proc_supported
= dwarf_version
>= 4;
15317 dw_die_ref dwarf_proc_die
;
15319 if ((dwarf_version
< 3 && dwarf_strict
)
15320 || location
== NULL
)
15323 dwarf_proc_die
= new_die (dwarf_proc_supported
15324 ? DW_TAG_dwarf_procedure
15329 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
15330 if (!dwarf_proc_supported
)
15331 add_AT_flag (dwarf_proc_die
, DW_AT_artificial
, 1);
15332 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
15333 return dwarf_proc_die
;
15336 /* Return whether TYPE is a supported type as a DWARF procedure argument
15337 type or return type (we handle only scalar types and pointer types that
15338 aren't wider than the DWARF expression evaluation stack. */
15341 is_handled_procedure_type (tree type
)
15343 return ((INTEGRAL_TYPE_P (type
)
15344 || TREE_CODE (type
) == OFFSET_TYPE
15345 || TREE_CODE (type
) == POINTER_TYPE
)
15346 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
15349 /* Helper for resolve_args_picking: do the same but stop when coming across
15350 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
15351 offset *before* evaluating the corresponding operation. */
15354 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
15355 struct dwarf_procedure_info
*dpi
,
15356 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
15358 /* The "frame_offset" identifier is already used to name a macro... */
15359 unsigned frame_offset_
= initial_frame_offset
;
15360 dw_loc_descr_ref l
;
15362 for (l
= loc
; l
!= NULL
;)
15365 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
15367 /* If we already met this node, there is nothing to compute anymore. */
15370 /* Make sure that the stack size is consistent wherever the execution
15371 flow comes from. */
15372 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
15375 l_frame_offset
= frame_offset_
;
15377 /* If needed, relocate the picking offset with respect to the frame
15379 if (l
->dw_loc_opc
== DW_OP_pick
&& l
->frame_offset_rel
)
15381 /* frame_offset_ is the size of the current stack frame, including
15382 incoming arguments. Besides, the arguments are pushed
15383 right-to-left. Thus, in order to access the Nth argument from
15384 this operation node, the picking has to skip temporaries *plus*
15385 one stack slot per argument (0 for the first one, 1 for the second
15388 The targetted argument number (N) is already set as the operand,
15389 and the number of temporaries can be computed with:
15390 frame_offsets_ - dpi->args_count */
15391 l
->dw_loc_oprnd1
.v
.val_unsigned
+= frame_offset_
- dpi
->args_count
;
15393 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
15394 if (l
->dw_loc_oprnd1
.v
.val_unsigned
> 255)
15398 /* Update frame_offset according to the effect the current operation has
15400 switch (l
->dw_loc_opc
)
15408 case DW_OP_plus_uconst
:
15444 case DW_OP_deref_size
:
15446 case DW_OP_form_tls_address
:
15447 case DW_OP_bit_piece
:
15448 case DW_OP_implicit_value
:
15449 case DW_OP_stack_value
:
15453 case DW_OP_const1u
:
15454 case DW_OP_const1s
:
15455 case DW_OP_const2u
:
15456 case DW_OP_const2s
:
15457 case DW_OP_const4u
:
15458 case DW_OP_const4s
:
15459 case DW_OP_const8u
:
15460 case DW_OP_const8s
:
15531 case DW_OP_push_object_address
:
15532 case DW_OP_call_frame_cfa
:
15557 case DW_OP_xderef_size
:
15563 case DW_OP_call_ref
:
15565 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
15566 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
15568 if (stack_usage
== NULL
)
15570 frame_offset_
+= *stack_usage
;
15574 case DW_OP_GNU_push_tls_address
:
15575 case DW_OP_GNU_uninit
:
15576 case DW_OP_GNU_encoded_addr
:
15577 case DW_OP_GNU_implicit_pointer
:
15578 case DW_OP_GNU_entry_value
:
15579 case DW_OP_GNU_const_type
:
15580 case DW_OP_GNU_regval_type
:
15581 case DW_OP_GNU_deref_type
:
15582 case DW_OP_GNU_convert
:
15583 case DW_OP_GNU_reinterpret
:
15584 case DW_OP_GNU_parameter_ref
:
15585 /* loc_list_from_tree will probably not output these operations for
15586 size functions, so assume they will not appear here. */
15587 /* Fall through... */
15590 gcc_unreachable ();
15593 /* Now, follow the control flow (except subroutine calls). */
15594 switch (l
->dw_loc_opc
)
15597 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
15600 /* Fall through... */
15603 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
15606 case DW_OP_stack_value
:
15610 l
= l
->dw_loc_next
;
15618 /* Make a DFS over operations reachable through LOC (i.e. follow branch
15619 operations) in order to resolve the operand of DW_OP_pick operations that
15620 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
15621 offset *before* LOC is executed. Return if all relocations were
15625 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
15626 struct dwarf_procedure_info
*dpi
)
15628 /* Associate to all visited operations the frame offset *before* evaluating
15630 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
15632 return resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
,
15636 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
15637 Return NULL if it is not possible. */
15640 function_to_dwarf_procedure (tree fndecl
)
15642 struct loc_descr_context ctx
;
15643 struct dwarf_procedure_info dpi
;
15644 dw_die_ref dwarf_proc_die
;
15645 tree tree_body
= DECL_SAVED_TREE (fndecl
);
15646 dw_loc_descr_ref loc_body
, epilogue
;
15651 /* Do not generate multiple DWARF procedures for the same function
15653 dwarf_proc_die
= lookup_decl_die (fndecl
);
15654 if (dwarf_proc_die
!= NULL
)
15655 return dwarf_proc_die
;
15657 /* DWARF procedures are available starting with the DWARFv3 standard, but
15658 it's the DWARFv4 standard that introduces the DW_TAG_dwarf_procedure
15660 if (dwarf_version
< 3 && dwarf_strict
)
15663 /* We handle only functions for which we still have a body, that return a
15664 supported type and that takes arguments with supported types. Note that
15665 there is no point translating functions that return nothing. */
15666 if (tree_body
== NULL_TREE
15667 || DECL_RESULT (fndecl
) == NULL_TREE
15668 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
15671 for (cursor
= DECL_ARGUMENTS (fndecl
);
15672 cursor
!= NULL_TREE
;
15673 cursor
= TREE_CHAIN (cursor
))
15674 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
15677 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
15678 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
15680 tree_body
= TREE_OPERAND (tree_body
, 0);
15681 if (TREE_CODE (tree_body
) != MODIFY_EXPR
15682 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
15684 tree_body
= TREE_OPERAND (tree_body
, 1);
15686 /* Try to translate the body expression itself. Note that this will probably
15687 cause an infinite recursion if its call graph has a cycle. This is very
15688 unlikely for size functions, however, so don't bother with such things at
15690 ctx
.context_type
= NULL_TREE
;
15691 ctx
.base_decl
= NULL_TREE
;
15693 dpi
.fndecl
= fndecl
;
15694 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
15695 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
15699 /* After evaluating all operands in "loc_body", we should still have on the
15700 stack all arguments plus the desired function result (top of the stack).
15701 Generate code in order to keep only the result in our stack frame. */
15703 for (i
= 0; i
< dpi
.args_count
; ++i
)
15705 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
15706 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
15707 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
15708 epilogue
= op_couple
;
15710 add_loc_descr (&loc_body
, epilogue
);
15711 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
15714 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
15715 because they are considered useful. Now there is an epilogue, they are
15716 not anymore, so give it another try. */
15717 loc_descr_without_nops (loc_body
);
15719 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
15720 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
15721 though, given that size functions do not come from source, so they should
15722 not have a dedicated DW_TAG_subprogram DIE. */
15724 = new_dwarf_proc_die (loc_body
, fndecl
,
15725 get_context_die (DECL_CONTEXT (fndecl
)));
15727 /* The called DWARF procedure consumes one stack slot per argument and
15728 returns one stack slot. */
15729 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
15731 return dwarf_proc_die
;
15735 /* Generate Dwarf location list representing LOC.
15736 If WANT_ADDRESS is false, expression computing LOC will be computed
15737 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
15738 if WANT_ADDRESS is 2, expression computing address useable in location
15739 will be returned (i.e. DW_OP_reg can be used
15740 to refer to register values).
15742 CONTEXT provides information to customize the location descriptions
15743 generation. Its context_type field specifies what type is implicitly
15744 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
15745 will not be generated.
15747 Its DPI field determines whether we are generating a DWARF expression for a
15748 DWARF procedure, so PARM_DECL references are processed specifically.
15750 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
15751 and dpi fields were null. */
15753 static dw_loc_list_ref
15754 loc_list_from_tree_1 (tree loc
, int want_address
,
15755 const struct loc_descr_context
*context
)
15757 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
15758 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
15759 int have_address
= 0;
15760 enum dwarf_location_atom op
;
15762 /* ??? Most of the time we do not take proper care for sign/zero
15763 extending the values properly. Hopefully this won't be a real
15766 if (context
!= NULL
15767 && context
->base_decl
== loc
15768 && want_address
== 0)
15770 if (dwarf_version
>= 3 || !dwarf_strict
)
15771 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
15777 switch (TREE_CODE (loc
))
15780 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
15783 case PLACEHOLDER_EXPR
:
15784 /* This case involves extracting fields from an object to determine the
15785 position of other fields. It is supposed to appear only as the first
15786 operand of COMPONENT_REF nodes and to reference precisely the type
15787 that the context allows. */
15788 if (context
!= NULL
15789 && TREE_TYPE (loc
) == context
->context_type
15790 && want_address
>= 1)
15792 if (dwarf_version
>= 3 || !dwarf_strict
)
15794 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
15802 expansion_failed (loc
, NULL_RTX
,
15803 "PLACEHOLDER_EXPR for an unexpected type");
15808 const int nargs
= call_expr_nargs (loc
);
15809 tree callee
= get_callee_fndecl (loc
);
15811 dw_die_ref dwarf_proc
;
15813 if (callee
== NULL_TREE
)
15814 goto call_expansion_failed
;
15816 /* We handle only functions that return an integer. */
15817 if (!is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
))))
15818 goto call_expansion_failed
;
15820 dwarf_proc
= function_to_dwarf_procedure (callee
);
15821 if (dwarf_proc
== NULL
)
15822 goto call_expansion_failed
;
15824 /* Evaluate arguments right-to-left so that the first argument will
15825 be the top-most one on the stack. */
15826 for (i
= nargs
- 1; i
>= 0; --i
)
15828 dw_loc_descr_ref loc_descr
15829 = loc_descriptor_from_tree (CALL_EXPR_ARG (loc
, i
), 0,
15832 if (loc_descr
== NULL
)
15833 goto call_expansion_failed
;
15835 add_loc_descr (&ret
, loc_descr
);
15838 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
15839 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15840 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
15841 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15842 add_loc_descr (&ret
, ret1
);
15845 call_expansion_failed
:
15846 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
15847 /* There are no opcodes for these operations. */
15851 case PREINCREMENT_EXPR
:
15852 case PREDECREMENT_EXPR
:
15853 case POSTINCREMENT_EXPR
:
15854 case POSTDECREMENT_EXPR
:
15855 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
15856 /* There are no opcodes for these operations. */
15860 /* If we already want an address, see if there is INDIRECT_REF inside
15861 e.g. for &this->field. */
15864 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
15865 (loc
, want_address
== 2, context
);
15868 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
15869 && (ret
= cst_pool_loc_descr (loc
)))
15872 /* Otherwise, process the argument and look for the address. */
15873 if (!list_ret
&& !ret
)
15874 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
15878 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
15884 if (DECL_THREAD_LOCAL_P (loc
))
15887 enum dwarf_location_atom tls_op
;
15888 enum dtprel_bool dtprel
= dtprel_false
;
15890 if (targetm
.have_tls
)
15892 /* If this is not defined, we have no way to emit the
15894 if (!targetm
.asm_out
.output_dwarf_dtprel
)
15897 /* The way DW_OP_GNU_push_tls_address is specified, we
15898 can only look up addresses of objects in the current
15899 module. We used DW_OP_addr as first op, but that's
15900 wrong, because DW_OP_addr is relocated by the debug
15901 info consumer, while DW_OP_GNU_push_tls_address
15902 operand shouldn't be. */
15903 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
15905 dtprel
= dtprel_true
;
15906 tls_op
= DW_OP_GNU_push_tls_address
;
15910 if (!targetm
.emutls
.debug_form_tls_address
15911 || !(dwarf_version
>= 3 || !dwarf_strict
))
15913 /* We stuffed the control variable into the DECL_VALUE_EXPR
15914 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
15915 no longer appear in gimple code. We used the control
15916 variable in specific so that we could pick it up here. */
15917 loc
= DECL_VALUE_EXPR (loc
);
15918 tls_op
= DW_OP_form_tls_address
;
15921 rtl
= rtl_for_decl_location (loc
);
15922 if (rtl
== NULL_RTX
)
15927 rtl
= XEXP (rtl
, 0);
15928 if (! CONSTANT_P (rtl
))
15931 ret
= new_addr_loc_descr (rtl
, dtprel
);
15932 ret1
= new_loc_descr (tls_op
, 0, 0);
15933 add_loc_descr (&ret
, ret1
);
15941 if (context
!= NULL
&& context
->dpi
!= NULL
15942 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
15944 /* We are generating code for a DWARF procedure and we want to access
15945 one of its arguments: find the appropriate argument offset and let
15946 the resolve_args_picking pass compute the offset that complies
15947 with the stack frame size. */
15951 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
15952 cursor
!= NULL_TREE
&& cursor
!= loc
;
15953 cursor
= TREE_CHAIN (cursor
), ++i
)
15955 /* If we are translating a DWARF procedure, all referenced parameters
15956 must belong to the current function. */
15957 gcc_assert (cursor
!= NULL_TREE
);
15959 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
15960 ret
->frame_offset_rel
= 1;
15966 if (DECL_HAS_VALUE_EXPR_P (loc
))
15967 return loc_list_from_tree_1 (DECL_VALUE_EXPR (loc
),
15968 want_address
, context
);
15971 case FUNCTION_DECL
:
15974 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
15976 if (loc_list
&& loc_list
->first
)
15978 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
15979 have_address
= want_address
!= 0;
15982 rtl
= rtl_for_decl_location (loc
);
15983 if (rtl
== NULL_RTX
)
15985 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
15988 else if (CONST_INT_P (rtl
))
15990 HOST_WIDE_INT val
= INTVAL (rtl
);
15991 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
15992 val
&= GET_MODE_MASK (DECL_MODE (loc
));
15993 ret
= int_loc_descriptor (val
);
15995 else if (GET_CODE (rtl
) == CONST_STRING
)
15997 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
16000 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
16001 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
16004 machine_mode mode
, mem_mode
;
16006 /* Certain constructs can only be represented at top-level. */
16007 if (want_address
== 2)
16009 ret
= loc_descriptor (rtl
, VOIDmode
,
16010 VAR_INIT_STATUS_INITIALIZED
);
16015 mode
= GET_MODE (rtl
);
16016 mem_mode
= VOIDmode
;
16020 mode
= get_address_mode (rtl
);
16021 rtl
= XEXP (rtl
, 0);
16024 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
16025 VAR_INIT_STATUS_INITIALIZED
);
16028 expansion_failed (loc
, rtl
,
16029 "failed to produce loc descriptor for rtl");
16035 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
16042 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
16046 case TARGET_MEM_REF
:
16048 case DEBUG_EXPR_DECL
:
16051 case COMPOUND_EXPR
:
16052 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
16056 case VIEW_CONVERT_EXPR
:
16059 case NON_LVALUE_EXPR
:
16060 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
16063 case COMPONENT_REF
:
16064 case BIT_FIELD_REF
:
16066 case ARRAY_RANGE_REF
:
16067 case REALPART_EXPR
:
16068 case IMAGPART_EXPR
:
16071 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
16073 int unsignedp
, reversep
, volatilep
= 0;
16075 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
16076 &unsignedp
, &reversep
, &volatilep
);
16078 gcc_assert (obj
!= loc
);
16080 list_ret
= loc_list_from_tree_1 (obj
,
16082 && !bitpos
&& !offset
? 2 : 1,
16084 /* TODO: We can extract value of the small expression via shifting even
16085 for nonzero bitpos. */
16088 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
16090 expansion_failed (loc
, NULL_RTX
,
16091 "bitfield access");
16095 if (offset
!= NULL_TREE
)
16097 /* Variable offset. */
16098 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
16099 if (list_ret1
== 0)
16101 add_loc_list (&list_ret
, list_ret1
);
16104 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
16107 bytepos
= bitpos
/ BITS_PER_UNIT
;
16109 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
16110 else if (bytepos
< 0)
16111 loc_list_plus_const (list_ret
, bytepos
);
16118 if ((want_address
|| !tree_fits_shwi_p (loc
))
16119 && (ret
= cst_pool_loc_descr (loc
)))
16121 else if (want_address
== 2
16122 && tree_fits_shwi_p (loc
)
16123 && (ret
= address_of_int_loc_descriptor
16124 (int_size_in_bytes (TREE_TYPE (loc
)),
16125 tree_to_shwi (loc
))))
16127 else if (tree_fits_shwi_p (loc
))
16128 ret
= int_loc_descriptor (tree_to_shwi (loc
));
16129 else if (tree_fits_uhwi_p (loc
))
16130 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
16133 expansion_failed (loc
, NULL_RTX
,
16134 "Integer operand is not host integer");
16143 if ((ret
= cst_pool_loc_descr (loc
)))
16145 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
16147 tree type
= TREE_TYPE (loc
);
16148 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
16149 unsigned HOST_WIDE_INT offset
= 0;
16150 unsigned HOST_WIDE_INT cnt
;
16151 constructor_elt
*ce
;
16153 if (TREE_CODE (type
) == RECORD_TYPE
)
16155 /* This is very limited, but it's enough to output
16156 pointers to member functions, as long as the
16157 referenced function is defined in the current
16158 translation unit. */
16159 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
16161 tree val
= ce
->value
;
16163 tree field
= ce
->index
;
16168 if (!field
|| DECL_BIT_FIELD (field
))
16170 expansion_failed (loc
, NULL_RTX
,
16171 "bitfield in record type constructor");
16172 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
16177 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
16178 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
16179 gcc_assert (pos
+ fieldsize
<= size
);
16182 expansion_failed (loc
, NULL_RTX
,
16183 "out-of-order fields in record constructor");
16184 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
16190 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
16191 add_loc_descr (&ret
, ret1
);
16194 if (val
&& fieldsize
!= 0)
16196 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
16199 expansion_failed (loc
, NULL_RTX
,
16200 "unsupported expression in field");
16201 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
16205 add_loc_descr (&ret
, ret1
);
16209 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
16210 add_loc_descr (&ret
, ret1
);
16211 offset
= pos
+ fieldsize
;
16215 if (offset
!= size
)
16217 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
16218 add_loc_descr (&ret
, ret1
);
16222 have_address
= !!want_address
;
16225 expansion_failed (loc
, NULL_RTX
,
16226 "constructor of non-record type");
16229 /* We can construct small constants here using int_loc_descriptor. */
16230 expansion_failed (loc
, NULL_RTX
,
16231 "constructor or constant not in constant pool");
16234 case TRUTH_AND_EXPR
:
16235 case TRUTH_ANDIF_EXPR
:
16240 case TRUTH_XOR_EXPR
:
16245 case TRUTH_OR_EXPR
:
16246 case TRUTH_ORIF_EXPR
:
16251 case FLOOR_DIV_EXPR
:
16252 case CEIL_DIV_EXPR
:
16253 case ROUND_DIV_EXPR
:
16254 case TRUNC_DIV_EXPR
:
16255 case EXACT_DIV_EXPR
:
16256 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
16265 case FLOOR_MOD_EXPR
:
16266 case CEIL_MOD_EXPR
:
16267 case ROUND_MOD_EXPR
:
16268 case TRUNC_MOD_EXPR
:
16269 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
16274 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
16275 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
16276 if (list_ret
== 0 || list_ret1
== 0)
16279 add_loc_list (&list_ret
, list_ret1
);
16282 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
16283 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
16284 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
16285 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
16286 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
16298 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
16301 case POINTER_PLUS_EXPR
:
16304 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
16306 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
16307 smarter to encode their opposite. The DW_OP_plus_uconst operation
16308 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
16309 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
16310 bytes, Y being the size of the operation that pushes the opposite
16311 of the addend. So let's choose the smallest representation. */
16312 const tree tree_addend
= TREE_OPERAND (loc
, 1);
16313 offset_int wi_addend
;
16314 HOST_WIDE_INT shwi_addend
;
16315 dw_loc_descr_ref loc_naddend
;
16317 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
16321 /* Try to get the literal to push. It is the opposite of the addend,
16322 so as we rely on wrapping during DWARF evaluation, first decode
16323 the literal as a "DWARF-sized" signed number. */
16324 wi_addend
= wi::to_offset (tree_addend
);
16325 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
16326 shwi_addend
= wi_addend
.to_shwi ();
16327 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
16328 ? int_loc_descriptor (-shwi_addend
)
16331 if (loc_naddend
!= NULL
16332 && ((unsigned) size_of_uleb128 (shwi_addend
)
16333 > size_of_loc_descr (loc_naddend
)))
16335 add_loc_descr_to_each (list_ret
, loc_naddend
);
16336 add_loc_descr_to_each (list_ret
,
16337 new_loc_descr (DW_OP_minus
, 0, 0));
16341 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
16343 loc_naddend
= loc_cur
;
16344 loc_cur
= loc_cur
->dw_loc_next
;
16345 ggc_free (loc_naddend
);
16347 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
16357 goto do_comp_binop
;
16361 goto do_comp_binop
;
16365 goto do_comp_binop
;
16369 goto do_comp_binop
;
16372 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
16374 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
16375 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
16376 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
16392 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
16393 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
16394 if (list_ret
== 0 || list_ret1
== 0)
16397 add_loc_list (&list_ret
, list_ret1
);
16400 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
16403 case TRUTH_NOT_EXPR
:
16417 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
16421 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
16427 const enum tree_code code
=
16428 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
16430 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
16431 build2 (code
, integer_type_node
,
16432 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
16433 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
16436 /* ... fall through ... */
16440 dw_loc_descr_ref lhs
16441 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
16442 dw_loc_list_ref rhs
16443 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
16444 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
16446 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
16447 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
16450 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
16451 add_loc_descr_to_each (list_ret
, bra_node
);
16453 add_loc_list (&list_ret
, rhs
);
16454 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
16455 add_loc_descr_to_each (list_ret
, jump_node
);
16457 add_loc_descr_to_each (list_ret
, lhs
);
16458 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16459 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
16461 /* ??? Need a node to point the skip at. Use a nop. */
16462 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
16463 add_loc_descr_to_each (list_ret
, tmp
);
16464 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16465 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
16469 case FIX_TRUNC_EXPR
:
16473 /* Leave front-end specific codes as simply unknown. This comes
16474 up, for instance, with the C STMT_EXPR. */
16475 if ((unsigned int) TREE_CODE (loc
)
16476 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
16478 expansion_failed (loc
, NULL_RTX
,
16479 "language specific tree node");
16483 /* Otherwise this is a generic code; we should just lists all of
16484 these explicitly. We forgot one. */
16486 gcc_unreachable ();
16488 /* In a release build, we want to degrade gracefully: better to
16489 generate incomplete debugging information than to crash. */
16493 if (!ret
&& !list_ret
)
16496 if (want_address
== 2 && !have_address
16497 && (dwarf_version
>= 4 || !dwarf_strict
))
16499 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
16501 expansion_failed (loc
, NULL_RTX
,
16502 "DWARF address size mismatch");
16506 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16508 add_loc_descr_to_each (list_ret
,
16509 new_loc_descr (DW_OP_stack_value
, 0, 0));
16512 /* Show if we can't fill the request for an address. */
16513 if (want_address
&& !have_address
)
16515 expansion_failed (loc
, NULL_RTX
,
16516 "Want address and only have value");
16520 gcc_assert (!ret
|| !list_ret
);
16522 /* If we've got an address and don't want one, dereference. */
16523 if (!want_address
&& have_address
)
16525 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
16527 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
16529 expansion_failed (loc
, NULL_RTX
,
16530 "DWARF address size mismatch");
16533 else if (size
== DWARF2_ADDR_SIZE
)
16536 op
= DW_OP_deref_size
;
16539 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
16541 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
16544 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
16549 /* Likewise, but strip useless DW_OP_nop operations in the resulting
16552 static dw_loc_list_ref
16553 loc_list_from_tree (tree loc
, int want_address
,
16554 const struct loc_descr_context
*context
)
16556 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
16558 for (dw_loc_list_ref loc_cur
= result
;
16559 loc_cur
!= NULL
; loc_cur
=
16560 loc_cur
->dw_loc_next
)
16561 loc_descr_without_nops (loc_cur
->expr
);
16565 /* Same as above but return only single location expression. */
16566 static dw_loc_descr_ref
16567 loc_descriptor_from_tree (tree loc
, int want_address
,
16568 const struct loc_descr_context
*context
)
16570 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
16573 if (ret
->dw_loc_next
)
16575 expansion_failed (loc
, NULL_RTX
,
16576 "Location list where only loc descriptor needed");
16582 /* Given a value, round it up to the lowest multiple of `boundary'
16583 which is not less than the value itself. */
16585 static inline HOST_WIDE_INT
16586 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
16588 return (((value
+ boundary
- 1) / boundary
) * boundary
);
16591 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
16592 pointer to the declared type for the relevant field variable, or return
16593 `integer_type_node' if the given node turns out to be an
16594 ERROR_MARK node. */
16597 field_type (const_tree decl
)
16601 if (TREE_CODE (decl
) == ERROR_MARK
)
16602 return integer_type_node
;
16604 type
= DECL_BIT_FIELD_TYPE (decl
);
16605 if (type
== NULL_TREE
)
16606 type
= TREE_TYPE (decl
);
16611 /* Given a pointer to a tree node, return the alignment in bits for
16612 it, or else return BITS_PER_WORD if the node actually turns out to
16613 be an ERROR_MARK node. */
16615 static inline unsigned
16616 simple_type_align_in_bits (const_tree type
)
16618 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
16621 static inline unsigned
16622 simple_decl_align_in_bits (const_tree decl
)
16624 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
16627 /* Return the result of rounding T up to ALIGN. */
16629 static inline offset_int
16630 round_up_to_align (const offset_int
&t
, unsigned int align
)
16632 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
16635 /* Compute the size of TYPE in bytes. If possible, return NULL and store the
16636 size as an integer constant in CST_SIZE. Otherwise, if possible, return a
16637 DWARF expression that computes the size. Return NULL and set CST_SIZE to -1
16638 if we fail to return the size in one of these two forms. */
16640 static dw_loc_descr_ref
16641 type_byte_size (const_tree type
, HOST_WIDE_INT
*cst_size
)
16644 struct loc_descr_context ctx
;
16646 /* Return a constant integer in priority, if possible. */
16647 *cst_size
= int_size_in_bytes (type
);
16648 if (*cst_size
!= -1)
16651 ctx
.context_type
= const_cast<tree
> (type
);
16652 ctx
.base_decl
= NULL_TREE
;
16655 type
= TYPE_MAIN_VARIANT (type
);
16656 tree_size
= TYPE_SIZE_UNIT (type
);
16657 return ((tree_size
!= NULL_TREE
)
16658 ? loc_descriptor_from_tree (tree_size
, 0, &ctx
)
16662 /* Helper structure for RECORD_TYPE processing. */
16665 /* Root RECORD_TYPE. It is needed to generate data member location
16666 descriptions in variable-length records (VLR), but also to cope with
16667 variants, which are composed of nested structures multiplexed with
16668 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
16669 function processing a FIELD_DECL, it is required to be non null. */
16671 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
16672 QUAL_UNION_TYPE), this holds an expression that computes the offset for
16673 this variant part as part of the root record (in storage units). For
16674 regular records, it must be NULL_TREE. */
16675 tree variant_part_offset
;
16678 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
16679 addressed byte of the "containing object" for the given FIELD_DECL. If
16680 possible, return a native constant through CST_OFFSET (in which case NULL is
16681 returned); otherwise return a DWARF expression that computes the offset.
16683 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
16684 that offset is, either because the argument turns out to be a pointer to an
16685 ERROR_MARK node, or because the offset expression is too complex for us.
16687 CTX is required: see the comment for VLR_CONTEXT. */
16689 static dw_loc_descr_ref
16690 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
16691 HOST_WIDE_INT
*cst_offset
)
16693 offset_int object_offset_in_bits
;
16694 offset_int object_offset_in_bytes
;
16695 offset_int bitpos_int
;
16696 bool is_byte_offset_cst
, is_bit_offset_cst
;
16698 dw_loc_list_ref loc_result
;
16702 if (TREE_CODE (decl
) == ERROR_MARK
)
16705 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
16707 is_bit_offset_cst
= TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
;
16708 is_byte_offset_cst
= TREE_CODE (DECL_FIELD_OFFSET (decl
)) != INTEGER_CST
;
16710 /* We cannot handle variable bit offsets at the moment, so abort if it's the
16712 if (is_bit_offset_cst
)
16715 #ifdef PCC_BITFIELD_TYPE_MATTERS
16716 /* We used to handle only constant offsets in all cases. Now, we handle
16717 properly dynamic byte offsets only when PCC bitfield type doesn't
16719 if (PCC_BITFIELD_TYPE_MATTERS
&& is_byte_offset_cst
&& is_bit_offset_cst
)
16722 tree field_size_tree
;
16723 offset_int deepest_bitpos
;
16724 offset_int field_size_in_bits
;
16725 unsigned int type_align_in_bits
;
16726 unsigned int decl_align_in_bits
;
16727 offset_int type_size_in_bits
;
16729 bitpos_int
= wi::to_offset (bit_position (decl
));
16730 type
= field_type (decl
);
16731 type_size_in_bits
= offset_int_type_size_in_bits (type
);
16732 type_align_in_bits
= simple_type_align_in_bits (type
);
16734 field_size_tree
= DECL_SIZE (decl
);
16736 /* The size could be unspecified if there was an error, or for
16737 a flexible array member. */
16738 if (!field_size_tree
)
16739 field_size_tree
= bitsize_zero_node
;
16741 /* If the size of the field is not constant, use the type size. */
16742 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
16743 field_size_in_bits
= wi::to_offset (field_size_tree
);
16745 field_size_in_bits
= type_size_in_bits
;
16747 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
16749 /* The GCC front-end doesn't make any attempt to keep track of the
16750 starting bit offset (relative to the start of the containing
16751 structure type) of the hypothetical "containing object" for a
16752 bit-field. Thus, when computing the byte offset value for the
16753 start of the "containing object" of a bit-field, we must deduce
16754 this information on our own. This can be rather tricky to do in
16755 some cases. For example, handling the following structure type
16756 definition when compiling for an i386/i486 target (which only
16757 aligns long long's to 32-bit boundaries) can be very tricky:
16759 struct S { int field1; long long field2:31; };
16761 Fortunately, there is a simple rule-of-thumb which can be used
16762 in such cases. When compiling for an i386/i486, GCC will
16763 allocate 8 bytes for the structure shown above. It decides to
16764 do this based upon one simple rule for bit-field allocation.
16765 GCC allocates each "containing object" for each bit-field at
16766 the first (i.e. lowest addressed) legitimate alignment boundary
16767 (based upon the required minimum alignment for the declared
16768 type of the field) which it can possibly use, subject to the
16769 condition that there is still enough available space remaining
16770 in the containing object (when allocated at the selected point)
16771 to fully accommodate all of the bits of the bit-field itself.
16773 This simple rule makes it obvious why GCC allocates 8 bytes for
16774 each object of the structure type shown above. When looking
16775 for a place to allocate the "containing object" for `field2',
16776 the compiler simply tries to allocate a 64-bit "containing
16777 object" at each successive 32-bit boundary (starting at zero)
16778 until it finds a place to allocate that 64- bit field such that
16779 at least 31 contiguous (and previously unallocated) bits remain
16780 within that selected 64 bit field. (As it turns out, for the
16781 example above, the compiler finds it is OK to allocate the
16782 "containing object" 64-bit field at bit-offset zero within the
16785 Here we attempt to work backwards from the limited set of facts
16786 we're given, and we try to deduce from those facts, where GCC
16787 must have believed that the containing object started (within
16788 the structure type). The value we deduce is then used (by the
16789 callers of this routine) to generate DW_AT_location and
16790 DW_AT_bit_offset attributes for fields (both bit-fields and, in
16791 the case of DW_AT_location, regular fields as well). */
16793 /* Figure out the bit-distance from the start of the structure to
16794 the "deepest" bit of the bit-field. */
16795 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
16797 /* This is the tricky part. Use some fancy footwork to deduce
16798 where the lowest addressed bit of the containing object must
16800 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
16802 /* Round up to type_align by default. This works best for
16804 object_offset_in_bits
16805 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
16807 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
16809 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
16811 /* Round up to decl_align instead. */
16812 object_offset_in_bits
16813 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
16816 #endif /* PCC_BITFIELD_TYPE_MATTERS */
16818 tree_result
= byte_position (decl
);
16819 if (ctx
->variant_part_offset
!= NULL_TREE
)
16820 tree_result
= fold (build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
16821 ctx
->variant_part_offset
, tree_result
));
16823 /* If the byte offset is a constant, it's simplier to handle a native
16824 constant rather than a DWARF expression. */
16825 if (TREE_CODE (tree_result
) == INTEGER_CST
)
16827 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
16830 struct loc_descr_context loc_ctx
= {
16831 ctx
->struct_type
, /* context_type */
16832 NULL_TREE
, /* base_decl */
16835 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
16837 /* We want a DWARF expression: abort if we only have a location list with
16838 multiple elements. */
16839 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
16842 return loc_result
->expr
;
16845 /* The following routines define various Dwarf attributes and any data
16846 associated with them. */
16848 /* Add a location description attribute value to a DIE.
16850 This emits location attributes suitable for whole variables and
16851 whole parameters. Note that the location attributes for struct fields are
16852 generated by the routine `data_member_location_attribute' below. */
16855 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
16856 dw_loc_list_ref descr
)
16860 if (single_element_loc_list_p (descr
))
16861 add_AT_loc (die
, attr_kind
, descr
->expr
);
16863 add_AT_loc_list (die
, attr_kind
, descr
);
16866 /* Add DW_AT_accessibility attribute to DIE if needed. */
16869 add_accessibility_attribute (dw_die_ref die
, tree decl
)
16871 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
16872 children, otherwise the default is DW_ACCESS_public. In DWARF2
16873 the default has always been DW_ACCESS_public. */
16874 if (TREE_PROTECTED (decl
))
16875 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
16876 else if (TREE_PRIVATE (decl
))
16878 if (dwarf_version
== 2
16879 || die
->die_parent
== NULL
16880 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
16881 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
16883 else if (dwarf_version
> 2
16885 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
16886 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
16889 /* Attach the specialized form of location attribute used for data members of
16890 struct and union types. In the special case of a FIELD_DECL node which
16891 represents a bit-field, the "offset" part of this special location
16892 descriptor must indicate the distance in bytes from the lowest-addressed
16893 byte of the containing struct or union type to the lowest-addressed byte of
16894 the "containing object" for the bit-field. (See the `field_byte_offset'
16897 For any given bit-field, the "containing object" is a hypothetical object
16898 (of some integral or enum type) within which the given bit-field lives. The
16899 type of this hypothetical "containing object" is always the same as the
16900 declared type of the individual bit-field itself (for GCC anyway... the
16901 DWARF spec doesn't actually mandate this). Note that it is the size (in
16902 bytes) of the hypothetical "containing object" which will be given in the
16903 DW_AT_byte_size attribute for this bit-field. (See the
16904 `byte_size_attribute' function below.) It is also used when calculating the
16905 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
16908 CTX is required: see the comment for VLR_CONTEXT. */
16911 add_data_member_location_attribute (dw_die_ref die
,
16913 struct vlr_context
*ctx
)
16915 HOST_WIDE_INT offset
;
16916 dw_loc_descr_ref loc_descr
= 0;
16918 if (TREE_CODE (decl
) == TREE_BINFO
)
16920 /* We're working on the TAG_inheritance for a base class. */
16921 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
16923 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
16924 aren't at a fixed offset from all (sub)objects of the same
16925 type. We need to extract the appropriate offset from our
16926 vtable. The following dwarf expression means
16928 BaseAddr = ObAddr + *((*ObAddr) - Offset)
16930 This is specific to the V3 ABI, of course. */
16932 dw_loc_descr_ref tmp
;
16934 /* Make a copy of the object address. */
16935 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
16936 add_loc_descr (&loc_descr
, tmp
);
16938 /* Extract the vtable address. */
16939 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
16940 add_loc_descr (&loc_descr
, tmp
);
16942 /* Calculate the address of the offset. */
16943 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
16944 gcc_assert (offset
< 0);
16946 tmp
= int_loc_descriptor (-offset
);
16947 add_loc_descr (&loc_descr
, tmp
);
16948 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
16949 add_loc_descr (&loc_descr
, tmp
);
16951 /* Extract the offset. */
16952 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
16953 add_loc_descr (&loc_descr
, tmp
);
16955 /* Add it to the object address. */
16956 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
16957 add_loc_descr (&loc_descr
, tmp
);
16960 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
16964 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
16966 /* If loc_descr is available then we know the field offset is dynamic.
16967 However, GDB does not handle dynamic field offsets very well at the
16969 if (loc_descr
!= NULL
&& gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
)
16975 /* Data member location evalutation starts with the base address on the
16976 stack. Compute the field offset and add it to this base address. */
16977 else if (loc_descr
!= NULL
)
16978 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
16983 if (dwarf_version
> 2)
16985 /* Don't need to output a location expression, just the constant. */
16987 add_AT_int (die
, DW_AT_data_member_location
, offset
);
16989 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
16994 enum dwarf_location_atom op
;
16996 /* The DWARF2 standard says that we should assume that the structure
16997 address is already on the stack, so we can specify a structure
16998 field address by using DW_OP_plus_uconst. */
16999 op
= DW_OP_plus_uconst
;
17000 loc_descr
= new_loc_descr (op
, offset
, 0);
17004 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
17007 /* Writes integer values to dw_vec_const array. */
17010 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
17014 *dest
++ = val
& 0xff;
17020 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
17022 static HOST_WIDE_INT
17023 extract_int (const unsigned char *src
, unsigned int size
)
17025 HOST_WIDE_INT val
= 0;
17031 val
|= *--src
& 0xff;
17037 /* Writes wide_int values to dw_vec_const array. */
17040 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
17044 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
17046 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
17050 /* We'd have to extend this code to support odd sizes. */
17051 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
17053 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
17055 if (WORDS_BIG_ENDIAN
)
17056 for (i
= n
- 1; i
>= 0; i
--)
17058 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
17059 dest
+= sizeof (HOST_WIDE_INT
);
17062 for (i
= 0; i
< n
; i
++)
17064 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
17065 dest
+= sizeof (HOST_WIDE_INT
);
17069 /* Writes floating point values to dw_vec_const array. */
17072 insert_float (const_rtx rtl
, unsigned char *array
)
17077 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), GET_MODE (rtl
));
17079 /* real_to_target puts 32-bit pieces in each long. Pack them. */
17080 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
17082 insert_int (val
[i
], 4, array
);
17087 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
17088 does not have a "location" either in memory or in a register. These
17089 things can arise in GNU C when a constant is passed as an actual parameter
17090 to an inlined function. They can also arise in C++ where declared
17091 constants do not necessarily get memory "homes". */
17094 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
17096 switch (GET_CODE (rtl
))
17100 HOST_WIDE_INT val
= INTVAL (rtl
);
17103 add_AT_int (die
, DW_AT_const_value
, val
);
17105 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
17109 case CONST_WIDE_INT
:
17111 wide_int w1
= std::make_pair (rtl
, MAX_MODE_INT
);
17112 unsigned int prec
= MIN (wi::min_precision (w1
, UNSIGNED
),
17113 (unsigned int)CONST_WIDE_INT_NUNITS (rtl
) * HOST_BITS_PER_WIDE_INT
);
17114 wide_int w
= wi::zext (w1
, prec
);
17115 add_AT_wide (die
, DW_AT_const_value
, w
);
17120 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
17121 floating-point constant. A CONST_DOUBLE is used whenever the
17122 constant requires more than one word in order to be adequately
17125 machine_mode mode
= GET_MODE (rtl
);
17127 if (TARGET_SUPPORTS_WIDE_INT
== 0 && !SCALAR_FLOAT_MODE_P (mode
))
17128 add_AT_double (die
, DW_AT_const_value
,
17129 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
17132 unsigned int length
= GET_MODE_SIZE (mode
);
17133 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
17135 insert_float (rtl
, array
);
17136 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
17143 machine_mode mode
= GET_MODE (rtl
);
17144 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
17145 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
17146 unsigned char *array
17147 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
17150 machine_mode imode
= GET_MODE_INNER (mode
);
17152 switch (GET_MODE_CLASS (mode
))
17154 case MODE_VECTOR_INT
:
17155 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
17157 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
17158 insert_wide_int (std::make_pair (elt
, imode
), p
, elt_size
);
17162 case MODE_VECTOR_FLOAT
:
17163 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
17165 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
17166 insert_float (elt
, p
);
17171 gcc_unreachable ();
17174 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
17179 if (dwarf_version
>= 4 || !dwarf_strict
)
17181 dw_loc_descr_ref loc_result
;
17182 resolve_one_addr (&rtl
);
17184 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
17185 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
17186 add_AT_loc (die
, DW_AT_location
, loc_result
);
17187 vec_safe_push (used_rtx_array
, rtl
);
17193 if (CONSTANT_P (XEXP (rtl
, 0)))
17194 return add_const_value_attribute (die
, XEXP (rtl
, 0));
17197 if (!const_ok_for_output (rtl
))
17200 if (dwarf_version
>= 4 || !dwarf_strict
)
17205 /* In cases where an inlined instance of an inline function is passed
17206 the address of an `auto' variable (which is local to the caller) we
17207 can get a situation where the DECL_RTL of the artificial local
17208 variable (for the inlining) which acts as a stand-in for the
17209 corresponding formal parameter (of the inline function) will look
17210 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
17211 exactly a compile-time constant expression, but it isn't the address
17212 of the (artificial) local variable either. Rather, it represents the
17213 *value* which the artificial local variable always has during its
17214 lifetime. We currently have no way to represent such quasi-constant
17215 values in Dwarf, so for now we just punt and generate nothing. */
17223 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
17224 && MEM_READONLY_P (rtl
)
17225 && GET_MODE (rtl
) == BLKmode
)
17227 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
17233 /* No other kinds of rtx should be possible here. */
17234 gcc_unreachable ();
17239 /* Determine whether the evaluation of EXPR references any variables
17240 or functions which aren't otherwise used (and therefore may not be
17243 reference_to_unused (tree
* tp
, int * walk_subtrees
,
17244 void * data ATTRIBUTE_UNUSED
)
17246 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
17247 *walk_subtrees
= 0;
17249 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
17250 && ! TREE_ASM_WRITTEN (*tp
))
17252 /* ??? The C++ FE emits debug information for using decls, so
17253 putting gcc_unreachable here falls over. See PR31899. For now
17254 be conservative. */
17255 else if (!symtab
->global_info_ready
17256 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
17258 else if (TREE_CODE (*tp
) == VAR_DECL
)
17260 varpool_node
*node
= varpool_node::get (*tp
);
17261 if (!node
|| !node
->definition
)
17264 else if (TREE_CODE (*tp
) == FUNCTION_DECL
17265 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
17267 /* The call graph machinery must have finished analyzing,
17268 optimizing and gimplifying the CU by now.
17269 So if *TP has no call graph node associated
17270 to it, it means *TP will not be emitted. */
17271 if (!cgraph_node::get (*tp
))
17274 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
17280 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
17281 for use in a later add_const_value_attribute call. */
17284 rtl_for_decl_init (tree init
, tree type
)
17286 rtx rtl
= NULL_RTX
;
17290 /* If a variable is initialized with a string constant without embedded
17291 zeros, build CONST_STRING. */
17292 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
17294 tree enttype
= TREE_TYPE (type
);
17295 tree domain
= TYPE_DOMAIN (type
);
17296 machine_mode mode
= TYPE_MODE (enttype
);
17298 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
17300 && integer_zerop (TYPE_MIN_VALUE (domain
))
17301 && compare_tree_int (TYPE_MAX_VALUE (domain
),
17302 TREE_STRING_LENGTH (init
) - 1) == 0
17303 && ((size_t) TREE_STRING_LENGTH (init
)
17304 == strlen (TREE_STRING_POINTER (init
)) + 1))
17306 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
17307 ggc_strdup (TREE_STRING_POINTER (init
)));
17308 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
17309 MEM_READONLY_P (rtl
) = 1;
17312 /* Other aggregates, and complex values, could be represented using
17314 else if (AGGREGATE_TYPE_P (type
)
17315 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
17316 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
17317 || TREE_CODE (type
) == COMPLEX_TYPE
)
17319 /* Vectors only work if their mode is supported by the target.
17320 FIXME: generic vectors ought to work too. */
17321 else if (TREE_CODE (type
) == VECTOR_TYPE
17322 && !VECTOR_MODE_P (TYPE_MODE (type
)))
17324 /* If the initializer is something that we know will expand into an
17325 immediate RTL constant, expand it now. We must be careful not to
17326 reference variables which won't be output. */
17327 else if (initializer_constant_valid_p (init
, type
)
17328 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
17330 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
17332 if (TREE_CODE (type
) == VECTOR_TYPE
)
17333 switch (TREE_CODE (init
))
17338 if (TREE_CONSTANT (init
))
17340 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
17341 bool constant_p
= true;
17343 unsigned HOST_WIDE_INT ix
;
17345 /* Even when ctor is constant, it might contain non-*_CST
17346 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
17347 belong into VECTOR_CST nodes. */
17348 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
17349 if (!CONSTANT_CLASS_P (value
))
17351 constant_p
= false;
17357 init
= build_vector_from_ctor (type
, elts
);
17367 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
17369 /* If expand_expr returns a MEM, it wasn't immediate. */
17370 gcc_assert (!rtl
|| !MEM_P (rtl
));
17376 /* Generate RTL for the variable DECL to represent its location. */
17379 rtl_for_decl_location (tree decl
)
17383 /* Here we have to decide where we are going to say the parameter "lives"
17384 (as far as the debugger is concerned). We only have a couple of
17385 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
17387 DECL_RTL normally indicates where the parameter lives during most of the
17388 activation of the function. If optimization is enabled however, this
17389 could be either NULL or else a pseudo-reg. Both of those cases indicate
17390 that the parameter doesn't really live anywhere (as far as the code
17391 generation parts of GCC are concerned) during most of the function's
17392 activation. That will happen (for example) if the parameter is never
17393 referenced within the function.
17395 We could just generate a location descriptor here for all non-NULL
17396 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
17397 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
17398 where DECL_RTL is NULL or is a pseudo-reg.
17400 Note however that we can only get away with using DECL_INCOMING_RTL as
17401 a backup substitute for DECL_RTL in certain limited cases. In cases
17402 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
17403 we can be sure that the parameter was passed using the same type as it is
17404 declared to have within the function, and that its DECL_INCOMING_RTL
17405 points us to a place where a value of that type is passed.
17407 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
17408 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
17409 because in these cases DECL_INCOMING_RTL points us to a value of some
17410 type which is *different* from the type of the parameter itself. Thus,
17411 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
17412 such cases, the debugger would end up (for example) trying to fetch a
17413 `float' from a place which actually contains the first part of a
17414 `double'. That would lead to really incorrect and confusing
17415 output at debug-time.
17417 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
17418 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
17419 are a couple of exceptions however. On little-endian machines we can
17420 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
17421 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
17422 an integral type that is smaller than TREE_TYPE (decl). These cases arise
17423 when (on a little-endian machine) a non-prototyped function has a
17424 parameter declared to be of type `short' or `char'. In such cases,
17425 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
17426 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
17427 passed `int' value. If the debugger then uses that address to fetch
17428 a `short' or a `char' (on a little-endian machine) the result will be
17429 the correct data, so we allow for such exceptional cases below.
17431 Note that our goal here is to describe the place where the given formal
17432 parameter lives during most of the function's activation (i.e. between the
17433 end of the prologue and the start of the epilogue). We'll do that as best
17434 as we can. Note however that if the given formal parameter is modified
17435 sometime during the execution of the function, then a stack backtrace (at
17436 debug-time) will show the function as having been called with the *new*
17437 value rather than the value which was originally passed in. This happens
17438 rarely enough that it is not a major problem, but it *is* a problem, and
17439 I'd like to fix it.
17441 A future version of dwarf2out.c may generate two additional attributes for
17442 any given DW_TAG_formal_parameter DIE which will describe the "passed
17443 type" and the "passed location" for the given formal parameter in addition
17444 to the attributes we now generate to indicate the "declared type" and the
17445 "active location" for each parameter. This additional set of attributes
17446 could be used by debuggers for stack backtraces. Separately, note that
17447 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
17448 This happens (for example) for inlined-instances of inline function formal
17449 parameters which are never referenced. This really shouldn't be
17450 happening. All PARM_DECL nodes should get valid non-NULL
17451 DECL_INCOMING_RTL values. FIXME. */
17453 /* Use DECL_RTL as the "location" unless we find something better. */
17454 rtl
= DECL_RTL_IF_SET (decl
);
17456 /* When generating abstract instances, ignore everything except
17457 constants, symbols living in memory, and symbols living in
17458 fixed registers. */
17459 if (! reload_completed
)
17462 && (CONSTANT_P (rtl
)
17464 && CONSTANT_P (XEXP (rtl
, 0)))
17466 && TREE_CODE (decl
) == VAR_DECL
17467 && TREE_STATIC (decl
))))
17469 rtl
= targetm
.delegitimize_address (rtl
);
17474 else if (TREE_CODE (decl
) == PARM_DECL
)
17476 if (rtl
== NULL_RTX
17477 || is_pseudo_reg (rtl
)
17479 && is_pseudo_reg (XEXP (rtl
, 0))
17480 && DECL_INCOMING_RTL (decl
)
17481 && MEM_P (DECL_INCOMING_RTL (decl
))
17482 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
17484 tree declared_type
= TREE_TYPE (decl
);
17485 tree passed_type
= DECL_ARG_TYPE (decl
);
17486 machine_mode dmode
= TYPE_MODE (declared_type
);
17487 machine_mode pmode
= TYPE_MODE (passed_type
);
17489 /* This decl represents a formal parameter which was optimized out.
17490 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
17491 all cases where (rtl == NULL_RTX) just below. */
17492 if (dmode
== pmode
)
17493 rtl
= DECL_INCOMING_RTL (decl
);
17494 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
17495 && SCALAR_INT_MODE_P (dmode
)
17496 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
17497 && DECL_INCOMING_RTL (decl
))
17499 rtx inc
= DECL_INCOMING_RTL (decl
);
17502 else if (MEM_P (inc
))
17504 if (BYTES_BIG_ENDIAN
)
17505 rtl
= adjust_address_nv (inc
, dmode
,
17506 GET_MODE_SIZE (pmode
)
17507 - GET_MODE_SIZE (dmode
));
17514 /* If the parm was passed in registers, but lives on the stack, then
17515 make a big endian correction if the mode of the type of the
17516 parameter is not the same as the mode of the rtl. */
17517 /* ??? This is the same series of checks that are made in dbxout.c before
17518 we reach the big endian correction code there. It isn't clear if all
17519 of these checks are necessary here, but keeping them all is the safe
17521 else if (MEM_P (rtl
)
17522 && XEXP (rtl
, 0) != const0_rtx
17523 && ! CONSTANT_P (XEXP (rtl
, 0))
17524 /* Not passed in memory. */
17525 && !MEM_P (DECL_INCOMING_RTL (decl
))
17526 /* Not passed by invisible reference. */
17527 && (!REG_P (XEXP (rtl
, 0))
17528 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
17529 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
17530 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
17531 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
17534 /* Big endian correction check. */
17535 && BYTES_BIG_ENDIAN
17536 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
17537 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
17540 machine_mode addr_mode
= get_address_mode (rtl
);
17541 int offset
= (UNITS_PER_WORD
17542 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
17544 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
17545 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
17548 else if (TREE_CODE (decl
) == VAR_DECL
17551 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
17552 && BYTES_BIG_ENDIAN
)
17554 machine_mode addr_mode
= get_address_mode (rtl
);
17555 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
17556 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
17558 /* If a variable is declared "register" yet is smaller than
17559 a register, then if we store the variable to memory, it
17560 looks like we're storing a register-sized value, when in
17561 fact we are not. We need to adjust the offset of the
17562 storage location to reflect the actual value's bytes,
17563 else gdb will not be able to display it. */
17565 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
17566 plus_constant (addr_mode
, XEXP (rtl
, 0),
17570 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
17571 and will have been substituted directly into all expressions that use it.
17572 C does not have such a concept, but C++ and other languages do. */
17573 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
17574 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
17577 rtl
= targetm
.delegitimize_address (rtl
);
17579 /* If we don't look past the constant pool, we risk emitting a
17580 reference to a constant pool entry that isn't referenced from
17581 code, and thus is not emitted. */
17583 rtl
= avoid_constant_pool_reference (rtl
);
17585 /* Try harder to get a rtl. If this symbol ends up not being emitted
17586 in the current CU, resolve_addr will remove the expression referencing
17588 if (rtl
== NULL_RTX
17589 && TREE_CODE (decl
) == VAR_DECL
17590 && !DECL_EXTERNAL (decl
)
17591 && TREE_STATIC (decl
)
17592 && DECL_NAME (decl
)
17593 && !DECL_HARD_REGISTER (decl
)
17594 && DECL_MODE (decl
) != VOIDmode
)
17596 rtl
= make_decl_rtl_for_debug (decl
);
17598 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
17599 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
17606 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
17607 returned. If so, the decl for the COMMON block is returned, and the
17608 value is the offset into the common block for the symbol. */
17611 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
17613 tree val_expr
, cvar
;
17615 HOST_WIDE_INT bitsize
, bitpos
;
17617 int unsignedp
, reversep
, volatilep
= 0;
17619 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
17620 it does not have a value (the offset into the common area), or if it
17621 is thread local (as opposed to global) then it isn't common, and shouldn't
17622 be handled as such. */
17623 if (TREE_CODE (decl
) != VAR_DECL
17624 || !TREE_STATIC (decl
)
17625 || !DECL_HAS_VALUE_EXPR_P (decl
)
17629 val_expr
= DECL_VALUE_EXPR (decl
);
17630 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
17633 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
17634 &unsignedp
, &reversep
, &volatilep
);
17636 if (cvar
== NULL_TREE
17637 || TREE_CODE (cvar
) != VAR_DECL
17638 || DECL_ARTIFICIAL (cvar
)
17639 || !TREE_PUBLIC (cvar
))
17643 if (offset
!= NULL
)
17645 if (!tree_fits_shwi_p (offset
))
17647 *value
= tree_to_shwi (offset
);
17650 *value
+= bitpos
/ BITS_PER_UNIT
;
17655 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
17656 data attribute for a variable or a parameter. We generate the
17657 DW_AT_const_value attribute only in those cases where the given variable
17658 or parameter does not have a true "location" either in memory or in a
17659 register. This can happen (for example) when a constant is passed as an
17660 actual argument in a call to an inline function. (It's possible that
17661 these things can crop up in other ways also.) Note that one type of
17662 constant value which can be passed into an inlined function is a constant
17663 pointer. This can happen for example if an actual argument in an inlined
17664 function call evaluates to a compile-time constant address.
17666 CACHE_P is true if it is worth caching the location list for DECL,
17667 so that future calls can reuse it rather than regenerate it from scratch.
17668 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
17669 since we will need to refer to them each time the function is inlined. */
17672 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
17675 dw_loc_list_ref list
;
17676 var_loc_list
*loc_list
;
17677 cached_dw_loc_list
*cache
;
17682 if (TREE_CODE (decl
) == ERROR_MARK
)
17685 if (get_AT (die
, DW_AT_location
)
17686 || get_AT (die
, DW_AT_const_value
))
17689 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
17690 || TREE_CODE (decl
) == RESULT_DECL
);
17692 /* Try to get some constant RTL for this decl, and use that as the value of
17695 rtl
= rtl_for_decl_location (decl
);
17696 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
17697 && add_const_value_attribute (die
, rtl
))
17700 /* See if we have single element location list that is equivalent to
17701 a constant value. That way we are better to use add_const_value_attribute
17702 rather than expanding constant value equivalent. */
17703 loc_list
= lookup_decl_loc (decl
);
17706 && loc_list
->first
->next
== NULL
17707 && NOTE_P (loc_list
->first
->loc
)
17708 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
17709 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
17711 struct var_loc_node
*node
;
17713 node
= loc_list
->first
;
17714 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
17715 if (GET_CODE (rtl
) == EXPR_LIST
)
17716 rtl
= XEXP (rtl
, 0);
17717 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
17718 && add_const_value_attribute (die
, rtl
))
17721 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
17722 list several times. See if we've already cached the contents. */
17724 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
17728 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
17730 list
= cache
->loc_list
;
17734 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
17736 /* It is usually worth caching this result if the decl is from
17737 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
17738 if (cache_p
&& list
&& list
->dw_loc_next
)
17740 cached_dw_loc_list
**slot
17741 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
17744 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
17745 cache
->decl_id
= DECL_UID (decl
);
17746 cache
->loc_list
= list
;
17752 add_AT_location_description (die
, DW_AT_location
, list
);
17755 /* None of that worked, so it must not really have a location;
17756 try adding a constant value attribute from the DECL_INITIAL. */
17757 return tree_add_const_value_attribute_for_decl (die
, decl
);
17760 /* Helper function for tree_add_const_value_attribute. Natively encode
17761 initializer INIT into an array. Return true if successful. */
17764 native_encode_initializer (tree init
, unsigned char *array
, int size
)
17768 if (init
== NULL_TREE
)
17772 switch (TREE_CODE (init
))
17775 type
= TREE_TYPE (init
);
17776 if (TREE_CODE (type
) == ARRAY_TYPE
)
17778 tree enttype
= TREE_TYPE (type
);
17779 machine_mode mode
= TYPE_MODE (enttype
);
17781 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
17783 if (int_size_in_bytes (type
) != size
)
17785 if (size
> TREE_STRING_LENGTH (init
))
17787 memcpy (array
, TREE_STRING_POINTER (init
),
17788 TREE_STRING_LENGTH (init
));
17789 memset (array
+ TREE_STRING_LENGTH (init
),
17790 '\0', size
- TREE_STRING_LENGTH (init
));
17793 memcpy (array
, TREE_STRING_POINTER (init
), size
);
17798 type
= TREE_TYPE (init
);
17799 if (int_size_in_bytes (type
) != size
)
17801 if (TREE_CODE (type
) == ARRAY_TYPE
)
17803 HOST_WIDE_INT min_index
;
17804 unsigned HOST_WIDE_INT cnt
;
17805 int curpos
= 0, fieldsize
;
17806 constructor_elt
*ce
;
17808 if (TYPE_DOMAIN (type
) == NULL_TREE
17809 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
17812 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
17813 if (fieldsize
<= 0)
17816 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
17817 memset (array
, '\0', size
);
17818 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
17820 tree val
= ce
->value
;
17821 tree index
= ce
->index
;
17823 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
17824 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
17827 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
17832 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
17835 curpos
= pos
+ fieldsize
;
17836 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
17838 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
17839 - tree_to_shwi (TREE_OPERAND (index
, 0));
17840 while (count
-- > 0)
17843 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
17844 curpos
+= fieldsize
;
17847 gcc_assert (curpos
<= size
);
17851 else if (TREE_CODE (type
) == RECORD_TYPE
17852 || TREE_CODE (type
) == UNION_TYPE
)
17854 tree field
= NULL_TREE
;
17855 unsigned HOST_WIDE_INT cnt
;
17856 constructor_elt
*ce
;
17858 if (int_size_in_bytes (type
) != size
)
17861 if (TREE_CODE (type
) == RECORD_TYPE
)
17862 field
= TYPE_FIELDS (type
);
17864 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
17866 tree val
= ce
->value
;
17867 int pos
, fieldsize
;
17869 if (ce
->index
!= 0)
17875 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
17878 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
17879 && TYPE_DOMAIN (TREE_TYPE (field
))
17880 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
17882 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
17883 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
17885 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
17886 pos
= int_byte_position (field
);
17887 gcc_assert (pos
+ fieldsize
<= size
);
17888 if (val
&& fieldsize
!= 0
17889 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
17895 case VIEW_CONVERT_EXPR
:
17896 case NON_LVALUE_EXPR
:
17897 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
17899 return native_encode_expr (init
, array
, size
) == size
;
17903 /* Attach a DW_AT_const_value attribute to DIE. The value of the
17904 attribute is the const value T. */
17907 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
17910 tree type
= TREE_TYPE (t
);
17913 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
17917 gcc_assert (!DECL_P (init
));
17919 rtl
= rtl_for_decl_init (init
, type
);
17921 return add_const_value_attribute (die
, rtl
);
17922 /* If the host and target are sane, try harder. */
17923 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
17924 && initializer_constant_valid_p (init
, type
))
17926 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
17927 if (size
> 0 && (int) size
== size
)
17929 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
17931 if (native_encode_initializer (init
, array
, size
))
17933 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
17942 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
17943 attribute is the const value of T, where T is an integral constant
17944 variable with static storage duration
17945 (so it can't be a PARM_DECL or a RESULT_DECL). */
17948 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
17952 || (TREE_CODE (decl
) != VAR_DECL
17953 && TREE_CODE (decl
) != CONST_DECL
)
17954 || (TREE_CODE (decl
) == VAR_DECL
17955 && !TREE_STATIC (decl
)))
17958 if (TREE_READONLY (decl
)
17959 && ! TREE_THIS_VOLATILE (decl
)
17960 && DECL_INITIAL (decl
))
17965 /* Don't add DW_AT_const_value if abstract origin already has one. */
17966 if (get_AT (var_die
, DW_AT_const_value
))
17969 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
17972 /* Convert the CFI instructions for the current function into a
17973 location list. This is used for DW_AT_frame_base when we targeting
17974 a dwarf2 consumer that does not support the dwarf3
17975 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
17978 static dw_loc_list_ref
17979 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
17983 dw_loc_list_ref list
, *list_tail
;
17985 dw_cfa_location last_cfa
, next_cfa
;
17986 const char *start_label
, *last_label
, *section
;
17987 dw_cfa_location remember
;
17990 gcc_assert (fde
!= NULL
);
17992 section
= secname_for_decl (current_function_decl
);
17996 memset (&next_cfa
, 0, sizeof (next_cfa
));
17997 next_cfa
.reg
= INVALID_REGNUM
;
17998 remember
= next_cfa
;
18000 start_label
= fde
->dw_fde_begin
;
18002 /* ??? Bald assumption that the CIE opcode list does not contain
18003 advance opcodes. */
18004 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
18005 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
18007 last_cfa
= next_cfa
;
18008 last_label
= start_label
;
18010 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
18012 /* If the first partition contained no CFI adjustments, the
18013 CIE opcodes apply to the whole first partition. */
18014 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
18015 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
18016 list_tail
=&(*list_tail
)->dw_loc_next
;
18017 start_label
= last_label
= fde
->dw_fde_second_begin
;
18020 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
18022 switch (cfi
->dw_cfi_opc
)
18024 case DW_CFA_set_loc
:
18025 case DW_CFA_advance_loc1
:
18026 case DW_CFA_advance_loc2
:
18027 case DW_CFA_advance_loc4
:
18028 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
18030 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
18031 start_label
, last_label
, section
);
18033 list_tail
= &(*list_tail
)->dw_loc_next
;
18034 last_cfa
= next_cfa
;
18035 start_label
= last_label
;
18037 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
18040 case DW_CFA_advance_loc
:
18041 /* The encoding is complex enough that we should never emit this. */
18042 gcc_unreachable ();
18045 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
18048 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
18050 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
18052 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
18053 start_label
, last_label
, section
);
18055 list_tail
= &(*list_tail
)->dw_loc_next
;
18056 last_cfa
= next_cfa
;
18057 start_label
= last_label
;
18059 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
18060 start_label
, fde
->dw_fde_end
, section
);
18061 list_tail
= &(*list_tail
)->dw_loc_next
;
18062 start_label
= last_label
= fde
->dw_fde_second_begin
;
18066 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
18068 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
18069 start_label
, last_label
, section
);
18070 list_tail
= &(*list_tail
)->dw_loc_next
;
18071 start_label
= last_label
;
18074 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
18076 fde
->dw_fde_second_begin
18077 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
18080 if (list
&& list
->dw_loc_next
)
18086 /* Compute a displacement from the "steady-state frame pointer" to the
18087 frame base (often the same as the CFA), and store it in
18088 frame_pointer_fb_offset. OFFSET is added to the displacement
18089 before the latter is negated. */
18092 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
18096 #ifdef FRAME_POINTER_CFA_OFFSET
18097 reg
= frame_pointer_rtx
;
18098 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
18100 reg
= arg_pointer_rtx
;
18101 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
18104 elim
= (ira_use_lra_p
18105 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
18106 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
18107 if (GET_CODE (elim
) == PLUS
)
18109 offset
+= INTVAL (XEXP (elim
, 1));
18110 elim
= XEXP (elim
, 0);
18113 frame_pointer_fb_offset
= -offset
;
18115 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
18116 in which to eliminate. This is because it's stack pointer isn't
18117 directly accessible as a register within the ISA. To work around
18118 this, assume that while we cannot provide a proper value for
18119 frame_pointer_fb_offset, we won't need one either. */
18120 frame_pointer_fb_offset_valid
18121 = ((SUPPORTS_STACK_ALIGNMENT
18122 && (elim
== hard_frame_pointer_rtx
18123 || elim
== stack_pointer_rtx
))
18124 || elim
== (frame_pointer_needed
18125 ? hard_frame_pointer_rtx
18126 : stack_pointer_rtx
));
18129 /* Generate a DW_AT_name attribute given some string value to be included as
18130 the value of the attribute. */
18133 add_name_attribute (dw_die_ref die
, const char *name_string
)
18135 if (name_string
!= NULL
&& *name_string
!= 0)
18137 if (demangle_name_func
)
18138 name_string
= (*demangle_name_func
) (name_string
);
18140 add_AT_string (die
, DW_AT_name
, name_string
);
18144 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
18145 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
18146 of TYPE accordingly.
18148 ??? This is a temporary measure until after we're able to generate
18149 regular DWARF for the complex Ada type system. */
18152 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
18153 dw_die_ref context_die
)
18156 dw_die_ref dtype_die
;
18158 if (!lang_hooks
.types
.descriptive_type
)
18161 dtype
= lang_hooks
.types
.descriptive_type (type
);
18165 dtype_die
= lookup_type_die (dtype
);
18168 gen_type_die (dtype
, context_die
);
18169 dtype_die
= lookup_type_die (dtype
);
18170 gcc_assert (dtype_die
);
18173 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
18176 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
18178 static const char *
18179 comp_dir_string (void)
18183 static const char *cached_wd
= NULL
;
18185 if (cached_wd
!= NULL
)
18188 wd
= get_src_pwd ();
18192 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
18196 wdlen
= strlen (wd
);
18197 wd1
= ggc_vec_alloc
<char> (wdlen
+ 2);
18199 wd1
[wdlen
] = DIR_SEPARATOR
;
18200 wd1
[wdlen
+ 1] = 0;
18204 cached_wd
= remap_debug_filename (wd
);
18208 /* Generate a DW_AT_comp_dir attribute for DIE. */
18211 add_comp_dir_attribute (dw_die_ref die
)
18213 const char * wd
= comp_dir_string ();
18215 add_AT_string (die
, DW_AT_comp_dir
, wd
);
18218 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
18219 pointer computation, ...), output a representation for that bound according
18220 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
18221 loc_list_from_tree for the meaning of CONTEXT. */
18224 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
18225 int forms
, const struct loc_descr_context
*context
)
18227 dw_die_ref context_die
, decl_die
;
18228 dw_loc_list_ref list
;
18230 bool strip_conversions
= true;
18232 while (strip_conversions
)
18233 switch (TREE_CODE (value
))
18240 case VIEW_CONVERT_EXPR
:
18241 value
= TREE_OPERAND (value
, 0);
18245 strip_conversions
= false;
18249 /* If possible and permitted, output the attribute as a constant. */
18250 if ((forms
& dw_scalar_form_constant
) != 0
18251 && TREE_CODE (value
) == INTEGER_CST
)
18253 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
18255 /* If HOST_WIDE_INT is big enough then represent the bound as
18256 a constant value. We need to choose a form based on
18257 whether the type is signed or unsigned. We cannot just
18258 call add_AT_unsigned if the value itself is positive
18259 (add_AT_unsigned might add the unsigned value encoded as
18260 DW_FORM_data[1248]). Some DWARF consumers will lookup the
18261 bounds type and then sign extend any unsigned values found
18262 for signed types. This is needed only for
18263 DW_AT_{lower,upper}_bound, since for most other attributes,
18264 consumers will treat DW_FORM_data[1248] as unsigned values,
18265 regardless of the underlying type. */
18266 if (prec
<= HOST_BITS_PER_WIDE_INT
18267 || tree_fits_uhwi_p (value
))
18269 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
18270 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
18272 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
18275 /* Otherwise represent the bound as an unsigned value with
18276 the precision of its type. The precision and signedness
18277 of the type will be necessary to re-interpret it
18279 add_AT_wide (die
, attr
, value
);
18283 /* Otherwise, if it's possible and permitted too, output a reference to
18285 if ((forms
& dw_scalar_form_reference
) != 0)
18287 tree decl
= NULL_TREE
;
18289 /* Some type attributes reference an outer type. For instance, the upper
18290 bound of an array may reference an embedding record (this happens in
18292 if (TREE_CODE (value
) == COMPONENT_REF
18293 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
18294 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
18295 decl
= TREE_OPERAND (value
, 1);
18297 else if (TREE_CODE (value
) == VAR_DECL
18298 || TREE_CODE (value
) == PARM_DECL
18299 || TREE_CODE (value
) == RESULT_DECL
)
18302 if (decl
!= NULL_TREE
)
18304 dw_die_ref decl_die
= lookup_decl_die (decl
);
18306 /* ??? Can this happen, or should the variable have been bound
18307 first? Probably it can, since I imagine that we try to create
18308 the types of parameters in the order in which they exist in
18309 the list, and won't have created a forward reference to a
18310 later parameter. */
18311 if (decl_die
!= NULL
)
18313 add_AT_die_ref (die
, attr
, decl_die
);
18319 /* Last chance: try to create a stack operation procedure to evaluate the
18320 value. Do nothing if even that is not possible or permitted. */
18321 if ((forms
& dw_scalar_form_exprloc
) == 0)
18324 list
= loc_list_from_tree (value
, 2, context
);
18325 if (list
== NULL
|| single_element_loc_list_p (list
))
18327 /* If this attribute is not a reference nor constant, it is
18328 a DWARF expression rather than location description. For that
18329 loc_list_from_tree (value, 0, &context) is needed. */
18330 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
18331 if (list2
&& single_element_loc_list_p (list2
))
18333 add_AT_loc (die
, attr
, list2
->expr
);
18338 /* If that failed to give a single element location list, fall back to
18339 outputting this as a reference... still if permitted. */
18340 if (list
== NULL
|| (forms
& dw_scalar_form_reference
) == 0)
18343 if (current_function_decl
== 0)
18344 context_die
= comp_unit_die ();
18346 context_die
= lookup_decl_die (current_function_decl
);
18348 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
18349 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
18350 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
18352 add_AT_location_description (decl_die
, DW_AT_location
, list
);
18353 add_AT_die_ref (die
, attr
, decl_die
);
18356 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
18360 lower_bound_default (void)
18362 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
18368 case DW_LANG_C_plus_plus
:
18369 case DW_LANG_C_plus_plus_11
:
18370 case DW_LANG_C_plus_plus_14
:
18372 case DW_LANG_ObjC_plus_plus
:
18375 case DW_LANG_Fortran77
:
18376 case DW_LANG_Fortran90
:
18377 case DW_LANG_Fortran95
:
18378 case DW_LANG_Fortran03
:
18379 case DW_LANG_Fortran08
:
18383 case DW_LANG_Python
:
18384 return dwarf_version
>= 4 ? 0 : -1;
18385 case DW_LANG_Ada95
:
18386 case DW_LANG_Ada83
:
18387 case DW_LANG_Cobol74
:
18388 case DW_LANG_Cobol85
:
18389 case DW_LANG_Pascal83
:
18390 case DW_LANG_Modula2
:
18392 return dwarf_version
>= 4 ? 1 : -1;
18398 /* Given a tree node describing an array bound (either lower or upper) output
18399 a representation for that bound. */
18402 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
18403 tree bound
, const struct loc_descr_context
*context
)
18408 switch (TREE_CODE (bound
))
18410 /* Strip all conversions. */
18412 case VIEW_CONVERT_EXPR
:
18413 bound
= TREE_OPERAND (bound
, 0);
18416 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
18417 are even omitted when they are the default. */
18419 /* If the value for this bound is the default one, we can even omit the
18421 if (bound_attr
== DW_AT_lower_bound
18422 && tree_fits_shwi_p (bound
)
18423 && (dflt
= lower_bound_default ()) != -1
18424 && tree_to_shwi (bound
) == dflt
)
18430 /* Because of the complex interaction there can be with other GNAT
18431 encodings, GDB isn't ready yet to handle proper DWARF description
18432 for self-referencial subrange bounds: let GNAT encodings do the
18433 magic in such a case. */
18434 if (gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
18435 && contains_placeholder_p (bound
))
18438 add_scalar_info (subrange_die
, bound_attr
, bound
,
18439 dw_scalar_form_constant
18440 | dw_scalar_form_exprloc
18441 | dw_scalar_form_reference
,
18447 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
18448 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
18449 Note that the block of subscript information for an array type also
18450 includes information about the element type of the given array type.
18452 This function reuses previously set type and bound information if
18456 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
18458 unsigned dimension_number
;
18460 dw_die_ref child
= type_die
->die_child
;
18462 for (dimension_number
= 0;
18463 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
18464 type
= TREE_TYPE (type
), dimension_number
++)
18466 tree domain
= TYPE_DOMAIN (type
);
18468 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
18471 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
18472 and (in GNU C only) variable bounds. Handle all three forms
18475 /* Find and reuse a previously generated DW_TAG_subrange_type if
18478 For multi-dimensional arrays, as we iterate through the
18479 various dimensions in the enclosing for loop above, we also
18480 iterate through the DIE children and pick at each
18481 DW_TAG_subrange_type previously generated (if available).
18482 Each child DW_TAG_subrange_type DIE describes the range of
18483 the current dimension. At this point we should have as many
18484 DW_TAG_subrange_type's as we have dimensions in the
18486 dw_die_ref subrange_die
= NULL
;
18490 child
= child
->die_sib
;
18491 if (child
->die_tag
== DW_TAG_subrange_type
)
18492 subrange_die
= child
;
18493 if (child
== type_die
->die_child
)
18495 /* If we wrapped around, stop looking next time. */
18499 if (child
->die_tag
== DW_TAG_subrange_type
)
18503 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
18507 /* We have an array type with specified bounds. */
18508 lower
= TYPE_MIN_VALUE (domain
);
18509 upper
= TYPE_MAX_VALUE (domain
);
18511 /* Define the index type. */
18512 if (TREE_TYPE (domain
)
18513 && !get_AT (subrange_die
, DW_AT_type
))
18515 /* ??? This is probably an Ada unnamed subrange type. Ignore the
18516 TREE_TYPE field. We can't emit debug info for this
18517 because it is an unnamed integral type. */
18518 if (TREE_CODE (domain
) == INTEGER_TYPE
18519 && TYPE_NAME (domain
) == NULL_TREE
18520 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
18521 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
18524 add_type_attribute (subrange_die
, TREE_TYPE (domain
),
18525 TYPE_UNQUALIFIED
, false, type_die
);
18528 /* ??? If upper is NULL, the array has unspecified length,
18529 but it does have a lower bound. This happens with Fortran
18531 Since the debugger is definitely going to need to know N
18532 to produce useful results, go ahead and output the lower
18533 bound solo, and hope the debugger can cope. */
18535 if (!get_AT (subrange_die
, DW_AT_lower_bound
))
18536 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
18537 if (upper
&& !get_AT (subrange_die
, DW_AT_upper_bound
))
18538 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
18541 /* Otherwise we have an array type with an unspecified length. The
18542 DWARF-2 spec does not say how to handle this; let's just leave out the
18547 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
18550 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
18552 dw_die_ref decl_die
;
18553 HOST_WIDE_INT size
;
18554 dw_loc_descr_ref size_expr
= NULL
;
18556 switch (TREE_CODE (tree_node
))
18561 case ENUMERAL_TYPE
:
18564 case QUAL_UNION_TYPE
:
18565 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
18566 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
18568 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
18571 size_expr
= type_byte_size (tree_node
, &size
);
18574 /* For a data member of a struct or union, the DW_AT_byte_size is
18575 generally given as the number of bytes normally allocated for an
18576 object of the *declared* type of the member itself. This is true
18577 even for bit-fields. */
18578 size
= int_size_in_bytes (field_type (tree_node
));
18581 gcc_unreachable ();
18584 /* Support for dynamically-sized objects was introduced by DWARFv3.
18585 At the moment, GDB does not handle variable byte sizes very well,
18587 if ((dwarf_version
>= 3 || !dwarf_strict
)
18588 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
18589 && size_expr
!= NULL
)
18590 add_AT_loc (die
, DW_AT_byte_size
, size_expr
);
18592 /* Note that `size' might be -1 when we get to this point. If it is, that
18593 indicates that the byte size of the entity in question is variable and
18594 that we could not generate a DWARF expression that computes it. */
18596 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
18599 /* For a FIELD_DECL node which represents a bit-field, output an attribute
18600 which specifies the distance in bits from the highest order bit of the
18601 "containing object" for the bit-field to the highest order bit of the
18604 For any given bit-field, the "containing object" is a hypothetical object
18605 (of some integral or enum type) within which the given bit-field lives. The
18606 type of this hypothetical "containing object" is always the same as the
18607 declared type of the individual bit-field itself. The determination of the
18608 exact location of the "containing object" for a bit-field is rather
18609 complicated. It's handled by the `field_byte_offset' function (above).
18611 CTX is required: see the comment for VLR_CONTEXT.
18613 Note that it is the size (in bytes) of the hypothetical "containing object"
18614 which will be given in the DW_AT_byte_size attribute for this bit-field.
18615 (See `byte_size_attribute' above). */
18618 add_bit_offset_attribute (dw_die_ref die
, tree decl
, struct vlr_context
*ctx
)
18620 HOST_WIDE_INT object_offset_in_bytes
;
18621 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
18622 HOST_WIDE_INT bitpos_int
;
18623 HOST_WIDE_INT highest_order_object_bit_offset
;
18624 HOST_WIDE_INT highest_order_field_bit_offset
;
18625 HOST_WIDE_INT bit_offset
;
18627 field_byte_offset (decl
, ctx
, &object_offset_in_bytes
);
18629 /* Must be a field and a bit field. */
18630 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
18632 /* We can't yet handle bit-fields whose offsets are variable, so if we
18633 encounter such things, just return without generating any attribute
18634 whatsoever. Likewise for variable or too large size. */
18635 if (! tree_fits_shwi_p (bit_position (decl
))
18636 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
18639 bitpos_int
= int_bit_position (decl
);
18641 /* Note that the bit offset is always the distance (in bits) from the
18642 highest-order bit of the "containing object" to the highest-order bit of
18643 the bit-field itself. Since the "high-order end" of any object or field
18644 is different on big-endian and little-endian machines, the computation
18645 below must take account of these differences. */
18646 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
18647 highest_order_field_bit_offset
= bitpos_int
;
18649 if (! BYTES_BIG_ENDIAN
)
18651 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
18652 highest_order_object_bit_offset
+=
18653 simple_type_size_in_bits (original_type
);
18657 = (! BYTES_BIG_ENDIAN
18658 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
18659 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
18661 if (bit_offset
< 0)
18662 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
18664 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
18667 /* For a FIELD_DECL node which represents a bit field, output an attribute
18668 which specifies the length in bits of the given field. */
18671 add_bit_size_attribute (dw_die_ref die
, tree decl
)
18673 /* Must be a field and a bit field. */
18674 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
18675 && DECL_BIT_FIELD_TYPE (decl
));
18677 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
18678 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
18681 /* If the compiled language is ANSI C, then add a 'prototyped'
18682 attribute, if arg types are given for the parameters of a function. */
18685 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
18687 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
18694 if (prototype_p (func_type
))
18695 add_AT_flag (die
, DW_AT_prototyped
, 1);
18702 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
18703 by looking in the type declaration, the object declaration equate table or
18704 the block mapping. */
18706 static inline dw_die_ref
18707 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
18709 dw_die_ref origin_die
= NULL
;
18711 if (TREE_CODE (origin
) != FUNCTION_DECL
18712 && TREE_CODE (origin
) != BLOCK
)
18714 /* We may have gotten separated from the block for the inlined
18715 function, if we're in an exception handler or some such; make
18716 sure that the abstract function has been written out.
18718 Doing this for nested functions is wrong, however; functions are
18719 distinct units, and our context might not even be inline. */
18723 fn
= TYPE_STUB_DECL (fn
);
18725 fn
= decl_function_context (fn
);
18727 dwarf2out_abstract_function (fn
);
18730 if (DECL_P (origin
))
18731 origin_die
= lookup_decl_die (origin
);
18732 else if (TYPE_P (origin
))
18733 origin_die
= lookup_type_die (origin
);
18734 else if (TREE_CODE (origin
) == BLOCK
)
18735 origin_die
= BLOCK_DIE (origin
);
18737 /* XXX: Functions that are never lowered don't always have correct block
18738 trees (in the case of java, they simply have no block tree, in some other
18739 languages). For these functions, there is nothing we can really do to
18740 output correct debug info for inlined functions in all cases. Rather
18741 than die, we'll just produce deficient debug info now, in that we will
18742 have variables without a proper abstract origin. In the future, when all
18743 functions are lowered, we should re-add a gcc_assert (origin_die)
18747 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
18751 /* We do not currently support the pure_virtual attribute. */
18754 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
18756 if (DECL_VINDEX (func_decl
))
18758 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
18760 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
18761 add_AT_loc (die
, DW_AT_vtable_elem_location
,
18762 new_loc_descr (DW_OP_constu
,
18763 tree_to_shwi (DECL_VINDEX (func_decl
)),
18766 /* GNU extension: Record what type this method came from originally. */
18767 if (debug_info_level
> DINFO_LEVEL_TERSE
18768 && DECL_CONTEXT (func_decl
))
18769 add_AT_die_ref (die
, DW_AT_containing_type
,
18770 lookup_type_die (DECL_CONTEXT (func_decl
)));
18774 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
18775 given decl. This used to be a vendor extension until after DWARF 4
18776 standardized it. */
18779 add_linkage_attr (dw_die_ref die
, tree decl
)
18781 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
18783 /* Mimic what assemble_name_raw does with a leading '*'. */
18784 if (name
[0] == '*')
18787 if (dwarf_version
>= 4)
18788 add_AT_string (die
, DW_AT_linkage_name
, name
);
18790 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
18793 /* Add source coordinate attributes for the given decl. */
18796 add_src_coords_attributes (dw_die_ref die
, tree decl
)
18798 expanded_location s
;
18800 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
18802 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18803 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
18804 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
18807 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
18810 add_linkage_name_raw (dw_die_ref die
, tree decl
)
18812 /* Defer until we have an assembler name set. */
18813 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
18815 limbo_die_node
*asm_name
;
18817 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
18818 asm_name
->die
= die
;
18819 asm_name
->created_for
= decl
;
18820 asm_name
->next
= deferred_asm_name
;
18821 deferred_asm_name
= asm_name
;
18823 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
18824 add_linkage_attr (die
, decl
);
18827 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
18830 add_linkage_name (dw_die_ref die
, tree decl
)
18832 if (debug_info_level
> DINFO_LEVEL_NONE
18833 && (TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
18834 && TREE_PUBLIC (decl
)
18835 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
18836 && die
->die_tag
!= DW_TAG_member
)
18837 add_linkage_name_raw (die
, decl
);
18840 /* Add a DW_AT_name attribute and source coordinate attribute for the
18841 given decl, but only if it actually has a name. */
18844 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
18848 decl_name
= DECL_NAME (decl
);
18849 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
18851 const char *name
= dwarf2_name (decl
, 0);
18853 add_name_attribute (die
, name
);
18854 if (! DECL_ARTIFICIAL (decl
))
18855 add_src_coords_attributes (die
, decl
);
18857 add_linkage_name (die
, decl
);
18860 #ifdef VMS_DEBUGGING_INFO
18861 /* Get the function's name, as described by its RTL. This may be different
18862 from the DECL_NAME name used in the source file. */
18863 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
18865 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
18866 XEXP (DECL_RTL (decl
), 0), false);
18867 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
18869 #endif /* VMS_DEBUGGING_INFO */
18872 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
18875 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
18879 attr
.dw_attr
= DW_AT_discr_value
;
18880 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
18881 attr
.dw_attr_val
.val_entry
= NULL
;
18882 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
18884 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
18886 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
18887 add_dwarf_attr (die
, &attr
);
18890 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
18893 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
18897 attr
.dw_attr
= DW_AT_discr_list
;
18898 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
18899 attr
.dw_attr_val
.val_entry
= NULL
;
18900 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
18901 add_dwarf_attr (die
, &attr
);
18904 static inline dw_discr_list_ref
18905 AT_discr_list (dw_attr_node
*attr
)
18907 return attr
->dw_attr_val
.v
.val_discr_list
;
18910 #ifdef VMS_DEBUGGING_INFO
18911 /* Output the debug main pointer die for VMS */
18914 dwarf2out_vms_debug_main_pointer (void)
18916 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
18919 /* Allocate the VMS debug main subprogram die. */
18920 die
= ggc_cleared_alloc
<die_node
> ();
18921 die
->die_tag
= DW_TAG_subprogram
;
18922 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
18923 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
18924 current_function_funcdef_no
);
18925 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
18927 /* Make it the first child of comp_unit_die (). */
18928 die
->die_parent
= comp_unit_die ();
18929 if (comp_unit_die ()->die_child
)
18931 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
18932 comp_unit_die ()->die_child
->die_sib
= die
;
18936 die
->die_sib
= die
;
18937 comp_unit_die ()->die_child
= die
;
18940 #endif /* VMS_DEBUGGING_INFO */
18942 /* Push a new declaration scope. */
18945 push_decl_scope (tree scope
)
18947 vec_safe_push (decl_scope_table
, scope
);
18950 /* Pop a declaration scope. */
18953 pop_decl_scope (void)
18955 decl_scope_table
->pop ();
18958 /* walk_tree helper function for uses_local_type, below. */
18961 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
18964 *walk_subtrees
= 0;
18967 tree name
= TYPE_NAME (*tp
);
18968 if (name
&& DECL_P (name
) && decl_function_context (name
))
18974 /* If TYPE involves a function-local type (including a local typedef to a
18975 non-local type), returns that type; otherwise returns NULL_TREE. */
18978 uses_local_type (tree type
)
18980 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
18984 /* Return the DIE for the scope that immediately contains this type.
18985 Non-named types that do not involve a function-local type get global
18986 scope. Named types nested in namespaces or other types get their
18987 containing scope. All other types (i.e. function-local named types) get
18988 the current active scope. */
18991 scope_die_for (tree t
, dw_die_ref context_die
)
18993 dw_die_ref scope_die
= NULL
;
18994 tree containing_scope
;
18996 /* Non-types always go in the current scope. */
18997 gcc_assert (TYPE_P (t
));
18999 /* Use the scope of the typedef, rather than the scope of the type
19001 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
19002 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
19004 containing_scope
= TYPE_CONTEXT (t
);
19006 /* Use the containing namespace if there is one. */
19007 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
19009 if (context_die
== lookup_decl_die (containing_scope
))
19011 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
19012 context_die
= get_context_die (containing_scope
);
19014 containing_scope
= NULL_TREE
;
19017 /* Ignore function type "scopes" from the C frontend. They mean that
19018 a tagged type is local to a parmlist of a function declarator, but
19019 that isn't useful to DWARF. */
19020 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
19021 containing_scope
= NULL_TREE
;
19023 if (SCOPE_FILE_SCOPE_P (containing_scope
))
19025 /* If T uses a local type keep it local as well, to avoid references
19026 to function-local DIEs from outside the function. */
19027 if (current_function_decl
&& uses_local_type (t
))
19028 scope_die
= context_die
;
19030 scope_die
= comp_unit_die ();
19032 else if (TYPE_P (containing_scope
))
19034 /* For types, we can just look up the appropriate DIE. */
19035 if (debug_info_level
> DINFO_LEVEL_TERSE
)
19036 scope_die
= get_context_die (containing_scope
);
19039 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
19040 if (scope_die
== NULL
)
19041 scope_die
= comp_unit_die ();
19045 scope_die
= context_die
;
19050 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
19053 local_scope_p (dw_die_ref context_die
)
19055 for (; context_die
; context_die
= context_die
->die_parent
)
19056 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
19057 || context_die
->die_tag
== DW_TAG_subprogram
)
19063 /* Returns nonzero if CONTEXT_DIE is a class. */
19066 class_scope_p (dw_die_ref context_die
)
19068 return (context_die
19069 && (context_die
->die_tag
== DW_TAG_structure_type
19070 || context_die
->die_tag
== DW_TAG_class_type
19071 || context_die
->die_tag
== DW_TAG_interface_type
19072 || context_die
->die_tag
== DW_TAG_union_type
));
19075 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
19076 whether or not to treat a DIE in this context as a declaration. */
19079 class_or_namespace_scope_p (dw_die_ref context_die
)
19081 return (class_scope_p (context_die
)
19082 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
19085 /* Many forms of DIEs require a "type description" attribute. This
19086 routine locates the proper "type descriptor" die for the type given
19087 by 'type' plus any additional qualifiers given by 'cv_quals', and
19088 adds a DW_AT_type attribute below the given die. */
19091 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
19092 bool reverse
, dw_die_ref context_die
)
19094 enum tree_code code
= TREE_CODE (type
);
19095 dw_die_ref type_die
= NULL
;
19097 /* ??? If this type is an unnamed subrange type of an integral, floating-point
19098 or fixed-point type, use the inner type. This is because we have no
19099 support for unnamed types in base_type_die. This can happen if this is
19100 an Ada subrange type. Correct solution is emit a subrange type die. */
19101 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
19102 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
19103 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
19105 if (code
== ERROR_MARK
19106 /* Handle a special case. For functions whose return type is void, we
19107 generate *no* type attribute. (Note that no object may have type
19108 `void', so this only applies to function return types). */
19109 || code
== VOID_TYPE
)
19112 type_die
= modified_type_die (type
,
19113 cv_quals
| TYPE_QUALS_NO_ADDR_SPACE (type
),
19117 if (type_die
!= NULL
)
19118 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
19121 /* Given an object die, add the calling convention attribute for the
19122 function call type. */
19124 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
19126 enum dwarf_calling_convention value
= DW_CC_normal
;
19128 value
= ((enum dwarf_calling_convention
)
19129 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
19132 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
19134 /* DWARF 2 doesn't provide a way to identify a program's source-level
19135 entry point. DW_AT_calling_convention attributes are only meant
19136 to describe functions' calling conventions. However, lacking a
19137 better way to signal the Fortran main program, we used this for
19138 a long time, following existing custom. Now, DWARF 4 has
19139 DW_AT_main_subprogram, which we add below, but some tools still
19140 rely on the old way, which we thus keep. */
19141 value
= DW_CC_program
;
19143 if (dwarf_version
>= 4 || !dwarf_strict
)
19144 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
19147 /* Only add the attribute if the backend requests it, and
19148 is not DW_CC_normal. */
19149 if (value
&& (value
!= DW_CC_normal
))
19150 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
19153 /* Given a tree pointer to a struct, class, union, or enum type node, return
19154 a pointer to the (string) tag name for the given type, or zero if the type
19155 was declared without a tag. */
19157 static const char *
19158 type_tag (const_tree type
)
19160 const char *name
= 0;
19162 if (TYPE_NAME (type
) != 0)
19166 /* Find the IDENTIFIER_NODE for the type name. */
19167 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
19168 && !TYPE_NAMELESS (type
))
19169 t
= TYPE_NAME (type
);
19171 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
19172 a TYPE_DECL node, regardless of whether or not a `typedef' was
19174 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
19175 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
19177 /* We want to be extra verbose. Don't call dwarf_name if
19178 DECL_NAME isn't set. The default hook for decl_printable_name
19179 doesn't like that, and in this context it's correct to return
19180 0, instead of "<anonymous>" or the like. */
19181 if (DECL_NAME (TYPE_NAME (type
))
19182 && !DECL_NAMELESS (TYPE_NAME (type
)))
19183 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
19186 /* Now get the name as a string, or invent one. */
19187 if (!name
&& t
!= 0)
19188 name
= IDENTIFIER_POINTER (t
);
19191 return (name
== 0 || *name
== '\0') ? 0 : name
;
19194 /* Return the type associated with a data member, make a special check
19195 for bit field types. */
19198 member_declared_type (const_tree member
)
19200 return (DECL_BIT_FIELD_TYPE (member
)
19201 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
19204 /* Get the decl's label, as described by its RTL. This may be different
19205 from the DECL_NAME name used in the source file. */
19208 static const char *
19209 decl_start_label (tree decl
)
19212 const char *fnname
;
19214 x
= DECL_RTL (decl
);
19215 gcc_assert (MEM_P (x
));
19218 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
19220 fnname
= XSTR (x
, 0);
19225 /* For variable-length arrays that have been previously generated, but
19226 may be incomplete due to missing subscript info, fill the subscript
19227 info. Return TRUE if this is one of those cases. */
19229 fill_variable_array_bounds (tree type
)
19231 if (TREE_ASM_WRITTEN (type
)
19232 && TREE_CODE (type
) == ARRAY_TYPE
19233 && variably_modified_type_p (type
, NULL
))
19235 dw_die_ref array_die
= lookup_type_die (type
);
19238 add_subscript_info (array_die
, type
, !is_ada ());
19244 /* These routines generate the internal representation of the DIE's for
19245 the compilation unit. Debugging information is collected by walking
19246 the declaration trees passed in from dwarf2out_decl(). */
19249 gen_array_type_die (tree type
, dw_die_ref context_die
)
19251 dw_die_ref array_die
;
19253 /* GNU compilers represent multidimensional array types as sequences of one
19254 dimensional array types whose element types are themselves array types.
19255 We sometimes squish that down to a single array_type DIE with multiple
19256 subscripts in the Dwarf debugging info. The draft Dwarf specification
19257 say that we are allowed to do this kind of compression in C, because
19258 there is no difference between an array of arrays and a multidimensional
19259 array. We don't do this for Ada to remain as close as possible to the
19260 actual representation, which is especially important against the language
19261 flexibilty wrt arrays of variable size. */
19263 bool collapse_nested_arrays
= !is_ada ();
19265 if (fill_variable_array_bounds (type
))
19268 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
19271 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
19272 DW_TAG_string_type doesn't have DW_AT_type attribute). */
19273 if (TYPE_STRING_FLAG (type
)
19274 && TREE_CODE (type
) == ARRAY_TYPE
19276 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
19278 HOST_WIDE_INT size
;
19280 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
19281 add_name_attribute (array_die
, type_tag (type
));
19282 equate_type_number_to_die (type
, array_die
);
19283 size
= int_size_in_bytes (type
);
19285 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
19286 else if (TYPE_DOMAIN (type
) != NULL_TREE
19287 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
19288 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
19290 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
19291 dw_loc_list_ref loc
= loc_list_from_tree (szdecl
, 2, NULL
);
19293 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
19294 if (loc
&& size
> 0)
19296 add_AT_location_description (array_die
, DW_AT_string_length
, loc
);
19297 if (size
!= DWARF2_ADDR_SIZE
)
19298 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
19304 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
19305 add_name_attribute (array_die
, type_tag (type
));
19306 equate_type_number_to_die (type
, array_die
);
19308 if (TREE_CODE (type
) == VECTOR_TYPE
)
19309 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
19311 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
19313 && TREE_CODE (type
) == ARRAY_TYPE
19314 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
19315 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
19316 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
19319 /* We default the array ordering. SDB will probably do
19320 the right things even if DW_AT_ordering is not present. It's not even
19321 an issue until we start to get into multidimensional arrays anyway. If
19322 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
19323 then we'll have to put the DW_AT_ordering attribute back in. (But if
19324 and when we find out that we need to put these in, we will only do so
19325 for multidimensional arrays. */
19326 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
19329 if (TREE_CODE (type
) == VECTOR_TYPE
)
19331 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
19332 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
19333 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
, NULL
);
19334 add_bound_info (subrange_die
, DW_AT_upper_bound
,
19335 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
19338 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
19340 /* Add representation of the type of the elements of this array type and
19341 emit the corresponding DIE if we haven't done it already. */
19342 element_type
= TREE_TYPE (type
);
19343 if (collapse_nested_arrays
)
19344 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
19346 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
19348 element_type
= TREE_TYPE (element_type
);
19351 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
19352 TREE_CODE (type
) == ARRAY_TYPE
19353 && TYPE_REVERSE_STORAGE_ORDER (type
),
19356 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
19357 if (TYPE_ARTIFICIAL (type
))
19358 add_AT_flag (array_die
, DW_AT_artificial
, 1);
19360 if (get_AT (array_die
, DW_AT_name
))
19361 add_pubtype (type
, array_die
);
19364 /* This routine generates DIE for array with hidden descriptor, details
19365 are filled into *info by a langhook. */
19368 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
19369 dw_die_ref context_die
)
19371 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
19372 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
19373 const struct loc_descr_context context
= { type
, info
->base_decl
, NULL
};
19376 add_name_attribute (array_die
, type_tag (type
));
19377 equate_type_number_to_die (type
, array_die
);
19379 if (info
->ndimensions
> 1)
19380 switch (info
->ordering
)
19382 case array_descr_ordering_row_major
:
19383 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
19385 case array_descr_ordering_column_major
:
19386 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
19392 if (dwarf_version
>= 3 || !dwarf_strict
)
19394 if (info
->data_location
)
19395 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
19396 dw_scalar_form_exprloc
, &context
);
19397 if (info
->associated
)
19398 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
19399 dw_scalar_form_constant
19400 | dw_scalar_form_exprloc
19401 | dw_scalar_form_reference
, &context
);
19402 if (info
->allocated
)
19403 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
19404 dw_scalar_form_constant
19405 | dw_scalar_form_exprloc
19406 | dw_scalar_form_reference
, &context
);
19409 const enum dwarf_attribute attr
19410 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
19412 = (info
->stride_in_bits
)
19413 ? dw_scalar_form_constant
19414 : (dw_scalar_form_constant
19415 | dw_scalar_form_exprloc
19416 | dw_scalar_form_reference
);
19418 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
19422 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
19424 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
19426 dw_die_ref subrange_die
19427 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
19429 if (info
->dimen
[dim
].bounds_type
)
19430 add_type_attribute (subrange_die
,
19431 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
19432 false, context_die
);
19433 if (info
->dimen
[dim
].lower_bound
)
19434 add_bound_info (subrange_die
, DW_AT_lower_bound
,
19435 info
->dimen
[dim
].lower_bound
, &context
);
19436 if (info
->dimen
[dim
].upper_bound
)
19437 add_bound_info (subrange_die
, DW_AT_upper_bound
,
19438 info
->dimen
[dim
].upper_bound
, &context
);
19439 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
19440 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
19441 info
->dimen
[dim
].stride
,
19442 dw_scalar_form_constant
19443 | dw_scalar_form_exprloc
19444 | dw_scalar_form_reference
,
19448 gen_type_die (info
->element_type
, context_die
);
19449 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
19450 TREE_CODE (type
) == ARRAY_TYPE
19451 && TYPE_REVERSE_STORAGE_ORDER (type
),
19454 if (get_AT (array_die
, DW_AT_name
))
19455 add_pubtype (type
, array_die
);
19460 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
19462 tree origin
= decl_ultimate_origin (decl
);
19463 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
19465 if (origin
!= NULL
)
19466 add_abstract_origin_attribute (decl_die
, origin
);
19469 add_name_and_src_coords_attributes (decl_die
, decl
);
19470 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
19471 TYPE_UNQUALIFIED
, false, context_die
);
19474 if (DECL_ABSTRACT_P (decl
))
19475 equate_decl_number_to_die (decl
, decl_die
);
19477 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
19481 /* Walk through the list of incomplete types again, trying once more to
19482 emit full debugging info for them. */
19485 retry_incomplete_types (void)
19490 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
19491 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
19492 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
19493 vec_safe_truncate (incomplete_types
, 0);
19496 /* Determine what tag to use for a record type. */
19498 static enum dwarf_tag
19499 record_type_tag (tree type
)
19501 if (! lang_hooks
.types
.classify_record
)
19502 return DW_TAG_structure_type
;
19504 switch (lang_hooks
.types
.classify_record (type
))
19506 case RECORD_IS_STRUCT
:
19507 return DW_TAG_structure_type
;
19509 case RECORD_IS_CLASS
:
19510 return DW_TAG_class_type
;
19512 case RECORD_IS_INTERFACE
:
19513 if (dwarf_version
>= 3 || !dwarf_strict
)
19514 return DW_TAG_interface_type
;
19515 return DW_TAG_structure_type
;
19518 gcc_unreachable ();
19522 /* Generate a DIE to represent an enumeration type. Note that these DIEs
19523 include all of the information about the enumeration values also. Each
19524 enumerated type name/value is listed as a child of the enumerated type
19528 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
19530 dw_die_ref type_die
= lookup_type_die (type
);
19532 if (type_die
== NULL
)
19534 type_die
= new_die (DW_TAG_enumeration_type
,
19535 scope_die_for (type
, context_die
), type
);
19536 equate_type_number_to_die (type
, type_die
);
19537 add_name_attribute (type_die
, type_tag (type
));
19538 if (dwarf_version
>= 4 || !dwarf_strict
)
19540 if (ENUM_IS_SCOPED (type
))
19541 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
19542 if (ENUM_IS_OPAQUE (type
))
19543 add_AT_flag (type_die
, DW_AT_declaration
, 1);
19546 else if (! TYPE_SIZE (type
))
19549 remove_AT (type_die
, DW_AT_declaration
);
19551 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
19552 given enum type is incomplete, do not generate the DW_AT_byte_size
19553 attribute or the DW_AT_element_list attribute. */
19554 if (TYPE_SIZE (type
))
19558 TREE_ASM_WRITTEN (type
) = 1;
19559 add_byte_size_attribute (type_die
, type
);
19560 if (dwarf_version
>= 3 || !dwarf_strict
)
19562 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
19563 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
19566 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
19568 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
19569 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
19572 /* If the first reference to this type was as the return type of an
19573 inline function, then it may not have a parent. Fix this now. */
19574 if (type_die
->die_parent
== NULL
)
19575 add_child_die (scope_die_for (type
, context_die
), type_die
);
19577 for (link
= TYPE_VALUES (type
);
19578 link
!= NULL
; link
= TREE_CHAIN (link
))
19580 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
19581 tree value
= TREE_VALUE (link
);
19583 add_name_attribute (enum_die
,
19584 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
19586 if (TREE_CODE (value
) == CONST_DECL
)
19587 value
= DECL_INITIAL (value
);
19589 if (simple_type_size_in_bits (TREE_TYPE (value
))
19590 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
19592 /* For constant forms created by add_AT_unsigned DWARF
19593 consumers (GDB, elfutils, etc.) always zero extend
19594 the value. Only when the actual value is negative
19595 do we need to use add_AT_int to generate a constant
19596 form that can represent negative values. */
19597 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
19598 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
19599 add_AT_unsigned (enum_die
, DW_AT_const_value
,
19600 (unsigned HOST_WIDE_INT
) val
);
19602 add_AT_int (enum_die
, DW_AT_const_value
, val
);
19605 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
19606 that here. TODO: This should be re-worked to use correct
19607 signed/unsigned double tags for all cases. */
19608 add_AT_wide (enum_die
, DW_AT_const_value
, value
);
19611 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
19612 if (TYPE_ARTIFICIAL (type
))
19613 add_AT_flag (type_die
, DW_AT_artificial
, 1);
19616 add_AT_flag (type_die
, DW_AT_declaration
, 1);
19618 add_pubtype (type
, type_die
);
19623 /* Generate a DIE to represent either a real live formal parameter decl or to
19624 represent just the type of some formal parameter position in some function
19627 Note that this routine is a bit unusual because its argument may be a
19628 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
19629 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
19630 node. If it's the former then this function is being called to output a
19631 DIE to represent a formal parameter object (or some inlining thereof). If
19632 it's the latter, then this function is only being called to output a
19633 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
19634 argument type of some subprogram type.
19635 If EMIT_NAME_P is true, name and source coordinate attributes
19639 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
19640 dw_die_ref context_die
)
19642 tree node_or_origin
= node
? node
: origin
;
19643 tree ultimate_origin
;
19644 dw_die_ref parm_die
= NULL
;
19646 if (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)) == tcc_declaration
)
19648 parm_die
= lookup_decl_die (node
);
19650 /* If the contexts differ, we may not be talking about the same
19652 if (parm_die
&& parm_die
->die_parent
!= context_die
)
19654 if (!DECL_ABSTRACT_P (node
))
19656 /* This can happen when creating an inlined instance, in
19657 which case we need to create a new DIE that will get
19658 annotated with DW_AT_abstract_origin. */
19663 /* FIXME: Reuse DIE even with a differing context.
19665 This can happen when calling
19666 dwarf2out_abstract_function to build debug info for
19667 the abstract instance of a function for which we have
19668 already generated a DIE in
19669 dwarf2out_early_global_decl.
19671 Once we remove dwarf2out_abstract_function, we should
19672 have a call to gcc_unreachable here. */
19676 if (parm_die
&& parm_die
->die_parent
== NULL
)
19678 /* Check that parm_die already has the right attributes that
19679 we would have added below. If any attributes are
19680 missing, fall through to add them. */
19681 if (! DECL_ABSTRACT_P (node_or_origin
)
19682 && !get_AT (parm_die
, DW_AT_location
)
19683 && !get_AT (parm_die
, DW_AT_const_value
))
19684 /* We are missing location info, and are about to add it. */
19688 add_child_die (context_die
, parm_die
);
19694 /* If we have a previously generated DIE, use it, unless this is an
19695 concrete instance (origin != NULL), in which case we need a new
19696 DIE with a corresponding DW_AT_abstract_origin. */
19698 if (parm_die
&& origin
== NULL
)
19699 reusing_die
= true;
19702 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
19703 reusing_die
= false;
19706 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
19708 case tcc_declaration
:
19709 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
19710 if (node
|| ultimate_origin
)
19711 origin
= ultimate_origin
;
19716 if (origin
!= NULL
)
19717 add_abstract_origin_attribute (parm_die
, origin
);
19718 else if (emit_name_p
)
19719 add_name_and_src_coords_attributes (parm_die
, node
);
19721 || (! DECL_ABSTRACT_P (node_or_origin
)
19722 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
19723 decl_function_context
19724 (node_or_origin
))))
19726 tree type
= TREE_TYPE (node_or_origin
);
19727 if (decl_by_reference_p (node_or_origin
))
19728 add_type_attribute (parm_die
, TREE_TYPE (type
),
19730 false, context_die
);
19732 add_type_attribute (parm_die
, type
,
19733 decl_quals (node_or_origin
),
19734 false, context_die
);
19736 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
19737 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
19739 if (node
&& node
!= origin
)
19740 equate_decl_number_to_die (node
, parm_die
);
19741 if (! DECL_ABSTRACT_P (node_or_origin
))
19742 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
19748 /* We were called with some kind of a ..._TYPE node. */
19749 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
19754 gcc_unreachable ();
19760 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
19761 children DW_TAG_formal_parameter DIEs representing the arguments of the
19764 PARM_PACK must be a function parameter pack.
19765 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
19766 must point to the subsequent arguments of the function PACK_ARG belongs to.
19767 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
19768 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
19769 following the last one for which a DIE was generated. */
19772 gen_formal_parameter_pack_die (tree parm_pack
,
19774 dw_die_ref subr_die
,
19778 dw_die_ref parm_pack_die
;
19780 gcc_assert (parm_pack
19781 && lang_hooks
.function_parameter_pack_p (parm_pack
)
19784 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
19785 add_src_coords_attributes (parm_pack_die
, parm_pack
);
19787 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
19789 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
19792 gen_formal_parameter_die (arg
, NULL
,
19793 false /* Don't emit name attribute. */,
19798 return parm_pack_die
;
19801 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
19802 at the end of an (ANSI prototyped) formal parameters list. */
19805 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
19807 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
19810 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
19811 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
19812 parameters as specified in some function type specification (except for
19813 those which appear as part of a function *definition*). */
19816 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
19819 tree formal_type
= NULL
;
19820 tree first_parm_type
;
19823 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
19825 arg
= DECL_ARGUMENTS (function_or_method_type
);
19826 function_or_method_type
= TREE_TYPE (function_or_method_type
);
19831 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
19833 /* Make our first pass over the list of formal parameter types and output a
19834 DW_TAG_formal_parameter DIE for each one. */
19835 for (link
= first_parm_type
; link
; )
19837 dw_die_ref parm_die
;
19839 formal_type
= TREE_VALUE (link
);
19840 if (formal_type
== void_type_node
)
19843 /* Output a (nameless) DIE to represent the formal parameter itself. */
19844 if (!POINTER_BOUNDS_TYPE_P (formal_type
))
19846 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
19847 true /* Emit name attribute. */,
19849 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
19850 && link
== first_parm_type
)
19852 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
19853 if (dwarf_version
>= 3 || !dwarf_strict
)
19854 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
19856 else if (arg
&& DECL_ARTIFICIAL (arg
))
19857 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
19860 link
= TREE_CHAIN (link
);
19862 arg
= DECL_CHAIN (arg
);
19865 /* If this function type has an ellipsis, add a
19866 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
19867 if (formal_type
!= void_type_node
)
19868 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
19870 /* Make our second (and final) pass over the list of formal parameter types
19871 and output DIEs to represent those types (as necessary). */
19872 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
19873 link
&& TREE_VALUE (link
);
19874 link
= TREE_CHAIN (link
))
19875 gen_type_die (TREE_VALUE (link
), context_die
);
19878 /* We want to generate the DIE for TYPE so that we can generate the
19879 die for MEMBER, which has been defined; we will need to refer back
19880 to the member declaration nested within TYPE. If we're trying to
19881 generate minimal debug info for TYPE, processing TYPE won't do the
19882 trick; we need to attach the member declaration by hand. */
19885 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
19887 gen_type_die (type
, context_die
);
19889 /* If we're trying to avoid duplicate debug info, we may not have
19890 emitted the member decl for this function. Emit it now. */
19891 if (TYPE_STUB_DECL (type
)
19892 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
19893 && ! lookup_decl_die (member
))
19895 dw_die_ref type_die
;
19896 gcc_assert (!decl_ultimate_origin (member
));
19898 push_decl_scope (type
);
19899 type_die
= lookup_type_die_strip_naming_typedef (type
);
19900 if (TREE_CODE (member
) == FUNCTION_DECL
)
19901 gen_subprogram_die (member
, type_die
);
19902 else if (TREE_CODE (member
) == FIELD_DECL
)
19904 /* Ignore the nameless fields that are used to skip bits but handle
19905 C++ anonymous unions and structs. */
19906 if (DECL_NAME (member
) != NULL_TREE
19907 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
19908 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
19910 struct vlr_context vlr_ctx
= {
19911 DECL_CONTEXT (member
), /* struct_type */
19912 NULL_TREE
/* variant_part_offset */
19914 gen_type_die (member_declared_type (member
), type_die
);
19915 gen_field_die (member
, &vlr_ctx
, type_die
);
19919 gen_variable_die (member
, NULL_TREE
, type_die
);
19925 /* Forward declare these functions, because they are mutually recursive
19926 with their set_block_* pairing functions. */
19927 static void set_decl_origin_self (tree
);
19928 static void set_decl_abstract_flags (tree
, vec
<tree
> &);
19930 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
19931 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
19932 that it points to the node itself, thus indicating that the node is its
19933 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
19934 the given node is NULL, recursively descend the decl/block tree which
19935 it is the root of, and for each other ..._DECL or BLOCK node contained
19936 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
19937 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
19938 values to point to themselves. */
19941 set_block_origin_self (tree stmt
)
19943 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
19945 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
19950 for (local_decl
= BLOCK_VARS (stmt
);
19951 local_decl
!= NULL_TREE
;
19952 local_decl
= DECL_CHAIN (local_decl
))
19953 /* Do not recurse on nested functions since the inlining status
19954 of parent and child can be different as per the DWARF spec. */
19955 if (TREE_CODE (local_decl
) != FUNCTION_DECL
19956 && !DECL_EXTERNAL (local_decl
))
19957 set_decl_origin_self (local_decl
);
19963 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
19964 subblock
!= NULL_TREE
;
19965 subblock
= BLOCK_CHAIN (subblock
))
19966 set_block_origin_self (subblock
); /* Recurse. */
19971 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
19972 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
19973 node to so that it points to the node itself, thus indicating that the
19974 node represents its own (abstract) origin. Additionally, if the
19975 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
19976 the decl/block tree of which the given node is the root of, and for
19977 each other ..._DECL or BLOCK node contained therein whose
19978 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
19979 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
19980 point to themselves. */
19983 set_decl_origin_self (tree decl
)
19985 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
19987 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
19988 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19992 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
19993 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
19994 if (DECL_INITIAL (decl
) != NULL_TREE
19995 && DECL_INITIAL (decl
) != error_mark_node
)
19996 set_block_origin_self (DECL_INITIAL (decl
));
20001 /* Given a pointer to some BLOCK node, set the BLOCK_ABSTRACT flag to 1
20002 and if it wasn't 1 before, push it to abstract_vec vector.
20003 For all local decls and all local sub-blocks (recursively) do it
20007 set_block_abstract_flags (tree stmt
, vec
<tree
> &abstract_vec
)
20013 if (!BLOCK_ABSTRACT (stmt
))
20015 abstract_vec
.safe_push (stmt
);
20016 BLOCK_ABSTRACT (stmt
) = 1;
20019 for (local_decl
= BLOCK_VARS (stmt
);
20020 local_decl
!= NULL_TREE
;
20021 local_decl
= DECL_CHAIN (local_decl
))
20022 if (! DECL_EXTERNAL (local_decl
))
20023 set_decl_abstract_flags (local_decl
, abstract_vec
);
20025 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
20027 local_decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
20028 if ((TREE_CODE (local_decl
) == VAR_DECL
&& !TREE_STATIC (local_decl
))
20029 || TREE_CODE (local_decl
) == PARM_DECL
)
20030 set_decl_abstract_flags (local_decl
, abstract_vec
);
20033 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
20034 subblock
!= NULL_TREE
;
20035 subblock
= BLOCK_CHAIN (subblock
))
20036 set_block_abstract_flags (subblock
, abstract_vec
);
20039 /* Given a pointer to some ..._DECL node, set DECL_ABSTRACT_P flag on it
20040 to 1 and if it wasn't 1 before, push to abstract_vec vector.
20041 In the case where the decl is a FUNCTION_DECL also set the abstract
20042 flags for all of the parameters, local vars, local
20043 blocks and sub-blocks (recursively). */
20046 set_decl_abstract_flags (tree decl
, vec
<tree
> &abstract_vec
)
20048 if (!DECL_ABSTRACT_P (decl
))
20050 abstract_vec
.safe_push (decl
);
20051 DECL_ABSTRACT_P (decl
) = 1;
20054 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20058 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
20059 if (!DECL_ABSTRACT_P (arg
))
20061 abstract_vec
.safe_push (arg
);
20062 DECL_ABSTRACT_P (arg
) = 1;
20064 if (DECL_INITIAL (decl
) != NULL_TREE
20065 && DECL_INITIAL (decl
) != error_mark_node
)
20066 set_block_abstract_flags (DECL_INITIAL (decl
), abstract_vec
);
20070 /* Generate the DWARF2 info for the "abstract" instance of a function which we
20071 may later generate inlined and/or out-of-line instances of.
20073 FIXME: In the early-dwarf world, this function, and most of the
20074 DECL_ABSTRACT code should be obsoleted. The early DIE _is_
20075 the abstract instance. All we would need to do is annotate
20076 the early DIE with the appropriate DW_AT_inline in late
20077 dwarf (perhaps in gen_inlined_subroutine_die).
20079 However, we can't do this yet, because LTO streaming of DIEs
20080 has not been implemented yet. */
20083 dwarf2out_abstract_function (tree decl
)
20085 dw_die_ref old_die
;
20088 hash_table
<decl_loc_hasher
> *old_decl_loc_table
;
20089 hash_table
<dw_loc_list_hasher
> *old_cached_dw_loc_list_table
;
20090 int old_call_site_count
, old_tail_call_site_count
;
20091 struct call_arg_loc_node
*old_call_arg_locations
;
20093 /* Make sure we have the actual abstract inline, not a clone. */
20094 decl
= DECL_ORIGIN (decl
);
20096 old_die
= lookup_decl_die (decl
);
20097 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
20098 /* We've already generated the abstract instance. */
20101 /* We can be called while recursively when seeing block defining inlined subroutine
20102 DIE. Be sure to not clobber the outer location table nor use it or we would
20103 get locations in abstract instantces. */
20104 old_decl_loc_table
= decl_loc_table
;
20105 decl_loc_table
= NULL
;
20106 old_cached_dw_loc_list_table
= cached_dw_loc_list_table
;
20107 cached_dw_loc_list_table
= NULL
;
20108 old_call_arg_locations
= call_arg_locations
;
20109 call_arg_locations
= NULL
;
20110 old_call_site_count
= call_site_count
;
20111 call_site_count
= -1;
20112 old_tail_call_site_count
= tail_call_site_count
;
20113 tail_call_site_count
= -1;
20115 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
20116 we don't get confused by DECL_ABSTRACT_P. */
20117 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20119 context
= decl_class_context (decl
);
20121 gen_type_die_for_member
20122 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die ());
20125 /* Pretend we've just finished compiling this function. */
20126 save_fn
= current_function_decl
;
20127 current_function_decl
= decl
;
20129 auto_vec
<tree
, 64> abstract_vec
;
20130 set_decl_abstract_flags (decl
, abstract_vec
);
20131 dwarf2out_decl (decl
);
20134 FOR_EACH_VEC_ELT (abstract_vec
, i
, t
)
20135 if (TREE_CODE (t
) == BLOCK
)
20136 BLOCK_ABSTRACT (t
) = 0;
20138 DECL_ABSTRACT_P (t
) = 0;
20140 current_function_decl
= save_fn
;
20141 decl_loc_table
= old_decl_loc_table
;
20142 cached_dw_loc_list_table
= old_cached_dw_loc_list_table
;
20143 call_arg_locations
= old_call_arg_locations
;
20144 call_site_count
= old_call_site_count
;
20145 tail_call_site_count
= old_tail_call_site_count
;
20148 /* Helper function of premark_used_types() which gets called through
20151 Marks the DIE of a given type in *SLOT as perennial, so it never gets
20152 marked as unused by prune_unused_types. */
20155 premark_used_types_helper (tree
const &type
, void *)
20159 die
= lookup_type_die (type
);
20161 die
->die_perennial_p
= 1;
20165 /* Helper function of premark_types_used_by_global_vars which gets called
20166 through htab_traverse.
20168 Marks the DIE of a given type in *SLOT as perennial, so it never gets
20169 marked as unused by prune_unused_types. The DIE of the type is marked
20170 only if the global variable using the type will actually be emitted. */
20173 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
20176 struct types_used_by_vars_entry
*entry
;
20179 entry
= (struct types_used_by_vars_entry
*) *slot
;
20180 gcc_assert (entry
->type
!= NULL
20181 && entry
->var_decl
!= NULL
);
20182 die
= lookup_type_die (entry
->type
);
20185 /* Ask cgraph if the global variable really is to be emitted.
20186 If yes, then we'll keep the DIE of ENTRY->TYPE. */
20187 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
20188 if (node
&& node
->definition
)
20190 die
->die_perennial_p
= 1;
20191 /* Keep the parent DIEs as well. */
20192 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
20193 die
->die_perennial_p
= 1;
20199 /* Mark all members of used_types_hash as perennial. */
20202 premark_used_types (struct function
*fun
)
20204 if (fun
&& fun
->used_types_hash
)
20205 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
20208 /* Mark all members of types_used_by_vars_entry as perennial. */
20211 premark_types_used_by_global_vars (void)
20213 if (types_used_by_vars_hash
)
20214 types_used_by_vars_hash
20215 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
20218 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
20219 for CA_LOC call arg loc node. */
20222 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
20223 struct call_arg_loc_node
*ca_loc
)
20225 dw_die_ref stmt_die
= NULL
, die
;
20226 tree block
= ca_loc
->block
;
20229 && block
!= DECL_INITIAL (decl
)
20230 && TREE_CODE (block
) == BLOCK
)
20232 stmt_die
= BLOCK_DIE (block
);
20235 block
= BLOCK_SUPERCONTEXT (block
);
20237 if (stmt_die
== NULL
)
20238 stmt_die
= subr_die
;
20239 die
= new_die (DW_TAG_GNU_call_site
, stmt_die
, NULL_TREE
);
20240 add_AT_lbl_id (die
, DW_AT_low_pc
, ca_loc
->label
);
20241 if (ca_loc
->tail_call_p
)
20242 add_AT_flag (die
, DW_AT_GNU_tail_call
, 1);
20243 if (ca_loc
->symbol_ref
)
20245 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
20247 add_AT_die_ref (die
, DW_AT_abstract_origin
, tdie
);
20249 add_AT_addr (die
, DW_AT_abstract_origin
, ca_loc
->symbol_ref
, false);
20254 /* Generate a DIE to represent a declared function (either file-scope or
20258 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
20260 tree origin
= decl_ultimate_origin (decl
);
20261 dw_die_ref subr_die
;
20262 dw_die_ref old_die
= lookup_decl_die (decl
);
20264 /* This function gets called multiple times for different stages of
20265 the debug process. For example, for func() in this code:
20269 void func() { ... }
20272 ...we get called 4 times. Twice in early debug and twice in
20278 1. Once while generating func() within the namespace. This is
20279 the declaration. The declaration bit below is set, as the
20280 context is the namespace.
20282 A new DIE will be generated with DW_AT_declaration set.
20284 2. Once for func() itself. This is the specification. The
20285 declaration bit below is clear as the context is the CU.
20287 We will use the cached DIE from (1) to create a new DIE with
20288 DW_AT_specification pointing to the declaration in (1).
20290 Late debug via rest_of_handle_final()
20291 -------------------------------------
20293 3. Once generating func() within the namespace. This is also the
20294 declaration, as in (1), but this time we will early exit below
20295 as we have a cached DIE and a declaration needs no additional
20296 annotations (no locations), as the source declaration line
20299 4. Once for func() itself. As in (2), this is the specification,
20300 but this time we will re-use the cached DIE, and just annotate
20301 it with the location information that should now be available.
20303 For something without namespaces, but with abstract instances, we
20304 are also called a multiple times:
20309 Base (); // constructor declaration (1)
20312 Base::Base () { } // constructor specification (2)
20317 1. Once for the Base() constructor by virtue of it being a
20318 member of the Base class. This is done via
20319 rest_of_type_compilation.
20321 This is a declaration, so a new DIE will be created with
20324 2. Once for the Base() constructor definition, but this time
20325 while generating the abstract instance of the base
20326 constructor (__base_ctor) which is being generated via early
20327 debug of reachable functions.
20329 Even though we have a cached version of the declaration (1),
20330 we will create a DW_AT_specification of the declaration DIE
20333 3. Once for the __base_ctor itself, but this time, we generate
20334 an DW_AT_abstract_origin version of the DW_AT_specification in
20337 Late debug via rest_of_handle_final
20338 -----------------------------------
20340 4. One final time for the __base_ctor (which will have a cached
20341 DIE with DW_AT_abstract_origin created in (3). This time,
20342 we will just annotate the location information now
20345 int declaration
= (current_function_decl
!= decl
20346 || class_or_namespace_scope_p (context_die
));
20348 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
20350 /* Now that the C++ front end lazily declares artificial member fns, we
20351 might need to retrofit the declaration into its class. */
20352 if (!declaration
&& !origin
&& !old_die
20353 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
20354 && !class_or_namespace_scope_p (context_die
)
20355 && debug_info_level
> DINFO_LEVEL_TERSE
)
20356 old_die
= force_decl_die (decl
);
20358 /* An inlined instance, tag a new DIE with DW_AT_abstract_origin. */
20359 if (origin
!= NULL
)
20361 gcc_assert (!declaration
|| local_scope_p (context_die
));
20363 /* Fixup die_parent for the abstract instance of a nested
20364 inline function. */
20365 if (old_die
&& old_die
->die_parent
== NULL
)
20366 add_child_die (context_die
, old_die
);
20368 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
20370 /* If we have a DW_AT_abstract_origin we have a working
20372 subr_die
= old_die
;
20376 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
20377 add_abstract_origin_attribute (subr_die
, origin
);
20378 /* This is where the actual code for a cloned function is.
20379 Let's emit linkage name attribute for it. This helps
20380 debuggers to e.g, set breakpoints into
20381 constructors/destructors when the user asks "break
20383 add_linkage_name (subr_die
, decl
);
20386 /* A cached copy, possibly from early dwarf generation. Reuse as
20387 much as possible. */
20390 /* A declaration that has been previously dumped needs no
20391 additional information. */
20395 if (!get_AT_flag (old_die
, DW_AT_declaration
)
20396 /* We can have a normal definition following an inline one in the
20397 case of redefinition of GNU C extern inlines.
20398 It seems reasonable to use AT_specification in this case. */
20399 && !get_AT (old_die
, DW_AT_inline
))
20401 /* Detect and ignore this case, where we are trying to output
20402 something we have already output. */
20403 if (get_AT (old_die
, DW_AT_low_pc
)
20404 || get_AT (old_die
, DW_AT_ranges
))
20407 /* If we have no location information, this must be a
20408 partially generated DIE from early dwarf generation.
20409 Fall through and generate it. */
20412 /* If the definition comes from the same place as the declaration,
20413 maybe use the old DIE. We always want the DIE for this function
20414 that has the *_pc attributes to be under comp_unit_die so the
20415 debugger can find it. We also need to do this for abstract
20416 instances of inlines, since the spec requires the out-of-line copy
20417 to have the same parent. For local class methods, this doesn't
20418 apply; we just use the old DIE. */
20419 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
20420 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
20421 if ((is_cu_die (old_die
->die_parent
)
20422 /* This condition fixes the inconsistency/ICE with the
20423 following Fortran test (or some derivative thereof) while
20424 building libgfortran:
20428 logical function funky (FLAG)
20433 || (old_die
->die_parent
20434 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
20435 || context_die
== NULL
)
20436 && (DECL_ARTIFICIAL (decl
)
20437 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
20438 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
20439 == (unsigned) s
.line
))))
20441 subr_die
= old_die
;
20443 /* Clear out the declaration attribute, but leave the
20444 parameters so they can be augmented with location
20445 information later. Unless this was a declaration, in
20446 which case, wipe out the nameless parameters and recreate
20447 them further down. */
20448 if (remove_AT (subr_die
, DW_AT_declaration
))
20451 remove_AT (subr_die
, DW_AT_object_pointer
);
20452 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
20455 /* Make a specification pointing to the previously built
20459 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
20460 add_AT_specification (subr_die
, old_die
);
20461 add_pubname (decl
, subr_die
);
20462 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
20463 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
20464 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
20465 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
20467 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
20468 emit the real type on the definition die. */
20469 if (is_cxx() && debug_info_level
> DINFO_LEVEL_TERSE
)
20471 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
20472 if (die
== auto_die
|| die
== decltype_auto_die
)
20473 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
20474 TYPE_UNQUALIFIED
, false, context_die
);
20478 /* Create a fresh DIE for anything else. */
20481 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
20483 if (TREE_PUBLIC (decl
))
20484 add_AT_flag (subr_die
, DW_AT_external
, 1);
20486 add_name_and_src_coords_attributes (subr_die
, decl
);
20487 add_pubname (decl
, subr_die
);
20488 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20490 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
20491 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
20492 TYPE_UNQUALIFIED
, false, context_die
);
20495 add_pure_or_virtual_attribute (subr_die
, decl
);
20496 if (DECL_ARTIFICIAL (decl
))
20497 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
20499 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
20500 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
20502 add_accessibility_attribute (subr_die
, decl
);
20505 /* Unless we have an existing non-declaration DIE, equate the new
20507 if (!old_die
|| is_declaration_die (old_die
))
20508 equate_decl_number_to_die (decl
, subr_die
);
20512 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
20514 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
20516 /* If this is an explicit function declaration then generate
20517 a DW_AT_explicit attribute. */
20518 if (lang_hooks
.decls
.function_decl_explicit_p (decl
)
20519 && (dwarf_version
>= 3 || !dwarf_strict
))
20520 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
20522 /* If this is a C++11 deleted special function member then generate
20523 a DW_AT_GNU_deleted attribute. */
20524 if (lang_hooks
.decls
.function_decl_deleted_p (decl
)
20525 && (! dwarf_strict
))
20526 add_AT_flag (subr_die
, DW_AT_GNU_deleted
, 1);
20529 /* Tag abstract instances with DW_AT_inline. */
20530 else if (DECL_ABSTRACT_P (decl
))
20532 if (DECL_DECLARED_INLINE_P (decl
))
20534 if (cgraph_function_possibly_inlined_p (decl
))
20535 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
20537 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
20541 if (cgraph_function_possibly_inlined_p (decl
))
20542 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
20544 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
20547 if (DECL_DECLARED_INLINE_P (decl
)
20548 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
20549 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
20551 /* For non DECL_EXTERNALs, if range information is available, fill
20552 the DIE with it. */
20553 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
20555 HOST_WIDE_INT cfa_fb_offset
;
20557 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
20559 if (!flag_reorder_blocks_and_partition
)
20561 dw_fde_ref fde
= fun
->fde
;
20562 if (fde
->dw_fde_begin
)
20564 /* We have already generated the labels. */
20565 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
20566 fde
->dw_fde_end
, false);
20570 /* Create start/end labels and add the range. */
20571 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
20572 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
20573 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
20574 current_function_funcdef_no
);
20575 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
20576 current_function_funcdef_no
);
20577 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
20581 #if VMS_DEBUGGING_INFO
20582 /* HP OpenVMS Industry Standard 64: DWARF Extensions
20583 Section 2.3 Prologue and Epilogue Attributes:
20584 When a breakpoint is set on entry to a function, it is generally
20585 desirable for execution to be suspended, not on the very first
20586 instruction of the function, but rather at a point after the
20587 function's frame has been set up, after any language defined local
20588 declaration processing has been completed, and before execution of
20589 the first statement of the function begins. Debuggers generally
20590 cannot properly determine where this point is. Similarly for a
20591 breakpoint set on exit from a function. The prologue and epilogue
20592 attributes allow a compiler to communicate the location(s) to use. */
20595 if (fde
->dw_fde_vms_end_prologue
)
20596 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
20597 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
20599 if (fde
->dw_fde_vms_begin_epilogue
)
20600 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
20601 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
20608 /* Generate pubnames entries for the split function code ranges. */
20609 dw_fde_ref fde
= fun
->fde
;
20611 if (fde
->dw_fde_second_begin
)
20613 if (dwarf_version
>= 3 || !dwarf_strict
)
20615 /* We should use ranges for non-contiguous code section
20616 addresses. Use the actual code range for the initial
20617 section, since the HOT/COLD labels might precede an
20618 alignment offset. */
20619 bool range_list_added
= false;
20620 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
20621 fde
->dw_fde_end
, &range_list_added
,
20623 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
20624 fde
->dw_fde_second_end
,
20625 &range_list_added
, false);
20626 if (range_list_added
)
20631 /* There is no real support in DW2 for this .. so we make
20632 a work-around. First, emit the pub name for the segment
20633 containing the function label. Then make and emit a
20634 simplified subprogram DIE for the second segment with the
20635 name pre-fixed by __hot/cold_sect_of_. We use the same
20636 linkage name for the second die so that gdb will find both
20637 sections when given "b foo". */
20638 const char *name
= NULL
;
20639 tree decl_name
= DECL_NAME (decl
);
20640 dw_die_ref seg_die
;
20642 /* Do the 'primary' section. */
20643 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
20644 fde
->dw_fde_end
, false);
20646 /* Build a minimal DIE for the secondary section. */
20647 seg_die
= new_die (DW_TAG_subprogram
,
20648 subr_die
->die_parent
, decl
);
20650 if (TREE_PUBLIC (decl
))
20651 add_AT_flag (seg_die
, DW_AT_external
, 1);
20653 if (decl_name
!= NULL
20654 && IDENTIFIER_POINTER (decl_name
) != NULL
)
20656 name
= dwarf2_name (decl
, 1);
20657 if (! DECL_ARTIFICIAL (decl
))
20658 add_src_coords_attributes (seg_die
, decl
);
20660 add_linkage_name (seg_die
, decl
);
20662 gcc_assert (name
!= NULL
);
20663 add_pure_or_virtual_attribute (seg_die
, decl
);
20664 if (DECL_ARTIFICIAL (decl
))
20665 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
20667 name
= concat ("__second_sect_of_", name
, NULL
);
20668 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
20669 fde
->dw_fde_second_end
, false);
20670 add_name_attribute (seg_die
, name
);
20671 if (want_pubnames ())
20672 add_pubname_string (name
, seg_die
);
20676 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
20680 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
20682 /* We define the "frame base" as the function's CFA. This is more
20683 convenient for several reasons: (1) It's stable across the prologue
20684 and epilogue, which makes it better than just a frame pointer,
20685 (2) With dwarf3, there exists a one-byte encoding that allows us
20686 to reference the .debug_frame data by proxy, but failing that,
20687 (3) We can at least reuse the code inspection and interpretation
20688 code that determines the CFA position at various points in the
20690 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
20692 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
20693 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
20697 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
20698 if (list
->dw_loc_next
)
20699 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
20701 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
20704 /* Compute a displacement from the "steady-state frame pointer" to
20705 the CFA. The former is what all stack slots and argument slots
20706 will reference in the rtl; the latter is what we've told the
20707 debugger about. We'll need to adjust all frame_base references
20708 by this displacement. */
20709 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
20711 if (fun
->static_chain_decl
)
20713 /* DWARF requires here a location expression that computes the
20714 address of the enclosing subprogram's frame base. The machinery
20715 in tree-nested.c is supposed to store this specific address in the
20716 last field of the FRAME record. */
20717 const tree frame_type
20718 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
20719 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
20722 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
20723 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
20724 fb_expr
, fb_decl
, NULL_TREE
);
20726 add_AT_location_description (subr_die
, DW_AT_static_link
,
20727 loc_list_from_tree (fb_expr
, 0, NULL
));
20731 /* Generate child dies for template paramaters. */
20732 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
20733 gen_generic_params_dies (decl
);
20735 /* Now output descriptions of the arguments for this function. This gets
20736 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
20737 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
20738 `...' at the end of the formal parameter list. In order to find out if
20739 there was a trailing ellipsis or not, we must instead look at the type
20740 associated with the FUNCTION_DECL. This will be a node of type
20741 FUNCTION_TYPE. If the chain of type nodes hanging off of this
20742 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
20743 an ellipsis at the end. */
20745 /* In the case where we are describing a mere function declaration, all we
20746 need to do here (and all we *can* do here) is to describe the *types* of
20747 its formal parameters. */
20748 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20750 else if (declaration
)
20751 gen_formal_types_die (decl
, subr_die
);
20754 /* Generate DIEs to represent all known formal parameters. */
20755 tree parm
= DECL_ARGUMENTS (decl
);
20756 tree generic_decl
= early_dwarf
20757 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
20758 tree generic_decl_parm
= generic_decl
20759 ? DECL_ARGUMENTS (generic_decl
)
20762 /* Now we want to walk the list of parameters of the function and
20763 emit their relevant DIEs.
20765 We consider the case of DECL being an instance of a generic function
20766 as well as it being a normal function.
20768 If DECL is an instance of a generic function we walk the
20769 parameters of the generic function declaration _and_ the parameters of
20770 DECL itself. This is useful because we want to emit specific DIEs for
20771 function parameter packs and those are declared as part of the
20772 generic function declaration. In that particular case,
20773 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
20774 That DIE has children DIEs representing the set of arguments
20775 of the pack. Note that the set of pack arguments can be empty.
20776 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
20779 Otherwise, we just consider the parameters of DECL. */
20780 while (generic_decl_parm
|| parm
)
20782 if (generic_decl_parm
20783 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
20784 gen_formal_parameter_pack_die (generic_decl_parm
,
20787 else if (parm
&& !POINTER_BOUNDS_P (parm
))
20789 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
20791 if (parm
== DECL_ARGUMENTS (decl
)
20792 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
20794 && (dwarf_version
>= 3 || !dwarf_strict
))
20795 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
20797 parm
= DECL_CHAIN (parm
);
20800 parm
= DECL_CHAIN (parm
);
20802 if (generic_decl_parm
)
20803 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
20806 /* Decide whether we need an unspecified_parameters DIE at the end.
20807 There are 2 more cases to do this for: 1) the ansi ... declaration -
20808 this is detectable when the end of the arg list is not a
20809 void_type_node 2) an unprototyped function declaration (not a
20810 definition). This just means that we have no info about the
20811 parameters at all. */
20814 if (prototype_p (TREE_TYPE (decl
)))
20816 /* This is the prototyped case, check for.... */
20817 if (stdarg_p (TREE_TYPE (decl
)))
20818 gen_unspecified_parameters_die (decl
, subr_die
);
20820 else if (DECL_INITIAL (decl
) == NULL_TREE
)
20821 gen_unspecified_parameters_die (decl
, subr_die
);
20825 if (subr_die
!= old_die
)
20826 /* Add the calling convention attribute if requested. */
20827 add_calling_convention_attribute (subr_die
, decl
);
20829 /* Output Dwarf info for all of the stuff within the body of the function
20830 (if it has one - it may be just a declaration).
20832 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
20833 a function. This BLOCK actually represents the outermost binding contour
20834 for the function, i.e. the contour in which the function's formal
20835 parameters and labels get declared. Curiously, it appears that the front
20836 end doesn't actually put the PARM_DECL nodes for the current function onto
20837 the BLOCK_VARS list for this outer scope, but are strung off of the
20838 DECL_ARGUMENTS list for the function instead.
20840 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
20841 the LABEL_DECL nodes for the function however, and we output DWARF info
20842 for those in decls_for_scope. Just within the `outer_scope' there will be
20843 a BLOCK node representing the function's outermost pair of curly braces,
20844 and any blocks used for the base and member initializers of a C++
20845 constructor function. */
20846 tree outer_scope
= DECL_INITIAL (decl
);
20847 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
20849 int call_site_note_count
= 0;
20850 int tail_call_site_note_count
= 0;
20852 /* Emit a DW_TAG_variable DIE for a named return value. */
20853 if (DECL_NAME (DECL_RESULT (decl
)))
20854 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
20856 /* The first time through decls_for_scope we will generate the
20857 DIEs for the locals. The second time, we fill in the
20859 decls_for_scope (outer_scope
, subr_die
);
20861 if (call_arg_locations
&& !dwarf_strict
)
20863 struct call_arg_loc_node
*ca_loc
;
20864 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
20866 dw_die_ref die
= NULL
;
20867 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
20870 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
20871 ? NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
)
20873 arg
; arg
= next_arg
)
20875 dw_loc_descr_ref reg
, val
;
20876 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
20877 dw_die_ref cdie
, tdie
= NULL
;
20879 next_arg
= XEXP (arg
, 1);
20880 if (REG_P (XEXP (XEXP (arg
, 0), 0))
20882 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
20883 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
20884 && REGNO (XEXP (XEXP (arg
, 0), 0))
20885 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
20886 next_arg
= XEXP (next_arg
, 1);
20887 if (mode
== VOIDmode
)
20889 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
20890 if (mode
== VOIDmode
)
20891 mode
= GET_MODE (XEXP (arg
, 0));
20893 if (mode
== VOIDmode
|| mode
== BLKmode
)
20895 /* Get dynamic information about call target only if we
20896 have no static information: we cannot generate both
20897 DW_AT_abstract_origin and DW_AT_GNU_call_site_target
20899 if (ca_loc
->symbol_ref
== NULL_RTX
)
20901 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
20903 tloc
= XEXP (XEXP (arg
, 0), 1);
20906 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
20907 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
20909 tlocc
= XEXP (XEXP (arg
, 0), 1);
20914 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
20915 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
20916 VAR_INIT_STATUS_INITIALIZED
);
20917 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
20919 rtx mem
= XEXP (XEXP (arg
, 0), 0);
20920 reg
= mem_loc_descriptor (XEXP (mem
, 0),
20921 get_address_mode (mem
),
20923 VAR_INIT_STATUS_INITIALIZED
);
20925 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
20926 == DEBUG_PARAMETER_REF
)
20929 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
20930 tdie
= lookup_decl_die (tdecl
);
20937 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
20938 != DEBUG_PARAMETER_REF
)
20940 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
20942 VAR_INIT_STATUS_INITIALIZED
);
20946 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
20947 cdie
= new_die (DW_TAG_GNU_call_site_parameter
, die
,
20950 add_AT_loc (cdie
, DW_AT_location
, reg
);
20951 else if (tdie
!= NULL
)
20952 add_AT_die_ref (cdie
, DW_AT_abstract_origin
, tdie
);
20953 add_AT_loc (cdie
, DW_AT_GNU_call_site_value
, val
);
20954 if (next_arg
!= XEXP (arg
, 1))
20956 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
20957 if (mode
== VOIDmode
)
20958 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
20959 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
20962 VAR_INIT_STATUS_INITIALIZED
);
20964 add_AT_loc (cdie
, DW_AT_GNU_call_site_data_value
, val
);
20968 && (ca_loc
->symbol_ref
|| tloc
))
20969 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
20970 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
20972 dw_loc_descr_ref tval
= NULL
;
20974 if (tloc
!= NULL_RTX
)
20975 tval
= mem_loc_descriptor (tloc
,
20976 GET_MODE (tloc
) == VOIDmode
20977 ? Pmode
: GET_MODE (tloc
),
20979 VAR_INIT_STATUS_INITIALIZED
);
20981 add_AT_loc (die
, DW_AT_GNU_call_site_target
, tval
);
20982 else if (tlocc
!= NULL_RTX
)
20984 tval
= mem_loc_descriptor (tlocc
,
20985 GET_MODE (tlocc
) == VOIDmode
20986 ? Pmode
: GET_MODE (tlocc
),
20988 VAR_INIT_STATUS_INITIALIZED
);
20990 add_AT_loc (die
, DW_AT_GNU_call_site_target_clobbered
,
20996 call_site_note_count
++;
20997 if (ca_loc
->tail_call_p
)
20998 tail_call_site_note_count
++;
21002 call_arg_locations
= NULL
;
21003 call_arg_loc_last
= NULL
;
21004 if (tail_call_site_count
>= 0
21005 && tail_call_site_count
== tail_call_site_note_count
21008 if (call_site_count
>= 0
21009 && call_site_count
== call_site_note_count
)
21010 add_AT_flag (subr_die
, DW_AT_GNU_all_call_sites
, 1);
21012 add_AT_flag (subr_die
, DW_AT_GNU_all_tail_call_sites
, 1);
21014 call_site_count
= -1;
21015 tail_call_site_count
= -1;
21019 /* Returns a hash value for X (which really is a die_struct). */
21022 block_die_hasher::hash (die_struct
*d
)
21024 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
21027 /* Return nonzero if decl_id and die_parent of die_struct X is the same
21028 as decl_id and die_parent of die_struct Y. */
21031 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
21033 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
21036 /* Return TRUE if DECL, which may have been previously generated as
21037 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
21038 true if decl (or its origin) is either an extern declaration or a
21039 class/namespace scoped declaration.
21041 The declare_in_namespace support causes us to get two DIEs for one
21042 variable, both of which are declarations. We want to avoid
21043 considering one to be a specification, so we must test for
21044 DECLARATION and DW_AT_declaration. */
21046 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
21048 return (old_die
&& TREE_STATIC (decl
) && !declaration
21049 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
21052 /* Return true if DECL is a local static. */
21055 local_function_static (tree decl
)
21057 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
21058 return TREE_STATIC (decl
)
21059 && DECL_CONTEXT (decl
)
21060 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
21063 /* Generate a DIE to represent a declared data object.
21064 Either DECL or ORIGIN must be non-null. */
21067 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
21069 HOST_WIDE_INT off
= 0;
21071 tree decl_or_origin
= decl
? decl
: origin
;
21072 tree ultimate_origin
;
21073 dw_die_ref var_die
;
21074 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
21075 dw_die_ref origin_die
= NULL
;
21076 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
21077 || class_or_namespace_scope_p (context_die
));
21078 bool specialization_p
= false;
21080 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
21081 if (decl
|| ultimate_origin
)
21082 origin
= ultimate_origin
;
21083 com_decl
= fortran_common (decl_or_origin
, &off
);
21085 /* Symbol in common gets emitted as a child of the common block, in the form
21086 of a data member. */
21089 dw_die_ref com_die
;
21090 dw_loc_list_ref loc
;
21091 die_node com_die_arg
;
21093 var_die
= lookup_decl_die (decl_or_origin
);
21096 if (get_AT (var_die
, DW_AT_location
) == NULL
)
21098 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
21103 /* Optimize the common case. */
21104 if (single_element_loc_list_p (loc
)
21105 && loc
->expr
->dw_loc_opc
== DW_OP_addr
21106 && loc
->expr
->dw_loc_next
== NULL
21107 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
21110 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
21111 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
21112 = plus_constant (GET_MODE (x
), x
, off
);
21115 loc_list_plus_const (loc
, off
);
21117 add_AT_location_description (var_die
, DW_AT_location
, loc
);
21118 remove_AT (var_die
, DW_AT_declaration
);
21124 if (common_block_die_table
== NULL
)
21125 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
21127 com_die_arg
.decl_id
= DECL_UID (com_decl
);
21128 com_die_arg
.die_parent
= context_die
;
21129 com_die
= common_block_die_table
->find (&com_die_arg
);
21130 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
21131 if (com_die
== NULL
)
21134 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
21137 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
21138 add_name_and_src_coords_attributes (com_die
, com_decl
);
21141 add_AT_location_description (com_die
, DW_AT_location
, loc
);
21142 /* Avoid sharing the same loc descriptor between
21143 DW_TAG_common_block and DW_TAG_variable. */
21144 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
21146 else if (DECL_EXTERNAL (decl_or_origin
))
21147 add_AT_flag (com_die
, DW_AT_declaration
, 1);
21148 if (want_pubnames ())
21149 add_pubname_string (cnam
, com_die
); /* ??? needed? */
21150 com_die
->decl_id
= DECL_UID (com_decl
);
21151 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
21154 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
21156 add_AT_location_description (com_die
, DW_AT_location
, loc
);
21157 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
21158 remove_AT (com_die
, DW_AT_declaration
);
21160 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
21161 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
21162 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
21163 decl_quals (decl_or_origin
), false,
21165 add_AT_flag (var_die
, DW_AT_external
, 1);
21170 /* Optimize the common case. */
21171 if (single_element_loc_list_p (loc
)
21172 && loc
->expr
->dw_loc_opc
== DW_OP_addr
21173 && loc
->expr
->dw_loc_next
== NULL
21174 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
21176 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
21177 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
21178 = plus_constant (GET_MODE (x
), x
, off
);
21181 loc_list_plus_const (loc
, off
);
21183 add_AT_location_description (var_die
, DW_AT_location
, loc
);
21185 else if (DECL_EXTERNAL (decl_or_origin
))
21186 add_AT_flag (var_die
, DW_AT_declaration
, 1);
21188 equate_decl_number_to_die (decl
, var_die
);
21196 /* A declaration that has been previously dumped, needs no
21197 further annotations, since it doesn't need location on
21198 the second pass. */
21201 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
21202 && !get_AT (old_die
, DW_AT_specification
))
21204 /* Fall-thru so we can make a new variable die along with a
21205 DW_AT_specification. */
21207 else if (origin
&& old_die
->die_parent
!= context_die
)
21209 /* If we will be creating an inlined instance, we need a
21210 new DIE that will get annotated with
21211 DW_AT_abstract_origin. Clear things so we can get a
21213 gcc_assert (!DECL_ABSTRACT_P (decl
));
21218 /* If a DIE was dumped early, it still needs location info.
21219 Skip to where we fill the location bits. */
21221 goto gen_variable_die_location
;
21225 /* For static data members, the declaration in the class is supposed
21226 to have DW_TAG_member tag; the specification should still be
21227 DW_TAG_variable referencing the DW_TAG_member DIE. */
21228 if (declaration
&& class_scope_p (context_die
))
21229 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
21231 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
21233 if (origin
!= NULL
)
21234 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
21236 /* Loop unrolling can create multiple blocks that refer to the same
21237 static variable, so we must test for the DW_AT_declaration flag.
21239 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
21240 copy decls and set the DECL_ABSTRACT_P flag on them instead of
21243 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
21244 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
21246 /* This is a definition of a C++ class level static. */
21247 add_AT_specification (var_die
, old_die
);
21248 specialization_p
= true;
21249 if (DECL_NAME (decl
))
21251 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
21252 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
21254 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
21255 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
21257 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
21258 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
21260 if (old_die
->die_tag
== DW_TAG_member
)
21261 add_linkage_name (var_die
, decl
);
21265 add_name_and_src_coords_attributes (var_die
, decl
);
21267 if ((origin
== NULL
&& !specialization_p
)
21269 && !DECL_ABSTRACT_P (decl_or_origin
)
21270 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
21271 decl_function_context
21272 (decl_or_origin
))))
21274 tree type
= TREE_TYPE (decl_or_origin
);
21276 if (decl_by_reference_p (decl_or_origin
))
21277 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
21280 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
21284 if (origin
== NULL
&& !specialization_p
)
21286 if (TREE_PUBLIC (decl
))
21287 add_AT_flag (var_die
, DW_AT_external
, 1);
21289 if (DECL_ARTIFICIAL (decl
))
21290 add_AT_flag (var_die
, DW_AT_artificial
, 1);
21292 add_accessibility_attribute (var_die
, decl
);
21296 add_AT_flag (var_die
, DW_AT_declaration
, 1);
21298 if (decl
&& (DECL_ABSTRACT_P (decl
)
21299 || !old_die
|| is_declaration_die (old_die
)))
21300 equate_decl_number_to_die (decl
, var_die
);
21302 gen_variable_die_location
:
21304 && (! DECL_ABSTRACT_P (decl_or_origin
)
21305 /* Local static vars are shared between all clones/inlines,
21306 so emit DW_AT_location on the abstract DIE if DECL_RTL is
21308 || (TREE_CODE (decl_or_origin
) == VAR_DECL
21309 && TREE_STATIC (decl_or_origin
)
21310 && DECL_RTL_SET_P (decl_or_origin
)))
21311 /* When abstract origin already has DW_AT_location attribute, no need
21312 to add it again. */
21313 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
21316 add_pubname (decl_or_origin
, var_die
);
21318 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
21322 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
21325 /* Generate a DIE to represent a named constant. */
21328 gen_const_die (tree decl
, dw_die_ref context_die
)
21330 dw_die_ref const_die
;
21331 tree type
= TREE_TYPE (decl
);
21333 const_die
= lookup_decl_die (decl
);
21337 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
21338 equate_decl_number_to_die (decl
, const_die
);
21339 add_name_and_src_coords_attributes (const_die
, decl
);
21340 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
21341 if (TREE_PUBLIC (decl
))
21342 add_AT_flag (const_die
, DW_AT_external
, 1);
21343 if (DECL_ARTIFICIAL (decl
))
21344 add_AT_flag (const_die
, DW_AT_artificial
, 1);
21345 tree_add_const_value_attribute_for_decl (const_die
, decl
);
21348 /* Generate a DIE to represent a label identifier. */
21351 gen_label_die (tree decl
, dw_die_ref context_die
)
21353 tree origin
= decl_ultimate_origin (decl
);
21354 dw_die_ref lbl_die
= lookup_decl_die (decl
);
21356 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21360 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
21361 equate_decl_number_to_die (decl
, lbl_die
);
21363 if (origin
!= NULL
)
21364 add_abstract_origin_attribute (lbl_die
, origin
);
21366 add_name_and_src_coords_attributes (lbl_die
, decl
);
21369 if (DECL_ABSTRACT_P (decl
))
21370 equate_decl_number_to_die (decl
, lbl_die
);
21373 insn
= DECL_RTL_IF_SET (decl
);
21375 /* Deleted labels are programmer specified labels which have been
21376 eliminated because of various optimizations. We still emit them
21377 here so that it is possible to put breakpoints on them. */
21381 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
21383 /* When optimization is enabled (via -O) some parts of the compiler
21384 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
21385 represent source-level labels which were explicitly declared by
21386 the user. This really shouldn't be happening though, so catch
21387 it if it ever does happen. */
21388 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
21390 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
21391 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
21395 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
21396 && CODE_LABEL_NUMBER (insn
) != -1)
21398 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
21399 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
21404 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
21405 attributes to the DIE for a block STMT, to describe where the inlined
21406 function was called from. This is similar to add_src_coords_attributes. */
21409 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
21411 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
21413 if (dwarf_version
>= 3 || !dwarf_strict
)
21415 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
21416 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
21421 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
21422 Add low_pc and high_pc attributes to the DIE for a block STMT. */
21425 add_high_low_attributes (tree stmt
, dw_die_ref die
)
21427 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21429 if (BLOCK_FRAGMENT_CHAIN (stmt
)
21430 && (dwarf_version
>= 3 || !dwarf_strict
))
21432 tree chain
, superblock
= NULL_TREE
;
21434 dw_attr_node
*attr
= NULL
;
21436 if (inlined_function_outer_scope_p (stmt
))
21438 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
21439 BLOCK_NUMBER (stmt
));
21440 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
21443 /* Optimize duplicate .debug_ranges lists or even tails of
21444 lists. If this BLOCK has same ranges as its supercontext,
21445 lookup DW_AT_ranges attribute in the supercontext (and
21446 recursively so), verify that the ranges_table contains the
21447 right values and use it instead of adding a new .debug_range. */
21448 for (chain
= stmt
, pdie
= die
;
21449 BLOCK_SAME_RANGE (chain
);
21450 chain
= BLOCK_SUPERCONTEXT (chain
))
21452 dw_attr_node
*new_attr
;
21454 pdie
= pdie
->die_parent
;
21457 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
21459 new_attr
= get_AT (pdie
, DW_AT_ranges
);
21460 if (new_attr
== NULL
21461 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
21464 superblock
= BLOCK_SUPERCONTEXT (chain
);
21467 && (ranges_table
[attr
->dw_attr_val
.v
.val_offset
21468 / 2 / DWARF2_ADDR_SIZE
].num
21469 == BLOCK_NUMBER (superblock
))
21470 && BLOCK_FRAGMENT_CHAIN (superblock
))
21472 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
21473 / 2 / DWARF2_ADDR_SIZE
;
21474 unsigned long supercnt
= 0, thiscnt
= 0;
21475 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
21476 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
21479 gcc_checking_assert (ranges_table
[off
+ supercnt
].num
21480 == BLOCK_NUMBER (chain
));
21482 gcc_checking_assert (ranges_table
[off
+ supercnt
+ 1].num
== 0);
21483 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
21484 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
21486 gcc_assert (supercnt
>= thiscnt
);
21487 add_AT_range_list (die
, DW_AT_ranges
,
21488 ((off
+ supercnt
- thiscnt
)
21489 * 2 * DWARF2_ADDR_SIZE
),
21494 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
), false);
21496 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
21499 add_ranges (chain
);
21500 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
21507 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
21508 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
21509 BLOCK_NUMBER (stmt
));
21510 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
21511 BLOCK_NUMBER (stmt
));
21512 add_AT_low_high_pc (die
, label
, label_high
, false);
21516 /* Generate a DIE for a lexical block. */
21519 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
21521 dw_die_ref old_die
= BLOCK_DIE (stmt
);
21522 dw_die_ref stmt_die
= NULL
;
21525 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
21526 BLOCK_DIE (stmt
) = stmt_die
;
21529 if (BLOCK_ABSTRACT (stmt
))
21533 /* This must have been generated early and it won't even
21534 need location information since it's a DW_AT_inline
21537 for (dw_die_ref c
= context_die
; c
; c
= c
->die_parent
)
21538 if (c
->die_tag
== DW_TAG_inlined_subroutine
21539 || c
->die_tag
== DW_TAG_subprogram
)
21541 gcc_assert (get_AT (c
, DW_AT_inline
));
21547 else if (BLOCK_ABSTRACT_ORIGIN (stmt
))
21549 /* If this is an inlined instance, create a new lexical die for
21550 anything below to attach DW_AT_abstract_origin to. */
21553 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
21554 BLOCK_DIE (stmt
) = stmt_die
;
21558 tree origin
= block_ultimate_origin (stmt
);
21559 if (origin
!= NULL_TREE
&& origin
!= stmt
)
21560 add_abstract_origin_attribute (stmt_die
, origin
);
21564 stmt_die
= old_die
;
21566 /* A non abstract block whose blocks have already been reordered
21567 should have the instruction range for this block. If so, set the
21568 high/low attributes. */
21569 if (!early_dwarf
&& !BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
21571 gcc_assert (stmt_die
);
21572 add_high_low_attributes (stmt
, stmt_die
);
21575 decls_for_scope (stmt
, stmt_die
);
21578 /* Generate a DIE for an inlined subprogram. */
21581 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
21585 /* The instance of function that is effectively being inlined shall not
21587 gcc_assert (! BLOCK_ABSTRACT (stmt
));
21589 decl
= block_ultimate_origin (stmt
);
21591 /* Make sure any inlined functions are known to be inlineable. */
21592 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
21593 || cgraph_function_possibly_inlined_p (decl
));
21595 /* Emit info for the abstract instance first, if we haven't yet. We
21596 must emit this even if the block is abstract, otherwise when we
21597 emit the block below (or elsewhere), we may end up trying to emit
21598 a die whose origin die hasn't been emitted, and crashing. */
21599 dwarf2out_abstract_function (decl
);
21601 if (! BLOCK_ABSTRACT (stmt
))
21603 dw_die_ref subr_die
21604 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
21606 if (call_arg_locations
)
21607 BLOCK_DIE (stmt
) = subr_die
;
21608 add_abstract_origin_attribute (subr_die
, decl
);
21609 if (TREE_ASM_WRITTEN (stmt
))
21610 add_high_low_attributes (stmt
, subr_die
);
21611 add_call_src_coords_attributes (stmt
, subr_die
);
21613 decls_for_scope (stmt
, subr_die
);
21617 /* Generate a DIE for a field in a record, or structure. CTX is required: see
21618 the comment for VLR_CONTEXT. */
21621 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
21623 dw_die_ref decl_die
;
21625 if (TREE_TYPE (decl
) == error_mark_node
)
21628 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
21629 add_name_and_src_coords_attributes (decl_die
, decl
);
21630 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
21631 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
21634 if (DECL_BIT_FIELD_TYPE (decl
))
21636 add_byte_size_attribute (decl_die
, decl
);
21637 add_bit_size_attribute (decl_die
, decl
);
21638 add_bit_offset_attribute (decl_die
, decl
, ctx
);
21641 /* If we have a variant part offset, then we are supposed to process a member
21642 of a QUAL_UNION_TYPE, which is how we represent variant parts in
21644 gcc_assert (ctx
->variant_part_offset
== NULL_TREE
21645 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != QUAL_UNION_TYPE
);
21646 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
21647 add_data_member_location_attribute (decl_die
, decl
, ctx
);
21649 if (DECL_ARTIFICIAL (decl
))
21650 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
21652 add_accessibility_attribute (decl_die
, decl
);
21654 /* Equate decl number to die, so that we can look up this decl later on. */
21655 equate_decl_number_to_die (decl
, decl_die
);
21659 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
21660 Use modified_type_die instead.
21661 We keep this code here just in case these types of DIEs may be needed to
21662 represent certain things in other languages (e.g. Pascal) someday. */
21665 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
21668 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
21670 equate_type_number_to_die (type
, ptr_die
);
21671 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
21673 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
21676 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
21677 Use modified_type_die instead.
21678 We keep this code here just in case these types of DIEs may be needed to
21679 represent certain things in other languages (e.g. Pascal) someday. */
21682 gen_reference_type_die (tree type
, dw_die_ref context_die
)
21684 dw_die_ref ref_die
, scope_die
= scope_die_for (type
, context_die
);
21686 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
21687 ref_die
= new_die (DW_TAG_rvalue_reference_type
, scope_die
, type
);
21689 ref_die
= new_die (DW_TAG_reference_type
, scope_die
, type
);
21691 equate_type_number_to_die (type
, ref_die
);
21692 add_type_attribute (ref_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
21694 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
21698 /* Generate a DIE for a pointer to a member type. */
21701 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
21704 = new_die (DW_TAG_ptr_to_member_type
,
21705 scope_die_for (type
, context_die
), type
);
21707 equate_type_number_to_die (type
, ptr_die
);
21708 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
21709 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
21710 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
21714 static char *producer_string
;
21716 /* Return a heap allocated producer string including command line options
21717 if -grecord-gcc-switches. */
21720 gen_producer_string (void)
21723 auto_vec
<const char *> switches
;
21724 const char *language_string
= lang_hooks
.name
;
21725 char *producer
, *tail
;
21727 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
21728 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
21730 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
21731 switch (save_decoded_options
[j
].opt_index
)
21738 case OPT_auxbase_strip
:
21747 case OPT_SPECIAL_unknown
:
21748 case OPT_SPECIAL_ignore
:
21749 case OPT_SPECIAL_program_name
:
21750 case OPT_SPECIAL_input_file
:
21751 case OPT_grecord_gcc_switches
:
21752 case OPT_gno_record_gcc_switches
:
21753 case OPT__output_pch_
:
21754 case OPT_fdiagnostics_show_location_
:
21755 case OPT_fdiagnostics_show_option
:
21756 case OPT_fdiagnostics_show_caret
:
21757 case OPT_fdiagnostics_color_
:
21758 case OPT_fverbose_asm
:
21760 case OPT__sysroot_
:
21762 case OPT_nostdinc__
:
21763 case OPT_fpreprocessed
:
21764 case OPT_fltrans_output_list_
:
21765 case OPT_fresolution_
:
21766 case OPT_fdebug_prefix_map_
:
21767 /* Ignore these. */
21770 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
21771 & CL_NO_DWARF_RECORD
)
21773 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
21775 switch (save_decoded_options
[j
].canonical_option
[0][1])
21782 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
21789 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
21790 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
21794 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
21796 sprintf (tail
, "%s %s", language_string
, version_string
);
21799 FOR_EACH_VEC_ELT (switches
, j
, p
)
21803 memcpy (tail
+ 1, p
, len
);
21811 /* Given a C and/or C++ language/version string return the "highest".
21812 C++ is assumed to be "higher" than C in this case. Used for merging
21813 LTO translation unit languages. */
21814 static const char *
21815 highest_c_language (const char *lang1
, const char *lang2
)
21817 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
21818 return "GNU C++14";
21819 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
21820 return "GNU C++11";
21821 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
21822 return "GNU C++98";
21824 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
21826 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
21828 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
21831 gcc_unreachable ();
21835 /* Generate the DIE for the compilation unit. */
21838 gen_compile_unit_die (const char *filename
)
21841 const char *language_string
= lang_hooks
.name
;
21844 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
21848 add_name_attribute (die
, filename
);
21849 /* Don't add cwd for <built-in>. */
21850 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
21851 add_comp_dir_attribute (die
);
21854 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
21856 /* If our producer is LTO try to figure out a common language to use
21857 from the global list of translation units. */
21858 if (strcmp (language_string
, "GNU GIMPLE") == 0)
21862 const char *common_lang
= NULL
;
21864 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
21866 if (!TRANSLATION_UNIT_LANGUAGE (t
))
21869 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
21870 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
21872 else if (strncmp (common_lang
, "GNU C", 5) == 0
21873 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
21874 /* Mixing C and C++ is ok, use C++ in that case. */
21875 common_lang
= highest_c_language (common_lang
,
21876 TRANSLATION_UNIT_LANGUAGE (t
));
21879 /* Fall back to C. */
21880 common_lang
= NULL
;
21886 language_string
= common_lang
;
21889 language
= DW_LANG_C
;
21890 if (strncmp (language_string
, "GNU C", 5) == 0
21891 && ISDIGIT (language_string
[5]))
21893 language
= DW_LANG_C89
;
21894 if (dwarf_version
>= 3 || !dwarf_strict
)
21896 if (strcmp (language_string
, "GNU C89") != 0)
21897 language
= DW_LANG_C99
;
21899 if (dwarf_version
>= 5 /* || !dwarf_strict */)
21900 if (strcmp (language_string
, "GNU C11") == 0)
21901 language
= DW_LANG_C11
;
21904 else if (strncmp (language_string
, "GNU C++", 7) == 0)
21906 language
= DW_LANG_C_plus_plus
;
21907 if (dwarf_version
>= 5 /* || !dwarf_strict */)
21909 if (strcmp (language_string
, "GNU C++11") == 0)
21910 language
= DW_LANG_C_plus_plus_11
;
21911 else if (strcmp (language_string
, "GNU C++14") == 0)
21912 language
= DW_LANG_C_plus_plus_14
;
21915 else if (strcmp (language_string
, "GNU F77") == 0)
21916 language
= DW_LANG_Fortran77
;
21917 else if (strcmp (language_string
, "GNU Pascal") == 0)
21918 language
= DW_LANG_Pascal83
;
21919 else if (dwarf_version
>= 3 || !dwarf_strict
)
21921 if (strcmp (language_string
, "GNU Ada") == 0)
21922 language
= DW_LANG_Ada95
;
21923 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
21925 language
= DW_LANG_Fortran95
;
21926 if (dwarf_version
>= 5 /* || !dwarf_strict */)
21928 if (strcmp (language_string
, "GNU Fortran2003") == 0)
21929 language
= DW_LANG_Fortran03
;
21930 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
21931 language
= DW_LANG_Fortran08
;
21934 else if (strcmp (language_string
, "GNU Java") == 0)
21935 language
= DW_LANG_Java
;
21936 else if (strcmp (language_string
, "GNU Objective-C") == 0)
21937 language
= DW_LANG_ObjC
;
21938 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
21939 language
= DW_LANG_ObjC_plus_plus
;
21940 else if (dwarf_version
>= 5 || !dwarf_strict
)
21942 if (strcmp (language_string
, "GNU Go") == 0)
21943 language
= DW_LANG_Go
;
21946 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
21947 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
21948 language
= DW_LANG_Fortran90
;
21950 add_AT_unsigned (die
, DW_AT_language
, language
);
21954 case DW_LANG_Fortran77
:
21955 case DW_LANG_Fortran90
:
21956 case DW_LANG_Fortran95
:
21957 case DW_LANG_Fortran03
:
21958 case DW_LANG_Fortran08
:
21959 /* Fortran has case insensitive identifiers and the front-end
21960 lowercases everything. */
21961 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
21964 /* The default DW_ID_case_sensitive doesn't need to be specified. */
21970 /* Generate the DIE for a base class. */
21973 gen_inheritance_die (tree binfo
, tree access
, tree type
,
21974 dw_die_ref context_die
)
21976 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
21977 struct vlr_context ctx
= { type
, NULL
};
21979 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
21981 add_data_member_location_attribute (die
, binfo
, &ctx
);
21983 if (BINFO_VIRTUAL_P (binfo
))
21984 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
21986 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
21987 children, otherwise the default is DW_ACCESS_public. In DWARF2
21988 the default has always been DW_ACCESS_private. */
21989 if (access
== access_public_node
)
21991 if (dwarf_version
== 2
21992 || context_die
->die_tag
== DW_TAG_class_type
)
21993 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
21995 else if (access
== access_protected_node
)
21996 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
21997 else if (dwarf_version
> 2
21998 && context_die
->die_tag
!= DW_TAG_class_type
)
21999 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
22002 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
22005 is_variant_part (tree decl
)
22007 return (TREE_CODE (decl
) == FIELD_DECL
22008 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
22011 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
22012 return the FIELD_DECL. Return NULL_TREE otherwise. */
22015 analyze_discr_in_predicate (tree operand
, tree struct_type
)
22017 bool continue_stripping
= true;
22018 while (continue_stripping
)
22019 switch (TREE_CODE (operand
))
22022 operand
= TREE_OPERAND (operand
, 0);
22025 continue_stripping
= false;
22029 /* Match field access to members of struct_type only. */
22030 if (TREE_CODE (operand
) == COMPONENT_REF
22031 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
22032 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
22033 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
22034 return TREE_OPERAND (operand
, 1);
22039 /* Check that SRC is a constant integer that can be represented as a native
22040 integer constant (either signed or unsigned). If so, store it into DEST and
22041 return true. Return false otherwise. */
22044 get_discr_value (tree src
, dw_discr_value
*dest
)
22046 bool is_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
22048 if (TREE_CODE (src
) != INTEGER_CST
22049 || !(is_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
22052 dest
->pos
= is_unsigned
;
22054 dest
->v
.uval
= tree_to_uhwi (src
);
22056 dest
->v
.sval
= tree_to_shwi (src
);
22061 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
22062 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
22063 store NULL_TREE in DISCR_DECL. Otherwise:
22065 - store the discriminant field in STRUCT_TYPE that controls the variant
22066 part to *DISCR_DECL
22068 - put in *DISCR_LISTS_P an array where for each variant, the item
22069 represents the corresponding matching list of discriminant values.
22071 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
22074 Note that when the array is allocated (i.e. when the analysis is
22075 successful), it is up to the caller to free the array. */
22078 analyze_variants_discr (tree variant_part_decl
,
22081 dw_discr_list_ref
**discr_lists_p
,
22082 unsigned *discr_lists_length
)
22084 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
22086 dw_discr_list_ref
*discr_lists
;
22089 /* Compute how many variants there are in this variant part. */
22090 *discr_lists_length
= 0;
22091 for (variant
= TYPE_FIELDS (variant_part_type
);
22092 variant
!= NULL_TREE
;
22093 variant
= DECL_CHAIN (variant
))
22094 ++*discr_lists_length
;
22096 *discr_decl
= NULL_TREE
;
22098 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
22099 sizeof (**discr_lists_p
));
22100 discr_lists
= *discr_lists_p
;
22102 /* And then analyze all variants to extract discriminant information for all
22103 of them. This analysis is conservative: as soon as we detect something we
22104 do not support, abort everything and pretend we found nothing. */
22105 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
22106 variant
!= NULL_TREE
;
22107 variant
= DECL_CHAIN (variant
), ++i
)
22109 tree match_expr
= DECL_QUALIFIER (variant
);
22111 /* Now, try to analyze the predicate and deduce a discriminant for
22113 if (match_expr
== boolean_true_node
)
22114 /* Typically happens for the default variant: it matches all cases that
22115 previous variants rejected. Don't output any matching value for
22119 /* The following loop tries to iterate over each discriminant
22120 possibility: single values or ranges. */
22121 while (match_expr
!= NULL_TREE
)
22123 tree next_round_match_expr
;
22124 tree candidate_discr
= NULL_TREE
;
22125 dw_discr_list_ref new_node
= NULL
;
22127 /* Possibilities are matched one after the other by nested
22128 TRUTH_ORIF_EXPR expressions. Process the current possibility and
22129 continue with the rest at next iteration. */
22130 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
22132 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
22133 match_expr
= TREE_OPERAND (match_expr
, 1);
22136 next_round_match_expr
= NULL_TREE
;
22138 if (match_expr
== boolean_false_node
)
22139 /* This sub-expression matches nothing: just wait for the next
22143 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
22145 /* We are matching: <discr_field> == <integer_cst>
22146 This sub-expression matches a single value. */
22147 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
22150 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
22153 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
22154 if (!get_discr_value (integer_cst
,
22155 &new_node
->dw_discr_lower_bound
))
22157 new_node
->dw_discr_range
= false;
22160 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
22162 /* We are matching:
22163 <discr_field> > <integer_cst>
22164 && <discr_field> < <integer_cst>.
22165 This sub-expression matches the range of values between the
22166 two matched integer constants. Note that comparisons can be
22167 inclusive or exclusive. */
22168 tree candidate_discr_1
, candidate_discr_2
;
22169 tree lower_cst
, upper_cst
;
22170 bool lower_cst_included
, upper_cst_included
;
22171 tree lower_op
= TREE_OPERAND (match_expr
, 0);
22172 tree upper_op
= TREE_OPERAND (match_expr
, 1);
22174 /* When the comparison is exclusive, the integer constant is not
22175 the discriminant range bound we are looking for: we will have
22176 to increment or decrement it. */
22177 if (TREE_CODE (lower_op
) == GE_EXPR
)
22178 lower_cst_included
= true;
22179 else if (TREE_CODE (lower_op
) == GT_EXPR
)
22180 lower_cst_included
= false;
22184 if (TREE_CODE (upper_op
) == LE_EXPR
)
22185 upper_cst_included
= true;
22186 else if (TREE_CODE (upper_op
) == LT_EXPR
)
22187 upper_cst_included
= false;
22191 /* Extract the discriminant from the first operand and check it
22192 is consistant with the same analysis in the second
22195 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
22198 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
22200 if (candidate_discr_1
== candidate_discr_2
)
22201 candidate_discr
= candidate_discr_1
;
22205 /* Extract bounds from both. */
22206 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
22207 lower_cst
= TREE_OPERAND (lower_op
, 1);
22208 upper_cst
= TREE_OPERAND (upper_op
, 1);
22210 if (!lower_cst_included
)
22212 = fold (build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
),
22214 build_int_cst (TREE_TYPE (lower_cst
), 1)));
22215 if (!upper_cst_included
)
22217 = fold (build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
),
22219 build_int_cst (TREE_TYPE (upper_cst
), 1)));
22221 if (!get_discr_value (lower_cst
,
22222 &new_node
->dw_discr_lower_bound
)
22223 || !get_discr_value (upper_cst
,
22224 &new_node
->dw_discr_upper_bound
))
22227 new_node
->dw_discr_range
= true;
22231 /* Unsupported sub-expression: we cannot determine the set of
22232 matching discriminant values. Abort everything. */
22235 /* If the discriminant info is not consistant with what we saw so
22236 far, consider the analysis failed and abort everything. */
22237 if (candidate_discr
== NULL_TREE
22238 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
22241 *discr_decl
= candidate_discr
;
22243 if (new_node
!= NULL
)
22245 new_node
->dw_discr_next
= discr_lists
[i
];
22246 discr_lists
[i
] = new_node
;
22248 match_expr
= next_round_match_expr
;
22252 /* If we reach this point, we could match everything we were interested
22257 /* Clean all data structure and return no result. */
22258 free (*discr_lists_p
);
22259 *discr_lists_p
= NULL
;
22260 *discr_decl
= NULL_TREE
;
22263 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
22264 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
22267 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
22268 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
22269 this type, which are record types, represent the available variants and each
22270 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
22271 values are inferred from these attributes.
22273 In trees, the offsets for the fields inside these sub-records are relative
22274 to the variant part itself, whereas the corresponding DIEs should have
22275 offset attributes that are relative to the embedding record base address.
22276 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
22277 must be an expression that computes the offset of the variant part to
22278 describe in DWARF. */
22281 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
22282 dw_die_ref context_die
)
22284 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
22285 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
22286 struct loc_descr_context ctx
= {
22287 vlr_ctx
->struct_type
, /* context_type */
22288 NULL_TREE
, /* base_decl */
22292 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
22293 NULL_TREE if there is no such field. */
22294 tree discr_decl
= NULL_TREE
;
22295 dw_discr_list_ref
*discr_lists
;
22296 unsigned discr_lists_length
= 0;
22299 dw_die_ref dwarf_proc_die
= NULL
;
22300 dw_die_ref variant_part_die
22301 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
22303 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
22305 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
22306 &discr_decl
, &discr_lists
, &discr_lists_length
);
22308 if (discr_decl
!= NULL_TREE
)
22310 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
22313 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
22315 /* We have no DIE for the discriminant, so just discard all
22316 discrimimant information in the output. */
22317 discr_decl
= NULL_TREE
;
22320 /* If the offset for this variant part is more complex than a constant,
22321 create a DWARF procedure for it so that we will not have to generate DWARF
22322 expressions for it for each member. */
22323 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
22324 && (dwarf_version
>= 3 || !dwarf_strict
))
22326 const tree dwarf_proc_fndecl
22327 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
22328 build_function_type (TREE_TYPE (variant_part_offset
),
22330 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
22331 const dw_loc_descr_ref dwarf_proc_body
22332 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
22334 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
22335 dwarf_proc_fndecl
, context_die
);
22336 if (dwarf_proc_die
!= NULL
)
22337 variant_part_offset
= dwarf_proc_call
;
22340 /* Output DIEs for all variants. */
22342 for (tree variant
= TYPE_FIELDS (variant_part_type
);
22343 variant
!= NULL_TREE
;
22344 variant
= DECL_CHAIN (variant
), ++i
)
22346 tree variant_type
= TREE_TYPE (variant
);
22347 dw_die_ref variant_die
;
22349 /* All variants (i.e. members of a variant part) are supposed to be
22350 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
22351 under these records. */
22352 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
22354 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
22355 equate_decl_number_to_die (variant
, variant_die
);
22357 /* Output discriminant values this variant matches, if any. */
22358 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
22359 /* In the case we have discriminant information at all, this is
22360 probably the default variant: as the standard says, don't
22361 output any discriminant value/list attribute. */
22363 else if (discr_lists
[i
]->dw_discr_next
== NULL
22364 && !discr_lists
[i
]->dw_discr_range
)
22365 /* If there is only one accepted value, don't bother outputting a
22367 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
22369 add_discr_list (variant_die
, discr_lists
[i
]);
22371 for (tree member
= TYPE_FIELDS (variant_type
);
22372 member
!= NULL_TREE
;
22373 member
= DECL_CHAIN (member
))
22375 struct vlr_context vlr_sub_ctx
= {
22376 vlr_ctx
->struct_type
, /* struct_type */
22377 NULL
/* variant_part_offset */
22379 if (is_variant_part (member
))
22381 /* All offsets for fields inside variant parts are relative to
22382 the top-level embedding RECORD_TYPE's base address. On the
22383 other hand, offsets in GCC's types are relative to the
22384 nested-most variant part. So we have to sum offsets each time
22387 vlr_sub_ctx
.variant_part_offset
22388 = fold (build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
22389 variant_part_offset
, byte_position (member
)));
22390 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
22394 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
22395 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
22400 free (discr_lists
);
22403 /* Generate a DIE for a class member. */
22406 gen_member_die (tree type
, dw_die_ref context_die
)
22409 tree binfo
= TYPE_BINFO (type
);
22412 /* If this is not an incomplete type, output descriptions of each of its
22413 members. Note that as we output the DIEs necessary to represent the
22414 members of this record or union type, we will also be trying to output
22415 DIEs to represent the *types* of those members. However the `type'
22416 function (above) will specifically avoid generating type DIEs for member
22417 types *within* the list of member DIEs for this (containing) type except
22418 for those types (of members) which are explicitly marked as also being
22419 members of this (containing) type themselves. The g++ front- end can
22420 force any given type to be treated as a member of some other (containing)
22421 type by setting the TYPE_CONTEXT of the given (member) type to point to
22422 the TREE node representing the appropriate (containing) type. */
22424 /* First output info about the base classes. */
22427 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
22431 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
22432 gen_inheritance_die (base
,
22433 (accesses
? (*accesses
)[i
] : access_public_node
),
22438 /* Now output info about the data members and type members. */
22439 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
22441 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
22443 /* If we thought we were generating minimal debug info for TYPE
22444 and then changed our minds, some of the member declarations
22445 may have already been defined. Don't define them again, but
22446 do put them in the right order. */
22448 child
= lookup_decl_die (member
);
22450 splice_child_die (context_die
, child
);
22452 /* Do not generate standard DWARF for variant parts if we are generating
22453 the corresponding GNAT encodings: DIEs generated for both would
22454 conflict in our mappings. */
22455 else if (is_variant_part (member
)
22456 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
)
22458 vlr_ctx
.variant_part_offset
= byte_position (member
);
22459 gen_variant_part (member
, &vlr_ctx
, context_die
);
22463 vlr_ctx
.variant_part_offset
= NULL_TREE
;
22464 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
22468 /* We do not keep type methods in type variants. */
22469 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
22470 /* Now output info about the function members (if any). */
22471 if (TYPE_METHODS (type
) != error_mark_node
)
22472 for (member
= TYPE_METHODS (type
); member
; member
= DECL_CHAIN (member
))
22474 /* Don't include clones in the member list. */
22475 if (DECL_ABSTRACT_ORIGIN (member
))
22477 /* Nor constructors for anonymous classes. */
22478 if (DECL_ARTIFICIAL (member
)
22479 && dwarf2_name (member
, 0) == NULL
)
22482 child
= lookup_decl_die (member
);
22484 splice_child_die (context_die
, child
);
22486 gen_decl_die (member
, NULL
, NULL
, context_die
);
22490 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
22491 is set, we pretend that the type was never defined, so we only get the
22492 member DIEs needed by later specification DIEs. */
22495 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
22496 enum debug_info_usage usage
)
22498 if (TREE_ASM_WRITTEN (type
))
22500 /* Fill in the bound of variable-length fields in late dwarf if
22501 still incomplete. */
22502 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
22503 for (tree member
= TYPE_FIELDS (type
);
22505 member
= DECL_CHAIN (member
))
22506 fill_variable_array_bounds (TREE_TYPE (member
));
22510 dw_die_ref type_die
= lookup_type_die (type
);
22511 dw_die_ref scope_die
= 0;
22513 int complete
= (TYPE_SIZE (type
)
22514 && (! TYPE_STUB_DECL (type
)
22515 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
22516 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
22517 complete
= complete
&& should_emit_struct_debug (type
, usage
);
22519 if (type_die
&& ! complete
)
22522 if (TYPE_CONTEXT (type
) != NULL_TREE
22523 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
22524 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
22527 scope_die
= scope_die_for (type
, context_die
);
22529 /* Generate child dies for template paramaters. */
22530 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
22531 schedule_generic_params_dies_gen (type
);
22533 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
22534 /* First occurrence of type or toplevel definition of nested class. */
22536 dw_die_ref old_die
= type_die
;
22538 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
22539 ? record_type_tag (type
) : DW_TAG_union_type
,
22541 equate_type_number_to_die (type
, type_die
);
22543 add_AT_specification (type_die
, old_die
);
22545 add_name_attribute (type_die
, type_tag (type
));
22548 remove_AT (type_die
, DW_AT_declaration
);
22550 /* If this type has been completed, then give it a byte_size attribute and
22551 then give a list of members. */
22552 if (complete
&& !ns_decl
)
22554 /* Prevent infinite recursion in cases where the type of some member of
22555 this type is expressed in terms of this type itself. */
22556 TREE_ASM_WRITTEN (type
) = 1;
22557 add_byte_size_attribute (type_die
, type
);
22558 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
22560 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
22561 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
22564 /* If the first reference to this type was as the return type of an
22565 inline function, then it may not have a parent. Fix this now. */
22566 if (type_die
->die_parent
== NULL
)
22567 add_child_die (scope_die
, type_die
);
22569 push_decl_scope (type
);
22570 gen_member_die (type
, type_die
);
22573 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
22574 if (TYPE_ARTIFICIAL (type
))
22575 add_AT_flag (type_die
, DW_AT_artificial
, 1);
22577 /* GNU extension: Record what type our vtable lives in. */
22578 if (TYPE_VFIELD (type
))
22580 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
22582 gen_type_die (vtype
, context_die
);
22583 add_AT_die_ref (type_die
, DW_AT_containing_type
,
22584 lookup_type_die (vtype
));
22589 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22591 /* We don't need to do this for function-local types. */
22592 if (TYPE_STUB_DECL (type
)
22593 && ! decl_function_context (TYPE_STUB_DECL (type
)))
22594 vec_safe_push (incomplete_types
, type
);
22597 if (get_AT (type_die
, DW_AT_name
))
22598 add_pubtype (type
, type_die
);
22601 /* Generate a DIE for a subroutine _type_. */
22604 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
22606 tree return_type
= TREE_TYPE (type
);
22607 dw_die_ref subr_die
22608 = new_die (DW_TAG_subroutine_type
,
22609 scope_die_for (type
, context_die
), type
);
22611 equate_type_number_to_die (type
, subr_die
);
22612 add_prototyped_attribute (subr_die
, type
);
22613 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
22615 gen_formal_types_die (type
, subr_die
);
22617 if (get_AT (subr_die
, DW_AT_name
))
22618 add_pubtype (type
, subr_die
);
22621 /* Generate a DIE for a type definition. */
22624 gen_typedef_die (tree decl
, dw_die_ref context_die
)
22626 dw_die_ref type_die
;
22629 if (TREE_ASM_WRITTEN (decl
))
22631 if (DECL_ORIGINAL_TYPE (decl
))
22632 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
22636 TREE_ASM_WRITTEN (decl
) = 1;
22637 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
22638 origin
= decl_ultimate_origin (decl
);
22639 if (origin
!= NULL
)
22640 add_abstract_origin_attribute (type_die
, origin
);
22645 add_name_and_src_coords_attributes (type_die
, decl
);
22646 if (DECL_ORIGINAL_TYPE (decl
))
22648 type
= DECL_ORIGINAL_TYPE (decl
);
22650 if (type
== error_mark_node
)
22653 gcc_assert (type
!= TREE_TYPE (decl
));
22654 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
22658 type
= TREE_TYPE (decl
);
22660 if (type
== error_mark_node
)
22663 if (is_naming_typedef_decl (TYPE_NAME (type
)))
22665 /* Here, we are in the case of decl being a typedef naming
22666 an anonymous type, e.g:
22667 typedef struct {...} foo;
22668 In that case TREE_TYPE (decl) is not a typedef variant
22669 type and TYPE_NAME of the anonymous type is set to the
22670 TYPE_DECL of the typedef. This construct is emitted by
22673 TYPE is the anonymous struct named by the typedef
22674 DECL. As we need the DW_AT_type attribute of the
22675 DW_TAG_typedef to point to the DIE of TYPE, let's
22676 generate that DIE right away. add_type_attribute
22677 called below will then pick (via lookup_type_die) that
22678 anonymous struct DIE. */
22679 if (!TREE_ASM_WRITTEN (type
))
22680 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
22682 /* This is a GNU Extension. We are adding a
22683 DW_AT_linkage_name attribute to the DIE of the
22684 anonymous struct TYPE. The value of that attribute
22685 is the name of the typedef decl naming the anonymous
22686 struct. This greatly eases the work of consumers of
22687 this debug info. */
22688 add_linkage_name_raw (lookup_type_die (type
), decl
);
22692 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
22695 if (is_naming_typedef_decl (decl
))
22696 /* We want that all subsequent calls to lookup_type_die with
22697 TYPE in argument yield the DW_TAG_typedef we have just
22699 equate_type_number_to_die (type
, type_die
);
22701 add_accessibility_attribute (type_die
, decl
);
22704 if (DECL_ABSTRACT_P (decl
))
22705 equate_decl_number_to_die (decl
, type_die
);
22707 if (get_AT (type_die
, DW_AT_name
))
22708 add_pubtype (decl
, type_die
);
22711 /* Generate a DIE for a struct, class, enum or union type. */
22714 gen_tagged_type_die (tree type
,
22715 dw_die_ref context_die
,
22716 enum debug_info_usage usage
)
22720 if (type
== NULL_TREE
22721 || !is_tagged_type (type
))
22724 if (TREE_ASM_WRITTEN (type
))
22726 /* If this is a nested type whose containing class hasn't been written
22727 out yet, writing it out will cover this one, too. This does not apply
22728 to instantiations of member class templates; they need to be added to
22729 the containing class as they are generated. FIXME: This hurts the
22730 idea of combining type decls from multiple TUs, since we can't predict
22731 what set of template instantiations we'll get. */
22732 else if (TYPE_CONTEXT (type
)
22733 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
22734 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
22736 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
22738 if (TREE_ASM_WRITTEN (type
))
22741 /* If that failed, attach ourselves to the stub. */
22742 push_decl_scope (TYPE_CONTEXT (type
));
22743 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
22746 else if (TYPE_CONTEXT (type
) != NULL_TREE
22747 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
22749 /* If this type is local to a function that hasn't been written
22750 out yet, use a NULL context for now; it will be fixed up in
22751 decls_for_scope. */
22752 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
22753 /* A declaration DIE doesn't count; nested types need to go in the
22755 if (context_die
&& is_declaration_die (context_die
))
22756 context_die
= NULL
;
22761 context_die
= declare_in_namespace (type
, context_die
);
22765 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
22767 /* This might have been written out by the call to
22768 declare_in_namespace. */
22769 if (!TREE_ASM_WRITTEN (type
))
22770 gen_enumeration_type_die (type
, context_die
);
22773 gen_struct_or_union_type_die (type
, context_die
, usage
);
22778 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
22779 it up if it is ever completed. gen_*_type_die will set it for us
22780 when appropriate. */
22783 /* Generate a type description DIE. */
22786 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
22787 enum debug_info_usage usage
)
22789 struct array_descr_info info
;
22791 if (type
== NULL_TREE
|| type
== error_mark_node
)
22794 if (flag_checking
&& type
)
22795 verify_type (type
);
22797 if (TYPE_NAME (type
) != NULL_TREE
22798 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
22799 && is_redundant_typedef (TYPE_NAME (type
))
22800 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
22801 /* The DECL of this type is a typedef we don't want to emit debug
22802 info for but we want debug info for its underlying typedef.
22803 This can happen for e.g, the injected-class-name of a C++
22805 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
22807 /* If TYPE is a typedef type variant, let's generate debug info
22808 for the parent typedef which TYPE is a type of. */
22809 if (typedef_variant_p (type
))
22811 if (TREE_ASM_WRITTEN (type
))
22814 /* Prevent broken recursion; we can't hand off to the same type. */
22815 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
22817 /* Give typedefs the right scope. */
22818 context_die
= scope_die_for (type
, context_die
);
22820 TREE_ASM_WRITTEN (type
) = 1;
22822 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
22826 /* If type is an anonymous tagged type named by a typedef, let's
22827 generate debug info for the typedef. */
22828 if (is_naming_typedef_decl (TYPE_NAME (type
)))
22830 /* Use the DIE of the containing namespace as the parent DIE of
22831 the type description DIE we want to generate. */
22832 if (DECL_CONTEXT (TYPE_NAME (type
))
22833 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
22834 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
22836 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
22840 /* We are going to output a DIE to represent the unqualified version
22841 of this type (i.e. without any const or volatile qualifiers) so
22842 get the main variant (i.e. the unqualified version) of this type
22843 now. (Vectors and arrays are special because the debugging info is in the
22844 cloned type itself). */
22845 if (TREE_CODE (type
) != VECTOR_TYPE
22846 && TREE_CODE (type
) != ARRAY_TYPE
)
22847 type
= type_main_variant (type
);
22849 /* If this is an array type with hidden descriptor, handle it first. */
22850 if (!TREE_ASM_WRITTEN (type
)
22851 && lang_hooks
.types
.get_array_descr_info
)
22853 memset (&info
, 0, sizeof (info
));
22854 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
22856 /* Fortran sometimes emits array types with no dimension. */
22857 gcc_assert (info
.ndimensions
>= 0
22858 && (info
.ndimensions
22859 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
22860 gen_descr_array_type_die (type
, &info
, context_die
);
22861 TREE_ASM_WRITTEN (type
) = 1;
22866 if (TREE_ASM_WRITTEN (type
))
22868 /* Variable-length types may be incomplete even if
22869 TREE_ASM_WRITTEN. For such types, fall through to
22870 gen_array_type_die() and possibly fill in
22871 DW_AT_{upper,lower}_bound attributes. */
22872 if ((TREE_CODE (type
) != ARRAY_TYPE
22873 && TREE_CODE (type
) != RECORD_TYPE
22874 && TREE_CODE (type
) != UNION_TYPE
22875 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
22876 || !variably_modified_type_p (type
, NULL
))
22880 switch (TREE_CODE (type
))
22886 case REFERENCE_TYPE
:
22887 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
22888 ensures that the gen_type_die recursion will terminate even if the
22889 type is recursive. Recursive types are possible in Ada. */
22890 /* ??? We could perhaps do this for all types before the switch
22892 TREE_ASM_WRITTEN (type
) = 1;
22894 /* For these types, all that is required is that we output a DIE (or a
22895 set of DIEs) to represent the "basis" type. */
22896 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
22897 DINFO_USAGE_IND_USE
);
22901 /* This code is used for C++ pointer-to-data-member types.
22902 Output a description of the relevant class type. */
22903 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
22904 DINFO_USAGE_IND_USE
);
22906 /* Output a description of the type of the object pointed to. */
22907 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
22908 DINFO_USAGE_IND_USE
);
22910 /* Now output a DIE to represent this pointer-to-data-member type
22912 gen_ptr_to_mbr_type_die (type
, context_die
);
22915 case FUNCTION_TYPE
:
22916 /* Force out return type (in case it wasn't forced out already). */
22917 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
22918 DINFO_USAGE_DIR_USE
);
22919 gen_subroutine_type_die (type
, context_die
);
22923 /* Force out return type (in case it wasn't forced out already). */
22924 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
22925 DINFO_USAGE_DIR_USE
);
22926 gen_subroutine_type_die (type
, context_die
);
22931 gen_array_type_die (type
, context_die
);
22934 case ENUMERAL_TYPE
:
22937 case QUAL_UNION_TYPE
:
22938 gen_tagged_type_die (type
, context_die
, usage
);
22944 case FIXED_POINT_TYPE
:
22947 case POINTER_BOUNDS_TYPE
:
22948 /* No DIEs needed for fundamental types. */
22953 /* Just use DW_TAG_unspecified_type. */
22955 dw_die_ref type_die
= lookup_type_die (type
);
22956 if (type_die
== NULL
)
22958 tree name
= TYPE_IDENTIFIER (type
);
22959 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
22961 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
22962 equate_type_number_to_die (type
, type_die
);
22968 if (is_cxx_auto (type
))
22970 tree name
= TYPE_IDENTIFIER (type
);
22971 dw_die_ref
*die
= (name
== get_identifier ("auto")
22972 ? &auto_die
: &decltype_auto_die
);
22975 *die
= new_die (DW_TAG_unspecified_type
,
22976 comp_unit_die (), NULL_TREE
);
22977 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
22979 equate_type_number_to_die (type
, *die
);
22982 gcc_unreachable ();
22985 TREE_ASM_WRITTEN (type
) = 1;
22989 gen_type_die (tree type
, dw_die_ref context_die
)
22991 if (type
!= error_mark_node
)
22993 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
22996 dw_die_ref die
= lookup_type_die (type
);
23003 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
23004 things which are local to the given block. */
23007 gen_block_die (tree stmt
, dw_die_ref context_die
)
23009 int must_output_die
= 0;
23012 /* Ignore blocks that are NULL. */
23013 if (stmt
== NULL_TREE
)
23016 inlined_func
= inlined_function_outer_scope_p (stmt
);
23018 /* If the block is one fragment of a non-contiguous block, do not
23019 process the variables, since they will have been done by the
23020 origin block. Do process subblocks. */
23021 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
23025 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
23026 gen_block_die (sub
, context_die
);
23031 /* Determine if we need to output any Dwarf DIEs at all to represent this
23034 /* The outer scopes for inlinings *must* always be represented. We
23035 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
23036 must_output_die
= 1;
23039 /* Determine if this block directly contains any "significant"
23040 local declarations which we will need to output DIEs for. */
23041 if (debug_info_level
> DINFO_LEVEL_TERSE
)
23042 /* We are not in terse mode so *any* local declaration counts
23043 as being a "significant" one. */
23044 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
23045 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
23046 && (TREE_USED (stmt
)
23047 || TREE_ASM_WRITTEN (stmt
)
23048 || BLOCK_ABSTRACT (stmt
)));
23049 else if ((TREE_USED (stmt
)
23050 || TREE_ASM_WRITTEN (stmt
)
23051 || BLOCK_ABSTRACT (stmt
))
23052 && !dwarf2out_ignore_block (stmt
))
23053 must_output_die
= 1;
23056 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
23057 DIE for any block which contains no significant local declarations at
23058 all. Rather, in such cases we just call `decls_for_scope' so that any
23059 needed Dwarf info for any sub-blocks will get properly generated. Note
23060 that in terse mode, our definition of what constitutes a "significant"
23061 local declaration gets restricted to include only inlined function
23062 instances and local (nested) function definitions. */
23063 if (must_output_die
)
23067 /* If STMT block is abstract, that means we have been called
23068 indirectly from dwarf2out_abstract_function.
23069 That function rightfully marks the descendent blocks (of
23070 the abstract function it is dealing with) as being abstract,
23071 precisely to prevent us from emitting any
23072 DW_TAG_inlined_subroutine DIE as a descendent
23073 of an abstract function instance. So in that case, we should
23074 not call gen_inlined_subroutine_die.
23076 Later though, when cgraph asks dwarf2out to emit info
23077 for the concrete instance of the function decl into which
23078 the concrete instance of STMT got inlined, the later will lead
23079 to the generation of a DW_TAG_inlined_subroutine DIE. */
23080 if (! BLOCK_ABSTRACT (stmt
))
23081 gen_inlined_subroutine_die (stmt
, context_die
);
23084 gen_lexical_block_die (stmt
, context_die
);
23087 decls_for_scope (stmt
, context_die
);
23090 /* Process variable DECL (or variable with origin ORIGIN) within
23091 block STMT and add it to CONTEXT_DIE. */
23093 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
23096 tree decl_or_origin
= decl
? decl
: origin
;
23098 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
23099 die
= lookup_decl_die (decl_or_origin
);
23100 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
23101 && TYPE_DECL_IS_STUB (decl_or_origin
))
23102 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
23106 if (die
!= NULL
&& die
->die_parent
== NULL
)
23107 add_child_die (context_die
, die
);
23108 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
23111 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
23112 stmt
, context_die
);
23115 gen_decl_die (decl
, origin
, NULL
, context_die
);
23118 /* Generate all of the decls declared within a given scope and (recursively)
23119 all of its sub-blocks. */
23122 decls_for_scope (tree stmt
, dw_die_ref context_die
)
23128 /* Ignore NULL blocks. */
23129 if (stmt
== NULL_TREE
)
23132 /* Output the DIEs to represent all of the data objects and typedefs
23133 declared directly within this block but not within any nested
23134 sub-blocks. Also, nested function and tag DIEs have been
23135 generated with a parent of NULL; fix that up now. We don't
23136 have to do this if we're at -g1. */
23137 if (debug_info_level
> DINFO_LEVEL_TERSE
)
23139 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
23140 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
23141 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
23142 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
23146 /* Even if we're at -g1, we need to process the subblocks in order to get
23147 inlined call information. */
23149 /* Output the DIEs to represent all sub-blocks (and the items declared
23150 therein) of this block. */
23151 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
23153 subblocks
= BLOCK_CHAIN (subblocks
))
23154 gen_block_die (subblocks
, context_die
);
23157 /* Is this a typedef we can avoid emitting? */
23160 is_redundant_typedef (const_tree decl
)
23162 if (TYPE_DECL_IS_STUB (decl
))
23165 if (DECL_ARTIFICIAL (decl
)
23166 && DECL_CONTEXT (decl
)
23167 && is_tagged_type (DECL_CONTEXT (decl
))
23168 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
23169 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
23170 /* Also ignore the artificial member typedef for the class name. */
23176 /* Return TRUE if TYPE is a typedef that names a type for linkage
23177 purposes. This kind of typedefs is produced by the C++ FE for
23180 typedef struct {...} foo;
23182 In that case, there is no typedef variant type produced for foo.
23183 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
23187 is_naming_typedef_decl (const_tree decl
)
23189 if (decl
== NULL_TREE
23190 || TREE_CODE (decl
) != TYPE_DECL
23191 || DECL_NAMELESS (decl
)
23192 || !is_tagged_type (TREE_TYPE (decl
))
23193 || DECL_IS_BUILTIN (decl
)
23194 || is_redundant_typedef (decl
)
23195 /* It looks like Ada produces TYPE_DECLs that are very similar
23196 to C++ naming typedefs but that have different
23197 semantics. Let's be specific to c++ for now. */
23201 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
23202 && TYPE_NAME (TREE_TYPE (decl
)) == decl
23203 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
23204 != TYPE_NAME (TREE_TYPE (decl
))));
23207 /* Looks up the DIE for a context. */
23209 static inline dw_die_ref
23210 lookup_context_die (tree context
)
23214 /* Find die that represents this context. */
23215 if (TYPE_P (context
))
23217 context
= TYPE_MAIN_VARIANT (context
);
23218 dw_die_ref ctx
= lookup_type_die (context
);
23221 return strip_naming_typedef (context
, ctx
);
23224 return lookup_decl_die (context
);
23226 return comp_unit_die ();
23229 /* Returns the DIE for a context. */
23231 static inline dw_die_ref
23232 get_context_die (tree context
)
23236 /* Find die that represents this context. */
23237 if (TYPE_P (context
))
23239 context
= TYPE_MAIN_VARIANT (context
);
23240 return strip_naming_typedef (context
, force_type_die (context
));
23243 return force_decl_die (context
);
23245 return comp_unit_die ();
23248 /* Returns the DIE for decl. A DIE will always be returned. */
23251 force_decl_die (tree decl
)
23253 dw_die_ref decl_die
;
23254 unsigned saved_external_flag
;
23255 tree save_fn
= NULL_TREE
;
23256 decl_die
= lookup_decl_die (decl
);
23259 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
23261 decl_die
= lookup_decl_die (decl
);
23265 switch (TREE_CODE (decl
))
23267 case FUNCTION_DECL
:
23268 /* Clear current_function_decl, so that gen_subprogram_die thinks
23269 that this is a declaration. At this point, we just want to force
23270 declaration die. */
23271 save_fn
= current_function_decl
;
23272 current_function_decl
= NULL_TREE
;
23273 gen_subprogram_die (decl
, context_die
);
23274 current_function_decl
= save_fn
;
23278 /* Set external flag to force declaration die. Restore it after
23279 gen_decl_die() call. */
23280 saved_external_flag
= DECL_EXTERNAL (decl
);
23281 DECL_EXTERNAL (decl
) = 1;
23282 gen_decl_die (decl
, NULL
, NULL
, context_die
);
23283 DECL_EXTERNAL (decl
) = saved_external_flag
;
23286 case NAMESPACE_DECL
:
23287 if (dwarf_version
>= 3 || !dwarf_strict
)
23288 dwarf2out_decl (decl
);
23290 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
23291 decl_die
= comp_unit_die ();
23294 case TRANSLATION_UNIT_DECL
:
23295 decl_die
= comp_unit_die ();
23299 gcc_unreachable ();
23302 /* We should be able to find the DIE now. */
23304 decl_die
= lookup_decl_die (decl
);
23305 gcc_assert (decl_die
);
23311 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
23312 always returned. */
23315 force_type_die (tree type
)
23317 dw_die_ref type_die
;
23319 type_die
= lookup_type_die (type
);
23322 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
23324 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
23325 false, context_die
);
23326 gcc_assert (type_die
);
23331 /* Force out any required namespaces to be able to output DECL,
23332 and return the new context_die for it, if it's changed. */
23335 setup_namespace_context (tree thing
, dw_die_ref context_die
)
23337 tree context
= (DECL_P (thing
)
23338 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
23339 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
23340 /* Force out the namespace. */
23341 context_die
= force_decl_die (context
);
23343 return context_die
;
23346 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
23347 type) within its namespace, if appropriate.
23349 For compatibility with older debuggers, namespace DIEs only contain
23350 declarations; all definitions are emitted at CU scope, with
23351 DW_AT_specification pointing to the declaration (like with class
23355 declare_in_namespace (tree thing
, dw_die_ref context_die
)
23357 dw_die_ref ns_context
;
23359 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23360 return context_die
;
23362 /* External declarations in the local scope only need to be emitted
23363 once, not once in the namespace and once in the scope.
23365 This avoids declaring the `extern' below in the
23366 namespace DIE as well as in the innermost scope:
23379 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
23380 return context_die
;
23382 /* If this decl is from an inlined function, then don't try to emit it in its
23383 namespace, as we will get confused. It would have already been emitted
23384 when the abstract instance of the inline function was emitted anyways. */
23385 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
23386 return context_die
;
23388 ns_context
= setup_namespace_context (thing
, context_die
);
23390 if (ns_context
!= context_die
)
23394 if (DECL_P (thing
))
23395 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
23397 gen_type_die (thing
, ns_context
);
23399 return context_die
;
23402 /* Generate a DIE for a namespace or namespace alias. */
23405 gen_namespace_die (tree decl
, dw_die_ref context_die
)
23407 dw_die_ref namespace_die
;
23409 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
23410 they are an alias of. */
23411 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
23413 /* Output a real namespace or module. */
23414 context_die
= setup_namespace_context (decl
, comp_unit_die ());
23415 namespace_die
= new_die (is_fortran ()
23416 ? DW_TAG_module
: DW_TAG_namespace
,
23417 context_die
, decl
);
23418 /* For Fortran modules defined in different CU don't add src coords. */
23419 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
23421 const char *name
= dwarf2_name (decl
, 0);
23423 add_name_attribute (namespace_die
, name
);
23426 add_name_and_src_coords_attributes (namespace_die
, decl
);
23427 if (DECL_EXTERNAL (decl
))
23428 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
23429 equate_decl_number_to_die (decl
, namespace_die
);
23433 /* Output a namespace alias. */
23435 /* Force out the namespace we are an alias of, if necessary. */
23436 dw_die_ref origin_die
23437 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
23439 if (DECL_FILE_SCOPE_P (decl
)
23440 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
23441 context_die
= setup_namespace_context (decl
, comp_unit_die ());
23442 /* Now create the namespace alias DIE. */
23443 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
23444 add_name_and_src_coords_attributes (namespace_die
, decl
);
23445 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
23446 equate_decl_number_to_die (decl
, namespace_die
);
23448 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
23449 if (want_pubnames ())
23450 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
23453 /* Generate Dwarf debug information for a decl described by DECL.
23454 The return value is currently only meaningful for PARM_DECLs,
23455 for all other decls it returns NULL.
23457 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
23458 It can be NULL otherwise. */
23461 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
23462 dw_die_ref context_die
)
23464 tree decl_or_origin
= decl
? decl
: origin
;
23465 tree class_origin
= NULL
, ultimate_origin
;
23467 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
23470 /* Ignore pointer bounds decls. */
23471 if (DECL_P (decl_or_origin
)
23472 && TREE_TYPE (decl_or_origin
)
23473 && POINTER_BOUNDS_P (decl_or_origin
))
23476 switch (TREE_CODE (decl_or_origin
))
23482 if (!is_fortran () && !is_ada ())
23484 /* The individual enumerators of an enum type get output when we output
23485 the Dwarf representation of the relevant enum type itself. */
23489 /* Emit its type. */
23490 gen_type_die (TREE_TYPE (decl
), context_die
);
23492 /* And its containing namespace. */
23493 context_die
= declare_in_namespace (decl
, context_die
);
23495 gen_const_die (decl
, context_die
);
23498 case FUNCTION_DECL
:
23499 /* Don't output any DIEs to represent mere function declarations,
23500 unless they are class members or explicit block externs. */
23501 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
23502 && DECL_FILE_SCOPE_P (decl_or_origin
)
23503 && (current_function_decl
== NULL_TREE
23504 || DECL_ARTIFICIAL (decl_or_origin
)))
23509 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
23510 on local redeclarations of global functions. That seems broken. */
23511 if (current_function_decl
!= decl
)
23512 /* This is only a declaration. */;
23515 /* If we're emitting a clone, emit info for the abstract instance. */
23516 if (origin
|| DECL_ORIGIN (decl
) != decl
)
23517 dwarf2out_abstract_function (origin
23518 ? DECL_ORIGIN (origin
)
23519 : DECL_ABSTRACT_ORIGIN (decl
));
23521 /* If we're emitting an out-of-line copy of an inline function,
23522 emit info for the abstract instance and set up to refer to it. */
23523 else if (cgraph_function_possibly_inlined_p (decl
)
23524 && ! DECL_ABSTRACT_P (decl
)
23525 && ! class_or_namespace_scope_p (context_die
)
23526 /* dwarf2out_abstract_function won't emit a die if this is just
23527 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
23528 that case, because that works only if we have a die. */
23529 && DECL_INITIAL (decl
) != NULL_TREE
)
23531 dwarf2out_abstract_function (decl
);
23532 set_decl_origin_self (decl
);
23535 /* Otherwise we're emitting the primary DIE for this decl. */
23536 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
23538 /* Before we describe the FUNCTION_DECL itself, make sure that we
23539 have its containing type. */
23541 origin
= decl_class_context (decl
);
23542 if (origin
!= NULL_TREE
)
23543 gen_type_die (origin
, context_die
);
23545 /* And its return type. */
23546 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
23548 /* And its virtual context. */
23549 if (DECL_VINDEX (decl
) != NULL_TREE
)
23550 gen_type_die (DECL_CONTEXT (decl
), context_die
);
23552 /* Make sure we have a member DIE for decl. */
23553 if (origin
!= NULL_TREE
)
23554 gen_type_die_for_member (origin
, decl
, context_die
);
23556 /* And its containing namespace. */
23557 context_die
= declare_in_namespace (decl
, context_die
);
23560 /* Now output a DIE to represent the function itself. */
23562 gen_subprogram_die (decl
, context_die
);
23566 /* If we are in terse mode, don't generate any DIEs to represent any
23567 actual typedefs. */
23568 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23571 /* In the special case of a TYPE_DECL node representing the declaration
23572 of some type tag, if the given TYPE_DECL is marked as having been
23573 instantiated from some other (original) TYPE_DECL node (e.g. one which
23574 was generated within the original definition of an inline function) we
23575 used to generate a special (abbreviated) DW_TAG_structure_type,
23576 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
23577 should be actually referencing those DIEs, as variable DIEs with that
23578 type would be emitted already in the abstract origin, so it was always
23579 removed during unused type prunning. Don't add anything in this
23581 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
23584 if (is_redundant_typedef (decl
))
23585 gen_type_die (TREE_TYPE (decl
), context_die
);
23587 /* Output a DIE to represent the typedef itself. */
23588 gen_typedef_die (decl
, context_die
);
23592 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
23593 gen_label_die (decl
, context_die
);
23598 /* If we are in terse mode, don't generate any DIEs to represent any
23599 variable declarations or definitions. */
23600 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23603 /* Output any DIEs that are needed to specify the type of this data
23605 if (decl_by_reference_p (decl_or_origin
))
23606 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
23608 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
23610 /* And its containing type. */
23611 class_origin
= decl_class_context (decl_or_origin
);
23612 if (class_origin
!= NULL_TREE
)
23613 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
23615 /* And its containing namespace. */
23616 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
23618 /* Now output the DIE to represent the data object itself. This gets
23619 complicated because of the possibility that the VAR_DECL really
23620 represents an inlined instance of a formal parameter for an inline
23622 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
23623 if (ultimate_origin
!= NULL_TREE
23624 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
23625 gen_formal_parameter_die (decl
, origin
,
23626 true /* Emit name attribute. */,
23629 gen_variable_die (decl
, origin
, context_die
);
23633 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
23634 /* Ignore the nameless fields that are used to skip bits but handle C++
23635 anonymous unions and structs. */
23636 if (DECL_NAME (decl
) != NULL_TREE
23637 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
23638 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
23640 gen_type_die (member_declared_type (decl
), context_die
);
23641 gen_field_die (decl
, ctx
, context_die
);
23646 if (DECL_BY_REFERENCE (decl_or_origin
))
23647 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
23649 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
23650 return gen_formal_parameter_die (decl
, origin
,
23651 true /* Emit name attribute. */,
23654 case NAMESPACE_DECL
:
23655 if (dwarf_version
>= 3 || !dwarf_strict
)
23656 gen_namespace_die (decl
, context_die
);
23659 case IMPORTED_DECL
:
23660 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
23661 DECL_CONTEXT (decl
), context_die
);
23664 case NAMELIST_DECL
:
23665 gen_namelist_decl (DECL_NAME (decl
), context_die
,
23666 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
23670 /* Probably some frontend-internal decl. Assume we don't care. */
23671 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
23678 /* Output initial debug information for global DECL. Called at the
23679 end of the parsing process.
23681 This is the initial debug generation process. As such, the DIEs
23682 generated may be incomplete. A later debug generation pass
23683 (dwarf2out_late_global_decl) will augment the information generated
23684 in this pass (e.g., with complete location info). */
23687 dwarf2out_early_global_decl (tree decl
)
23691 /* gen_decl_die() will set DECL_ABSTRACT because
23692 cgraph_function_possibly_inlined_p() returns true. This is in
23693 turn will cause DW_AT_inline attributes to be set.
23695 This happens because at early dwarf generation, there is no
23696 cgraph information, causing cgraph_function_possibly_inlined_p()
23697 to return true. Trick cgraph_function_possibly_inlined_p()
23698 while we generate dwarf early. */
23699 bool save
= symtab
->global_info_ready
;
23700 symtab
->global_info_ready
= true;
23702 /* We don't handle TYPE_DECLs. If required, they'll be reached via
23703 other DECLs and they can point to template types or other things
23704 that dwarf2out can't handle when done via dwarf2out_decl. */
23705 if (TREE_CODE (decl
) != TYPE_DECL
23706 && TREE_CODE (decl
) != PARM_DECL
)
23708 tree save_fndecl
= current_function_decl
;
23709 if (TREE_CODE (decl
) == FUNCTION_DECL
)
23711 /* No cfun means the symbol has no body, so there's nothing
23713 if (!DECL_STRUCT_FUNCTION (decl
))
23714 goto early_decl_exit
;
23716 current_function_decl
= decl
;
23718 dwarf2out_decl (decl
);
23719 if (TREE_CODE (decl
) == FUNCTION_DECL
)
23720 current_function_decl
= save_fndecl
;
23723 symtab
->global_info_ready
= save
;
23726 /* Output debug information for global decl DECL. Called from
23727 toplev.c after compilation proper has finished. */
23730 dwarf2out_late_global_decl (tree decl
)
23732 /* We have to generate early debug late for LTO. */
23734 dwarf2out_early_global_decl (decl
);
23736 /* Fill-in any location information we were unable to determine
23737 on the first pass. */
23738 if (TREE_CODE (decl
) == VAR_DECL
23739 && !POINTER_BOUNDS_P (decl
))
23741 dw_die_ref die
= lookup_decl_die (decl
);
23743 add_location_or_const_value_attribute (die
, decl
, false);
23747 /* Output debug information for type decl DECL. Called from toplev.c
23748 and from language front ends (to record built-in types). */
23750 dwarf2out_type_decl (tree decl
, int local
)
23755 dwarf2out_decl (decl
);
23759 /* Output debug information for imported module or decl DECL.
23760 NAME is non-NULL name in the lexical block if the decl has been renamed.
23761 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
23762 that DECL belongs to.
23763 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
23765 dwarf2out_imported_module_or_decl_1 (tree decl
,
23767 tree lexical_block
,
23768 dw_die_ref lexical_block_die
)
23770 expanded_location xloc
;
23771 dw_die_ref imported_die
= NULL
;
23772 dw_die_ref at_import_die
;
23774 if (TREE_CODE (decl
) == IMPORTED_DECL
)
23776 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
23777 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
23781 xloc
= expand_location (input_location
);
23783 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
23785 at_import_die
= force_type_die (TREE_TYPE (decl
));
23786 /* For namespace N { typedef void T; } using N::T; base_type_die
23787 returns NULL, but DW_TAG_imported_declaration requires
23788 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
23789 if (!at_import_die
)
23791 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
23792 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
23793 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
23794 gcc_assert (at_import_die
);
23799 at_import_die
= lookup_decl_die (decl
);
23800 if (!at_import_die
)
23802 /* If we're trying to avoid duplicate debug info, we may not have
23803 emitted the member decl for this field. Emit it now. */
23804 if (TREE_CODE (decl
) == FIELD_DECL
)
23806 tree type
= DECL_CONTEXT (decl
);
23808 if (TYPE_CONTEXT (type
)
23809 && TYPE_P (TYPE_CONTEXT (type
))
23810 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
23811 DINFO_USAGE_DIR_USE
))
23813 gen_type_die_for_member (type
, decl
,
23814 get_context_die (TYPE_CONTEXT (type
)));
23816 if (TREE_CODE (decl
) == NAMELIST_DECL
)
23817 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
23818 get_context_die (DECL_CONTEXT (decl
)),
23821 at_import_die
= force_decl_die (decl
);
23825 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
23827 if (dwarf_version
>= 3 || !dwarf_strict
)
23828 imported_die
= new_die (DW_TAG_imported_module
,
23835 imported_die
= new_die (DW_TAG_imported_declaration
,
23839 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
23840 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
23842 add_AT_string (imported_die
, DW_AT_name
,
23843 IDENTIFIER_POINTER (name
));
23844 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
23847 /* Output debug information for imported module or decl DECL.
23848 NAME is non-NULL name in context if the decl has been renamed.
23849 CHILD is true if decl is one of the renamed decls as part of
23850 importing whole module. */
23853 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
23856 /* dw_die_ref at_import_die; */
23857 dw_die_ref scope_die
;
23859 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23866 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
23867 We need decl DIE for reference and scope die. First, get DIE for the decl
23870 /* Get the scope die for decl context. Use comp_unit_die for global module
23871 or decl. If die is not found for non globals, force new die. */
23873 && TYPE_P (context
)
23874 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
23877 if (!(dwarf_version
>= 3 || !dwarf_strict
))
23880 scope_die
= get_context_die (context
);
23884 gcc_assert (scope_die
->die_child
);
23885 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
23886 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
23887 scope_die
= scope_die
->die_child
;
23890 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
23891 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
23894 /* Output debug information for namelists. */
23897 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
23899 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
23903 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23906 gcc_assert (scope_die
!= NULL
);
23907 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
23908 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
23910 /* If there are no item_decls, we have a nondefining namelist, e.g.
23911 with USE association; hence, set DW_AT_declaration. */
23912 if (item_decls
== NULL_TREE
)
23914 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
23918 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
23920 nml_item_ref_die
= lookup_decl_die (value
);
23921 if (!nml_item_ref_die
)
23922 nml_item_ref_die
= force_decl_die (value
);
23924 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
23925 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
23931 /* Write the debugging output for DECL and return the DIE. */
23934 dwarf2out_decl (tree decl
)
23936 dw_die_ref context_die
= comp_unit_die ();
23938 switch (TREE_CODE (decl
))
23943 case FUNCTION_DECL
:
23944 /* What we would really like to do here is to filter out all mere
23945 file-scope declarations of file-scope functions which are never
23946 referenced later within this translation unit (and keep all of ones
23947 that *are* referenced later on) but we aren't clairvoyant, so we have
23948 no idea which functions will be referenced in the future (i.e. later
23949 on within the current translation unit). So here we just ignore all
23950 file-scope function declarations which are not also definitions. If
23951 and when the debugger needs to know something about these functions,
23952 it will have to hunt around and find the DWARF information associated
23953 with the definition of the function.
23955 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
23956 nodes represent definitions and which ones represent mere
23957 declarations. We have to check DECL_INITIAL instead. That's because
23958 the C front-end supports some weird semantics for "extern inline"
23959 function definitions. These can get inlined within the current
23960 translation unit (and thus, we need to generate Dwarf info for their
23961 abstract instances so that the Dwarf info for the concrete inlined
23962 instances can have something to refer to) but the compiler never
23963 generates any out-of-lines instances of such things (despite the fact
23964 that they *are* definitions).
23966 The important point is that the C front-end marks these "extern
23967 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
23968 them anyway. Note that the C++ front-end also plays some similar games
23969 for inline function definitions appearing within include files which
23970 also contain `#pragma interface' pragmas.
23972 If we are called from dwarf2out_abstract_function output a DIE
23973 anyway. We can end up here this way with early inlining and LTO
23974 where the inlined function is output in a different LTRANS unit
23976 if (DECL_INITIAL (decl
) == NULL_TREE
23977 && ! DECL_ABSTRACT_P (decl
))
23980 /* If we're a nested function, initially use a parent of NULL; if we're
23981 a plain function, this will be fixed up in decls_for_scope. If
23982 we're a method, it will be ignored, since we already have a DIE. */
23983 if (decl_function_context (decl
)
23984 /* But if we're in terse mode, we don't care about scope. */
23985 && debug_info_level
> DINFO_LEVEL_TERSE
)
23986 context_die
= NULL
;
23990 /* For local statics lookup proper context die. */
23991 if (local_function_static (decl
))
23992 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
23994 /* If we are in terse mode, don't generate any DIEs to represent any
23995 variable declarations or definitions. */
23996 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
24001 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
24003 if (!is_fortran () && !is_ada ())
24005 if (TREE_STATIC (decl
) && decl_function_context (decl
))
24006 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
24009 case NAMESPACE_DECL
:
24010 case IMPORTED_DECL
:
24011 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
24013 if (lookup_decl_die (decl
) != NULL
)
24018 /* Don't emit stubs for types unless they are needed by other DIEs. */
24019 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
24022 /* Don't bother trying to generate any DIEs to represent any of the
24023 normal built-in types for the language we are compiling. */
24024 if (DECL_IS_BUILTIN (decl
))
24027 /* If we are in terse mode, don't generate any DIEs for types. */
24028 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
24031 /* If we're a function-scope tag, initially use a parent of NULL;
24032 this will be fixed up in decls_for_scope. */
24033 if (decl_function_context (decl
))
24034 context_die
= NULL
;
24038 case NAMELIST_DECL
:
24045 gen_decl_die (decl
, NULL
, NULL
, context_die
);
24049 dw_die_ref die
= lookup_decl_die (decl
);
24055 /* Write the debugging output for DECL. */
24058 dwarf2out_function_decl (tree decl
)
24060 dwarf2out_decl (decl
);
24061 call_arg_locations
= NULL
;
24062 call_arg_loc_last
= NULL
;
24063 call_site_count
= -1;
24064 tail_call_site_count
= -1;
24065 decl_loc_table
->empty ();
24066 cached_dw_loc_list_table
->empty ();
24069 /* Output a marker (i.e. a label) for the beginning of the generated code for
24070 a lexical block. */
24073 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
24074 unsigned int blocknum
)
24076 switch_to_section (current_function_section ());
24077 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
24080 /* Output a marker (i.e. a label) for the end of the generated code for a
24084 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
24086 switch_to_section (current_function_section ());
24087 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
24090 /* Returns nonzero if it is appropriate not to emit any debugging
24091 information for BLOCK, because it doesn't contain any instructions.
24093 Don't allow this for blocks with nested functions or local classes
24094 as we would end up with orphans, and in the presence of scheduling
24095 we may end up calling them anyway. */
24098 dwarf2out_ignore_block (const_tree block
)
24103 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
24104 if (TREE_CODE (decl
) == FUNCTION_DECL
24105 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
24107 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
24109 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
24110 if (TREE_CODE (decl
) == FUNCTION_DECL
24111 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
24118 /* Hash table routines for file_hash. */
24121 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
24123 return filename_cmp (p1
->filename
, p2
) == 0;
24127 dwarf_file_hasher::hash (dwarf_file_data
*p
)
24129 return htab_hash_string (p
->filename
);
24132 /* Lookup FILE_NAME (in the list of filenames that we know about here in
24133 dwarf2out.c) and return its "index". The index of each (known) filename is
24134 just a unique number which is associated with only that one filename. We
24135 need such numbers for the sake of generating labels (in the .debug_sfnames
24136 section) and references to those files numbers (in the .debug_srcinfo
24137 and .debug_macinfo sections). If the filename given as an argument is not
24138 found in our current list, add it to the list and assign it the next
24139 available unique index number. */
24141 static struct dwarf_file_data
*
24142 lookup_filename (const char *file_name
)
24144 struct dwarf_file_data
* created
;
24149 dwarf_file_data
**slot
24150 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
24155 created
= ggc_alloc
<dwarf_file_data
> ();
24156 created
->filename
= file_name
;
24157 created
->emitted_number
= 0;
24162 /* If the assembler will construct the file table, then translate the compiler
24163 internal file table number into the assembler file table number, and emit
24164 a .file directive if we haven't already emitted one yet. The file table
24165 numbers are different because we prune debug info for unused variables and
24166 types, which may include filenames. */
24169 maybe_emit_file (struct dwarf_file_data
* fd
)
24171 if (! fd
->emitted_number
)
24173 if (last_emitted_file
)
24174 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
24176 fd
->emitted_number
= 1;
24177 last_emitted_file
= fd
;
24179 if (DWARF2_ASM_LINE_DEBUG_INFO
)
24181 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
24182 output_quoted_string (asm_out_file
,
24183 remap_debug_filename (fd
->filename
));
24184 fputc ('\n', asm_out_file
);
24188 return fd
->emitted_number
;
24191 /* Schedule generation of a DW_AT_const_value attribute to DIE.
24192 That generation should happen after function debug info has been
24193 generated. The value of the attribute is the constant value of ARG. */
24196 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
24198 die_arg_entry entry
;
24203 gcc_assert (early_dwarf
);
24205 if (!tmpl_value_parm_die_table
)
24206 vec_alloc (tmpl_value_parm_die_table
, 32);
24210 vec_safe_push (tmpl_value_parm_die_table
, entry
);
24213 /* Return TRUE if T is an instance of generic type, FALSE
24217 generic_type_p (tree t
)
24219 if (t
== NULL_TREE
|| !TYPE_P (t
))
24221 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
24224 /* Schedule the generation of the generic parameter dies for the
24225 instance of generic type T. The proper generation itself is later
24226 done by gen_scheduled_generic_parms_dies. */
24229 schedule_generic_params_dies_gen (tree t
)
24231 if (!generic_type_p (t
))
24234 gcc_assert (early_dwarf
);
24236 if (!generic_type_instances
)
24237 vec_alloc (generic_type_instances
, 256);
24239 vec_safe_push (generic_type_instances
, t
);
24242 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
24243 by append_entry_to_tmpl_value_parm_die_table. This function must
24244 be called after function DIEs have been generated. */
24247 gen_remaining_tmpl_value_param_die_attribute (void)
24249 if (tmpl_value_parm_die_table
)
24254 /* We do this in two phases - first get the cases we can
24255 handle during early-finish, preserving those we cannot
24256 (containing symbolic constants where we don't yet know
24257 whether we are going to output the referenced symbols).
24258 For those we try again at late-finish. */
24260 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
24262 if (!tree_add_const_value_attribute (e
->die
, e
->arg
))
24264 dw_loc_descr_ref loc
= NULL
;
24265 if (dwarf_version
>= 5 || !dwarf_strict
)
24266 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
24268 add_AT_loc (e
->die
, DW_AT_location
, loc
);
24270 (*tmpl_value_parm_die_table
)[j
++] = *e
;
24273 tmpl_value_parm_die_table
->truncate (j
);
24277 /* Generate generic parameters DIEs for instances of generic types
24278 that have been previously scheduled by
24279 schedule_generic_params_dies_gen. This function must be called
24280 after all the types of the CU have been laid out. */
24283 gen_scheduled_generic_parms_dies (void)
24288 if (!generic_type_instances
)
24291 /* We end up "recursing" into schedule_generic_params_dies_gen, so
24292 pretend this generation is part of "early dwarf" as well. */
24295 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
24296 if (COMPLETE_TYPE_P (t
))
24297 gen_generic_params_dies (t
);
24299 generic_type_instances
= NULL
;
24303 /* Replace DW_AT_name for the decl with name. */
24306 dwarf2out_set_name (tree decl
, tree name
)
24309 dw_attr_node
*attr
;
24312 die
= TYPE_SYMTAB_DIE (decl
);
24316 dname
= dwarf2_name (name
, 0);
24320 attr
= get_AT (die
, DW_AT_name
);
24323 struct indirect_string_node
*node
;
24325 node
= find_AT_string (dname
);
24326 /* replace the string. */
24327 attr
->dw_attr_val
.v
.val_str
= node
;
24331 add_name_attribute (die
, dname
);
24334 /* True if before or during processing of the first function being emitted. */
24335 static bool in_first_function_p
= true;
24336 /* True if loc_note during dwarf2out_var_location call might still be
24337 before first real instruction at address equal to .Ltext0. */
24338 static bool maybe_at_text_label_p
= true;
24339 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
24340 static unsigned int first_loclabel_num_not_at_text_label
;
24342 /* Called by the final INSN scan whenever we see a var location. We
24343 use it to drop labels in the right places, and throw the location in
24344 our lookup table. */
24347 dwarf2out_var_location (rtx_insn
*loc_note
)
24349 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
24350 struct var_loc_node
*newloc
;
24351 rtx_insn
*next_real
, *next_note
;
24352 rtx_insn
*call_insn
= NULL
;
24353 static const char *last_label
;
24354 static const char *last_postcall_label
;
24355 static bool last_in_cold_section_p
;
24356 static rtx_insn
*expected_next_loc_note
;
24360 if (!NOTE_P (loc_note
))
24362 if (CALL_P (loc_note
))
24365 if (SIBLING_CALL_P (loc_note
))
24366 tail_call_site_count
++;
24367 if (optimize
== 0 && !flag_var_tracking
)
24369 /* When the var-tracking pass is not running, there is no note
24370 for indirect calls whose target is compile-time known. In this
24371 case, process such calls specifically so that we generate call
24372 sites for them anyway. */
24373 rtx x
= PATTERN (loc_note
);
24374 if (GET_CODE (x
) == PARALLEL
)
24375 x
= XVECEXP (x
, 0, 0);
24376 if (GET_CODE (x
) == SET
)
24378 if (GET_CODE (x
) == CALL
)
24381 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
24382 || !SYMBOL_REF_DECL (XEXP (x
, 0))
24383 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
24386 call_insn
= loc_note
;
24390 next_real
= next_real_insn (call_insn
);
24392 cached_next_real_insn
= NULL
;
24400 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
24401 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
24404 /* Optimize processing a large consecutive sequence of location
24405 notes so we don't spend too much time in next_real_insn. If the
24406 next insn is another location note, remember the next_real_insn
24407 calculation for next time. */
24408 next_real
= cached_next_real_insn
;
24411 if (expected_next_loc_note
!= loc_note
)
24415 next_note
= NEXT_INSN (loc_note
);
24417 || next_note
->deleted ()
24418 || ! NOTE_P (next_note
)
24419 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
24420 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
24424 next_real
= next_real_insn (loc_note
);
24428 expected_next_loc_note
= next_note
;
24429 cached_next_real_insn
= next_real
;
24432 cached_next_real_insn
= NULL
;
24434 /* If there are no instructions which would be affected by this note,
24435 don't do anything. */
24437 && next_real
== NULL_RTX
24438 && !NOTE_DURING_CALL_P (loc_note
))
24443 if (next_real
== NULL_RTX
)
24444 next_real
= get_last_insn ();
24446 /* If there were any real insns between note we processed last time
24447 and this note (or if it is the first note), clear
24448 last_{,postcall_}label so that they are not reused this time. */
24449 if (last_var_location_insn
== NULL_RTX
24450 || last_var_location_insn
!= next_real
24451 || last_in_cold_section_p
!= in_cold_section_p
)
24454 last_postcall_label
= NULL
;
24459 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
24460 newloc
= add_var_loc_to_decl (decl
, loc_note
,
24461 NOTE_DURING_CALL_P (loc_note
)
24462 ? last_postcall_label
: last_label
);
24463 if (newloc
== NULL
)
24472 /* If there were no real insns between note we processed last time
24473 and this note, use the label we emitted last time. Otherwise
24474 create a new label and emit it. */
24475 if (last_label
== NULL
)
24477 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
24478 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
24480 last_label
= ggc_strdup (loclabel
);
24481 /* See if loclabel might be equal to .Ltext0. If yes,
24482 bump first_loclabel_num_not_at_text_label. */
24483 if (!have_multiple_function_sections
24484 && in_first_function_p
24485 && maybe_at_text_label_p
)
24487 static rtx_insn
*last_start
;
24489 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
24490 if (insn
== last_start
)
24492 else if (!NONDEBUG_INSN_P (insn
))
24496 rtx body
= PATTERN (insn
);
24497 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
24499 /* Inline asm could occupy zero bytes. */
24500 else if (GET_CODE (body
) == ASM_INPUT
24501 || asm_noperands (body
) >= 0)
24503 #ifdef HAVE_attr_length
24504 else if (get_attr_min_length (insn
) == 0)
24509 /* Assume insn has non-zero length. */
24510 maybe_at_text_label_p
= false;
24514 if (maybe_at_text_label_p
)
24516 last_start
= loc_note
;
24517 first_loclabel_num_not_at_text_label
= loclabel_num
;
24522 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
24523 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
24527 struct call_arg_loc_node
*ca_loc
24528 = ggc_cleared_alloc
<call_arg_loc_node
> ();
24530 = loc_note
!= NULL_RTX
? prev_real_insn (loc_note
) : call_insn
;
24532 ca_loc
->call_arg_loc_note
= loc_note
;
24533 ca_loc
->next
= NULL
;
24534 ca_loc
->label
= last_label
;
24537 || (NONJUMP_INSN_P (prev
)
24538 && GET_CODE (PATTERN (prev
)) == SEQUENCE
24539 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
24540 if (!CALL_P (prev
))
24541 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
24542 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
24544 /* Look for a SYMBOL_REF in the "prev" instruction. */
24545 rtx x
= get_call_rtx_from (PATTERN (prev
));
24548 /* Try to get the call symbol, if any. */
24549 if (MEM_P (XEXP (x
, 0)))
24551 /* First, look for a memory access to a symbol_ref. */
24552 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
24553 && SYMBOL_REF_DECL (XEXP (x
, 0))
24554 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
24555 ca_loc
->symbol_ref
= XEXP (x
, 0);
24556 /* Otherwise, look at a compile-time known user-level function
24560 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
24561 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
24564 ca_loc
->block
= insn_scope (prev
);
24565 if (call_arg_locations
)
24566 call_arg_loc_last
->next
= ca_loc
;
24568 call_arg_locations
= ca_loc
;
24569 call_arg_loc_last
= ca_loc
;
24571 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
24572 newloc
->label
= last_label
;
24575 if (!last_postcall_label
)
24577 sprintf (loclabel
, "%s-1", last_label
);
24578 last_postcall_label
= ggc_strdup (loclabel
);
24580 newloc
->label
= last_postcall_label
;
24583 last_var_location_insn
= next_real
;
24584 last_in_cold_section_p
= in_cold_section_p
;
24587 /* Called from finalize_size_functions for size functions so that their body
24588 can be encoded in the debug info to describe the layout of variable-length
24592 dwarf2out_size_function (tree decl
)
24594 function_to_dwarf_procedure (decl
);
24597 /* Note in one location list that text section has changed. */
24600 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
24602 var_loc_list
*list
= *slot
;
24604 list
->last_before_switch
24605 = list
->last
->next
? list
->last
->next
: list
->last
;
24609 /* Note in all location lists that text section has changed. */
24612 var_location_switch_text_section (void)
24614 if (decl_loc_table
== NULL
)
24617 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
24620 /* Create a new line number table. */
24622 static dw_line_info_table
*
24623 new_line_info_table (void)
24625 dw_line_info_table
*table
;
24627 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
24628 table
->file_num
= 1;
24629 table
->line_num
= 1;
24630 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
24635 /* Lookup the "current" table into which we emit line info, so
24636 that we don't have to do it for every source line. */
24639 set_cur_line_info_table (section
*sec
)
24641 dw_line_info_table
*table
;
24643 if (sec
== text_section
)
24644 table
= text_section_line_info
;
24645 else if (sec
== cold_text_section
)
24647 table
= cold_text_section_line_info
;
24650 cold_text_section_line_info
= table
= new_line_info_table ();
24651 table
->end_label
= cold_end_label
;
24656 const char *end_label
;
24658 if (flag_reorder_blocks_and_partition
)
24660 if (in_cold_section_p
)
24661 end_label
= crtl
->subsections
.cold_section_end_label
;
24663 end_label
= crtl
->subsections
.hot_section_end_label
;
24667 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
24668 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
24669 current_function_funcdef_no
);
24670 end_label
= ggc_strdup (label
);
24673 table
= new_line_info_table ();
24674 table
->end_label
= end_label
;
24676 vec_safe_push (separate_line_info
, table
);
24679 if (DWARF2_ASM_LINE_DEBUG_INFO
)
24680 table
->is_stmt
= (cur_line_info_table
24681 ? cur_line_info_table
->is_stmt
24682 : DWARF_LINE_DEFAULT_IS_STMT_START
);
24683 cur_line_info_table
= table
;
24687 /* We need to reset the locations at the beginning of each
24688 function. We can't do this in the end_function hook, because the
24689 declarations that use the locations won't have been output when
24690 that hook is called. Also compute have_multiple_function_sections here. */
24693 dwarf2out_begin_function (tree fun
)
24695 section
*sec
= function_section (fun
);
24697 if (sec
!= text_section
)
24698 have_multiple_function_sections
= true;
24700 if (flag_reorder_blocks_and_partition
&& !cold_text_section
)
24702 gcc_assert (current_function_decl
== fun
);
24703 cold_text_section
= unlikely_text_section ();
24704 switch_to_section (cold_text_section
);
24705 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
24706 switch_to_section (sec
);
24709 dwarf2out_note_section_used ();
24710 call_site_count
= 0;
24711 tail_call_site_count
= 0;
24713 set_cur_line_info_table (sec
);
24716 /* Helper function of dwarf2out_end_function, called only after emitting
24717 the very first function into assembly. Check if some .debug_loc range
24718 might end with a .LVL* label that could be equal to .Ltext0.
24719 In that case we must force using absolute addresses in .debug_loc ranges,
24720 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
24721 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
24723 Set have_multiple_function_sections to true in that case and
24724 terminate htab traversal. */
24727 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
24729 var_loc_list
*entry
= *slot
;
24730 struct var_loc_node
*node
;
24732 node
= entry
->first
;
24733 if (node
&& node
->next
&& node
->next
->label
)
24736 const char *label
= node
->next
->label
;
24737 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
24739 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
24741 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
24742 if (strcmp (label
, loclabel
) == 0)
24744 have_multiple_function_sections
= true;
24752 /* Hook called after emitting a function into assembly.
24753 This does something only for the very first function emitted. */
24756 dwarf2out_end_function (unsigned int)
24758 if (in_first_function_p
24759 && !have_multiple_function_sections
24760 && first_loclabel_num_not_at_text_label
24762 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
24763 in_first_function_p
= false;
24764 maybe_at_text_label_p
= false;
24767 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
24768 front-ends register a translation unit even before dwarf2out_init is
24770 static tree main_translation_unit
= NULL_TREE
;
24772 /* Hook called by front-ends after they built their main translation unit.
24773 Associate comp_unit_die to UNIT. */
24776 dwarf2out_register_main_translation_unit (tree unit
)
24778 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
24779 && main_translation_unit
== NULL_TREE
);
24780 main_translation_unit
= unit
;
24781 /* If dwarf2out_init has not been called yet, it will perform the association
24782 itself looking at main_translation_unit. */
24783 if (decl_die_table
!= NULL
)
24784 equate_decl_number_to_die (unit
, comp_unit_die ());
24787 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
24790 push_dw_line_info_entry (dw_line_info_table
*table
,
24791 enum dw_line_info_opcode opcode
, unsigned int val
)
24793 dw_line_info_entry e
;
24796 vec_safe_push (table
->entries
, e
);
24799 /* Output a label to mark the beginning of a source code line entry
24800 and record information relating to this source line, in
24801 'line_info_table' for later output of the .debug_line section. */
24802 /* ??? The discriminator parameter ought to be unsigned. */
24805 dwarf2out_source_line (unsigned int line
, const char *filename
,
24806 int discriminator
, bool is_stmt
)
24808 unsigned int file_num
;
24809 dw_line_info_table
*table
;
24811 if (debug_info_level
< DINFO_LEVEL_TERSE
|| line
== 0)
24814 /* The discriminator column was added in dwarf4. Simplify the below
24815 by simply removing it if we're not supposed to output it. */
24816 if (dwarf_version
< 4 && dwarf_strict
)
24819 table
= cur_line_info_table
;
24820 file_num
= maybe_emit_file (lookup_filename (filename
));
24822 /* ??? TODO: Elide duplicate line number entries. Traditionally,
24823 the debugger has used the second (possibly duplicate) line number
24824 at the beginning of the function to mark the end of the prologue.
24825 We could eliminate any other duplicates within the function. For
24826 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
24827 that second line number entry. */
24828 /* Recall that this end-of-prologue indication is *not* the same thing
24829 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
24830 to which the hook corresponds, follows the last insn that was
24831 emitted by gen_prologue. What we need is to precede the first insn
24832 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
24833 insn that corresponds to something the user wrote. These may be
24834 very different locations once scheduling is enabled. */
24836 if (0 && file_num
== table
->file_num
24837 && line
== table
->line_num
24838 && discriminator
== table
->discrim_num
24839 && is_stmt
== table
->is_stmt
)
24842 switch_to_section (current_function_section ());
24844 /* If requested, emit something human-readable. */
24845 if (flag_debug_asm
)
24846 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
, filename
, line
);
24848 if (DWARF2_ASM_LINE_DEBUG_INFO
)
24850 /* Emit the .loc directive understood by GNU as. */
24851 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
24852 file_num, line, is_stmt, discriminator */
24853 fputs ("\t.loc ", asm_out_file
);
24854 fprint_ul (asm_out_file
, file_num
);
24855 putc (' ', asm_out_file
);
24856 fprint_ul (asm_out_file
, line
);
24857 putc (' ', asm_out_file
);
24858 putc ('0', asm_out_file
);
24860 if (is_stmt
!= table
->is_stmt
)
24862 fputs (" is_stmt ", asm_out_file
);
24863 putc (is_stmt
? '1' : '0', asm_out_file
);
24865 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
24867 gcc_assert (discriminator
> 0);
24868 fputs (" discriminator ", asm_out_file
);
24869 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
24871 putc ('\n', asm_out_file
);
24875 unsigned int label_num
= ++line_info_label_num
;
24877 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
24879 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
24880 if (file_num
!= table
->file_num
)
24881 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
24882 if (discriminator
!= table
->discrim_num
)
24883 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
24884 if (is_stmt
!= table
->is_stmt
)
24885 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
24886 push_dw_line_info_entry (table
, LI_set_line
, line
);
24889 table
->file_num
= file_num
;
24890 table
->line_num
= line
;
24891 table
->discrim_num
= discriminator
;
24892 table
->is_stmt
= is_stmt
;
24893 table
->in_use
= true;
24896 /* Record the beginning of a new source file. */
24899 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
24901 if (flag_eliminate_dwarf2_dups
)
24903 /* Record the beginning of the file for break_out_includes. */
24904 dw_die_ref bincl_die
;
24906 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die (), NULL
);
24907 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
24910 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
24913 e
.code
= DW_MACINFO_start_file
;
24915 e
.info
= ggc_strdup (filename
);
24916 vec_safe_push (macinfo_table
, e
);
24920 /* Record the end of a source file. */
24923 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
24925 if (flag_eliminate_dwarf2_dups
)
24926 /* Record the end of the file for break_out_includes. */
24927 new_die (DW_TAG_GNU_EINCL
, comp_unit_die (), NULL
);
24929 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
24932 e
.code
= DW_MACINFO_end_file
;
24935 vec_safe_push (macinfo_table
, e
);
24939 /* Called from debug_define in toplev.c. The `buffer' parameter contains
24940 the tail part of the directive line, i.e. the part which is past the
24941 initial whitespace, #, whitespace, directive-name, whitespace part. */
24944 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
24945 const char *buffer ATTRIBUTE_UNUSED
)
24947 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
24950 /* Insert a dummy first entry to be able to optimize the whole
24951 predefined macro block using DW_MACRO_GNU_transparent_include. */
24952 if (macinfo_table
->is_empty () && lineno
<= 1)
24957 vec_safe_push (macinfo_table
, e
);
24959 e
.code
= DW_MACINFO_define
;
24961 e
.info
= ggc_strdup (buffer
);
24962 vec_safe_push (macinfo_table
, e
);
24966 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
24967 the tail part of the directive line, i.e. the part which is past the
24968 initial whitespace, #, whitespace, directive-name, whitespace part. */
24971 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
24972 const char *buffer ATTRIBUTE_UNUSED
)
24974 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
24977 /* Insert a dummy first entry to be able to optimize the whole
24978 predefined macro block using DW_MACRO_GNU_transparent_include. */
24979 if (macinfo_table
->is_empty () && lineno
<= 1)
24984 vec_safe_push (macinfo_table
, e
);
24986 e
.code
= DW_MACINFO_undef
;
24988 e
.info
= ggc_strdup (buffer
);
24989 vec_safe_push (macinfo_table
, e
);
24993 /* Helpers to manipulate hash table of CUs. */
24995 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
24997 static inline hashval_t
hash (const macinfo_entry
*);
24998 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
25002 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
25004 return htab_hash_string (entry
->info
);
25008 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
25009 const macinfo_entry
*entry2
)
25011 return !strcmp (entry1
->info
, entry2
->info
);
25014 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
25016 /* Output a single .debug_macinfo entry. */
25019 output_macinfo_op (macinfo_entry
*ref
)
25023 struct indirect_string_node
*node
;
25024 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
25025 struct dwarf_file_data
*fd
;
25029 case DW_MACINFO_start_file
:
25030 fd
= lookup_filename (ref
->info
);
25031 file_num
= maybe_emit_file (fd
);
25032 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
25033 dw2_asm_output_data_uleb128 (ref
->lineno
,
25034 "Included from line number %lu",
25035 (unsigned long) ref
->lineno
);
25036 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
25038 case DW_MACINFO_end_file
:
25039 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
25041 case DW_MACINFO_define
:
25042 case DW_MACINFO_undef
:
25043 len
= strlen (ref
->info
) + 1;
25045 && len
> DWARF_OFFSET_SIZE
25046 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
25047 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
25049 ref
->code
= ref
->code
== DW_MACINFO_define
25050 ? DW_MACRO_GNU_define_indirect
25051 : DW_MACRO_GNU_undef_indirect
;
25052 output_macinfo_op (ref
);
25055 dw2_asm_output_data (1, ref
->code
,
25056 ref
->code
== DW_MACINFO_define
25057 ? "Define macro" : "Undefine macro");
25058 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
25059 (unsigned long) ref
->lineno
);
25060 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
25062 case DW_MACRO_GNU_define_indirect
:
25063 case DW_MACRO_GNU_undef_indirect
:
25064 node
= find_AT_string (ref
->info
);
25066 && ((node
->form
== DW_FORM_strp
)
25067 || (node
->form
== DW_FORM_GNU_str_index
)));
25068 dw2_asm_output_data (1, ref
->code
,
25069 ref
->code
== DW_MACRO_GNU_define_indirect
25070 ? "Define macro indirect"
25071 : "Undefine macro indirect");
25072 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
25073 (unsigned long) ref
->lineno
);
25074 if (node
->form
== DW_FORM_strp
)
25075 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
25076 debug_str_section
, "The macro: \"%s\"",
25079 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
25082 case DW_MACRO_GNU_transparent_include
:
25083 dw2_asm_output_data (1, ref
->code
, "Transparent include");
25084 ASM_GENERATE_INTERNAL_LABEL (label
,
25085 DEBUG_MACRO_SECTION_LABEL
, ref
->lineno
);
25086 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
25089 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
25090 ASM_COMMENT_START
, (unsigned long) ref
->code
);
25095 /* Attempt to make a sequence of define/undef macinfo ops shareable with
25096 other compilation unit .debug_macinfo sections. IDX is the first
25097 index of a define/undef, return the number of ops that should be
25098 emitted in a comdat .debug_macinfo section and emit
25099 a DW_MACRO_GNU_transparent_include entry referencing it.
25100 If the define/undef entry should be emitted normally, return 0. */
25103 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
25104 macinfo_hash_type
**macinfo_htab
)
25106 macinfo_entry
*first
, *second
, *cur
, *inc
;
25107 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
25108 unsigned char checksum
[16];
25109 struct md5_ctx ctx
;
25110 char *grp_name
, *tail
;
25112 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
25113 macinfo_entry
**slot
;
25115 first
= &(*macinfo_table
)[idx
];
25116 second
= &(*macinfo_table
)[idx
+ 1];
25118 /* Optimize only if there are at least two consecutive define/undef ops,
25119 and either all of them are before first DW_MACINFO_start_file
25120 with lineno {0,1} (i.e. predefined macro block), or all of them are
25121 in some included header file. */
25122 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
25124 if (vec_safe_is_empty (files
))
25126 if (first
->lineno
> 1 || second
->lineno
> 1)
25129 else if (first
->lineno
== 0)
25132 /* Find the last define/undef entry that can be grouped together
25133 with first and at the same time compute md5 checksum of their
25134 codes, linenumbers and strings. */
25135 md5_init_ctx (&ctx
);
25136 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
25137 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
25139 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
25143 unsigned char code
= cur
->code
;
25144 md5_process_bytes (&code
, 1, &ctx
);
25145 checksum_uleb128 (cur
->lineno
, &ctx
);
25146 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
25148 md5_finish_ctx (&ctx
, checksum
);
25151 /* From the containing include filename (if any) pick up just
25152 usable characters from its basename. */
25153 if (vec_safe_is_empty (files
))
25156 base
= lbasename (files
->last ().info
);
25157 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
25158 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
25159 encoded_filename_len
++;
25160 /* Count . at the end. */
25161 if (encoded_filename_len
)
25162 encoded_filename_len
++;
25164 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
25165 linebuf_len
= strlen (linebuf
);
25167 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
25168 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
25170 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
25171 tail
= grp_name
+ 4;
25172 if (encoded_filename_len
)
25174 for (i
= 0; base
[i
]; i
++)
25175 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
25179 memcpy (tail
, linebuf
, linebuf_len
);
25180 tail
+= linebuf_len
;
25182 for (i
= 0; i
< 16; i
++)
25183 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
25185 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
25186 in the empty vector entry before the first define/undef. */
25187 inc
= &(*macinfo_table
)[idx
- 1];
25188 inc
->code
= DW_MACRO_GNU_transparent_include
;
25190 inc
->info
= ggc_strdup (grp_name
);
25191 if (!*macinfo_htab
)
25192 *macinfo_htab
= new macinfo_hash_type (10);
25193 /* Avoid emitting duplicates. */
25194 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
25199 /* If such an entry has been used before, just emit
25200 a DW_MACRO_GNU_transparent_include op. */
25202 output_macinfo_op (inc
);
25203 /* And clear all macinfo_entry in the range to avoid emitting them
25204 in the second pass. */
25205 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
25214 inc
->lineno
= (*macinfo_htab
)->elements ();
25215 output_macinfo_op (inc
);
25220 /* Save any strings needed by the macinfo table in the debug str
25221 table. All strings must be collected into the table by the time
25222 index_string is called. */
25225 save_macinfo_strings (void)
25229 macinfo_entry
*ref
;
25231 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
25235 /* Match the logic in output_macinfo_op to decide on
25236 indirect strings. */
25237 case DW_MACINFO_define
:
25238 case DW_MACINFO_undef
:
25239 len
= strlen (ref
->info
) + 1;
25241 && len
> DWARF_OFFSET_SIZE
25242 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
25243 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
25244 set_indirect_string (find_AT_string (ref
->info
));
25246 case DW_MACRO_GNU_define_indirect
:
25247 case DW_MACRO_GNU_undef_indirect
:
25248 set_indirect_string (find_AT_string (ref
->info
));
25256 /* Output macinfo section(s). */
25259 output_macinfo (void)
25262 unsigned long length
= vec_safe_length (macinfo_table
);
25263 macinfo_entry
*ref
;
25264 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
25265 macinfo_hash_type
*macinfo_htab
= NULL
;
25270 /* output_macinfo* uses these interchangeably. */
25271 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_GNU_define
25272 && (int) DW_MACINFO_undef
== (int) DW_MACRO_GNU_undef
25273 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_GNU_start_file
25274 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_GNU_end_file
);
25276 /* For .debug_macro emit the section header. */
25279 dw2_asm_output_data (2, 4, "DWARF macro version number");
25280 if (DWARF_OFFSET_SIZE
== 8)
25281 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
25283 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
25284 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
25285 (!dwarf_split_debug_info
? debug_line_section_label
25286 : debug_skeleton_line_section_label
),
25287 debug_line_section
, NULL
);
25290 /* In the first loop, it emits the primary .debug_macinfo section
25291 and after each emitted op the macinfo_entry is cleared.
25292 If a longer range of define/undef ops can be optimized using
25293 DW_MACRO_GNU_transparent_include, the
25294 DW_MACRO_GNU_transparent_include op is emitted and kept in
25295 the vector before the first define/undef in the range and the
25296 whole range of define/undef ops is not emitted and kept. */
25297 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
25301 case DW_MACINFO_start_file
:
25302 vec_safe_push (files
, *ref
);
25304 case DW_MACINFO_end_file
:
25305 if (!vec_safe_is_empty (files
))
25308 case DW_MACINFO_define
:
25309 case DW_MACINFO_undef
:
25311 && HAVE_COMDAT_GROUP
25312 && vec_safe_length (files
) != 1
25315 && (*macinfo_table
)[i
- 1].code
== 0)
25317 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
25326 /* A dummy entry may be inserted at the beginning to be able
25327 to optimize the whole block of predefined macros. */
25333 output_macinfo_op (ref
);
25341 delete macinfo_htab
;
25342 macinfo_htab
= NULL
;
25344 /* If any DW_MACRO_GNU_transparent_include were used, on those
25345 DW_MACRO_GNU_transparent_include entries terminate the
25346 current chain and switch to a new comdat .debug_macinfo
25347 section and emit the define/undef entries within it. */
25348 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
25353 case DW_MACRO_GNU_transparent_include
:
25355 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
25356 tree comdat_key
= get_identifier (ref
->info
);
25357 /* Terminate the previous .debug_macinfo section. */
25358 dw2_asm_output_data (1, 0, "End compilation unit");
25359 targetm
.asm_out
.named_section (DEBUG_MACRO_SECTION
,
25361 | SECTION_LINKONCE
,
25363 ASM_GENERATE_INTERNAL_LABEL (label
,
25364 DEBUG_MACRO_SECTION_LABEL
,
25366 ASM_OUTPUT_LABEL (asm_out_file
, label
);
25369 dw2_asm_output_data (2, 4, "DWARF macro version number");
25370 if (DWARF_OFFSET_SIZE
== 8)
25371 dw2_asm_output_data (1, 1, "Flags: 64-bit");
25373 dw2_asm_output_data (1, 0, "Flags: 32-bit");
25376 case DW_MACINFO_define
:
25377 case DW_MACINFO_undef
:
25378 output_macinfo_op (ref
);
25383 gcc_unreachable ();
25387 /* Set up for Dwarf output at the start of compilation. */
25390 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
25392 /* This option is currently broken, see (PR53118 and PR46102). */
25393 if (flag_eliminate_dwarf2_dups
25394 && strstr (lang_hooks
.name
, "C++"))
25396 warning (0, "-feliminate-dwarf2-dups is broken for C++, ignoring");
25397 flag_eliminate_dwarf2_dups
= 0;
25400 /* Allocate the file_table. */
25401 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
25403 #ifndef DWARF2_LINENO_DEBUGGING_INFO
25404 /* Allocate the decl_die_table. */
25405 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
25407 /* Allocate the decl_loc_table. */
25408 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
25410 /* Allocate the cached_dw_loc_list_table. */
25411 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
25413 /* Allocate the initial hunk of the decl_scope_table. */
25414 vec_alloc (decl_scope_table
, 256);
25416 /* Allocate the initial hunk of the abbrev_die_table. */
25417 abbrev_die_table
= ggc_cleared_vec_alloc
<dw_die_ref
>
25418 (ABBREV_DIE_TABLE_INCREMENT
);
25419 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
25420 /* Zero-th entry is allocated, but unused. */
25421 abbrev_die_table_in_use
= 1;
25423 /* Allocate the dwarf_proc_stack_usage_map. */
25424 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
25426 /* Allocate the pubtypes and pubnames vectors. */
25427 vec_alloc (pubname_table
, 32);
25428 vec_alloc (pubtype_table
, 32);
25430 vec_alloc (incomplete_types
, 64);
25432 vec_alloc (used_rtx_array
, 32);
25434 if (!dwarf_split_debug_info
)
25436 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
25437 SECTION_DEBUG
, NULL
);
25438 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
25439 SECTION_DEBUG
, NULL
);
25440 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
25441 SECTION_DEBUG
, NULL
);
25445 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
25446 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
25447 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
25448 SECTION_DEBUG
| SECTION_EXCLUDE
,
25450 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
25451 SECTION_DEBUG
, NULL
);
25452 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
25453 SECTION_DEBUG
, NULL
);
25454 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
25455 SECTION_DEBUG
, NULL
);
25456 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
25457 DEBUG_SKELETON_ABBREV_SECTION_LABEL
, 0);
25459 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
25460 the main .o, but the skeleton_line goes into the split off dwo. */
25461 debug_skeleton_line_section
25462 = get_section (DEBUG_DWO_LINE_SECTION
,
25463 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
25464 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
25465 DEBUG_SKELETON_LINE_SECTION_LABEL
, 0);
25466 debug_str_offsets_section
= get_section (DEBUG_STR_OFFSETS_SECTION
,
25467 SECTION_DEBUG
| SECTION_EXCLUDE
,
25469 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
25470 DEBUG_SKELETON_INFO_SECTION_LABEL
, 0);
25471 debug_loc_section
= get_section (DEBUG_DWO_LOC_SECTION
,
25472 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
25473 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
25474 DEBUG_STR_DWO_SECTION_FLAGS
, NULL
);
25476 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
25477 SECTION_DEBUG
, NULL
);
25478 debug_macinfo_section
= get_section (dwarf_strict
25479 ? DEBUG_MACINFO_SECTION
25480 : DEBUG_MACRO_SECTION
,
25481 DEBUG_MACRO_SECTION_FLAGS
, NULL
);
25482 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
25483 SECTION_DEBUG
, NULL
);
25484 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
25485 SECTION_DEBUG
, NULL
);
25486 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
25487 SECTION_DEBUG
, NULL
);
25488 debug_str_section
= get_section (DEBUG_STR_SECTION
,
25489 DEBUG_STR_SECTION_FLAGS
, NULL
);
25490 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
25491 SECTION_DEBUG
, NULL
);
25492 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
25493 SECTION_DEBUG
, NULL
);
25495 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
25496 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
25497 DEBUG_ABBREV_SECTION_LABEL
, 0);
25498 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
25499 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
25500 COLD_TEXT_SECTION_LABEL
, 0);
25501 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
25503 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
25504 DEBUG_INFO_SECTION_LABEL
, 0);
25505 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
25506 DEBUG_LINE_SECTION_LABEL
, 0);
25507 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
25508 DEBUG_RANGES_SECTION_LABEL
, 0);
25509 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
25510 DEBUG_ADDR_SECTION_LABEL
, 0);
25511 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
25513 ? DEBUG_MACINFO_SECTION_LABEL
25514 : DEBUG_MACRO_SECTION_LABEL
, 0);
25515 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
, 0);
25517 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
25518 vec_alloc (macinfo_table
, 64);
25520 switch_to_section (text_section
);
25521 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
25524 /* Make sure the line number table for .text always exists. */
25525 text_section_line_info
= new_line_info_table ();
25526 text_section_line_info
->end_label
= text_end_label
;
25528 #ifdef DWARF2_LINENO_DEBUGGING_INFO
25529 cur_line_info_table
= text_section_line_info
;
25532 /* If front-ends already registered a main translation unit but we were not
25533 ready to perform the association, do this now. */
25534 if (main_translation_unit
!= NULL_TREE
)
25535 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
25538 /* Called before compile () starts outputtting functions, variables
25539 and toplevel asms into assembly. */
25542 dwarf2out_assembly_start (void)
25544 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
25545 && dwarf2out_do_cfi_asm ()
25546 && (!(flag_unwind_tables
|| flag_exceptions
)
25547 || targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
))
25548 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
25551 /* A helper function for dwarf2out_finish called through
25552 htab_traverse. Assign a string its index. All strings must be
25553 collected into the table by the time index_string is called,
25554 because the indexing code relies on htab_traverse to traverse nodes
25555 in the same order for each run. */
25558 index_string (indirect_string_node
**h
, unsigned int *index
)
25560 indirect_string_node
*node
= *h
;
25562 find_string_form (node
);
25563 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
25565 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
25566 node
->index
= *index
;
25572 /* A helper function for output_indirect_strings called through
25573 htab_traverse. Output the offset to a string and update the
25577 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
25579 indirect_string_node
*node
= *h
;
25581 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
25583 /* Assert that this node has been assigned an index. */
25584 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
25585 && node
->index
!= NOT_INDEXED
);
25586 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
25587 "indexed string 0x%x: %s", node
->index
, node
->str
);
25588 *offset
+= strlen (node
->str
) + 1;
25593 /* A helper function for dwarf2out_finish called through
25594 htab_traverse. Output the indexed string. */
25597 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
25599 struct indirect_string_node
*node
= *h
;
25601 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
25603 /* Assert that the strings are output in the same order as their
25604 indexes were assigned. */
25605 gcc_assert (*cur_idx
== node
->index
);
25606 assemble_string (node
->str
, strlen (node
->str
) + 1);
25612 /* A helper function for dwarf2out_finish called through
25613 htab_traverse. Emit one queued .debug_str string. */
25616 output_indirect_string (indirect_string_node
**h
, void *)
25618 struct indirect_string_node
*node
= *h
;
25620 node
->form
= find_string_form (node
);
25621 if (node
->form
== DW_FORM_strp
&& node
->refcount
> 0)
25623 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
25624 assemble_string (node
->str
, strlen (node
->str
) + 1);
25630 /* Output the indexed string table. */
25633 output_indirect_strings (void)
25635 switch_to_section (debug_str_section
);
25636 if (!dwarf_split_debug_info
)
25637 debug_str_hash
->traverse
<void *, output_indirect_string
> (NULL
);
25640 unsigned int offset
= 0;
25641 unsigned int cur_idx
= 0;
25643 skeleton_debug_str_hash
->traverse
<void *, output_indirect_string
> (NULL
);
25645 switch_to_section (debug_str_offsets_section
);
25646 debug_str_hash
->traverse_noresize
25647 <unsigned int *, output_index_string_offset
> (&offset
);
25648 switch_to_section (debug_str_dwo_section
);
25649 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
25654 /* Callback for htab_traverse to assign an index to an entry in the
25655 table, and to write that entry to the .debug_addr section. */
25658 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
25660 addr_table_entry
*entry
= *slot
;
25662 if (entry
->refcount
== 0)
25664 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
25665 || entry
->index
== NOT_INDEXED
);
25669 gcc_assert (entry
->index
== *cur_index
);
25672 switch (entry
->kind
)
25675 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
25676 "0x%x", entry
->index
);
25678 case ate_kind_rtx_dtprel
:
25679 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
25680 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
25683 fputc ('\n', asm_out_file
);
25685 case ate_kind_label
:
25686 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
25687 "0x%x", entry
->index
);
25690 gcc_unreachable ();
25695 /* Produce the .debug_addr section. */
25698 output_addr_table (void)
25700 unsigned int index
= 0;
25701 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
25704 switch_to_section (debug_addr_section
);
25706 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
25709 #if ENABLE_ASSERT_CHECKING
25710 /* Verify that all marks are clear. */
25713 verify_marks_clear (dw_die_ref die
)
25717 gcc_assert (! die
->die_mark
);
25718 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
25720 #endif /* ENABLE_ASSERT_CHECKING */
25722 /* Clear the marks for a die and its children.
25723 Be cool if the mark isn't set. */
25726 prune_unmark_dies (dw_die_ref die
)
25732 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
25735 /* Given LOC that is referenced by a DIE we're marking as used, find all
25736 referenced DWARF procedures it references and mark them as used. */
25739 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
25741 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
25742 switch (loc
->dw_loc_opc
)
25744 case DW_OP_GNU_implicit_pointer
:
25745 case DW_OP_GNU_convert
:
25746 case DW_OP_GNU_reinterpret
:
25747 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
25748 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
25752 case DW_OP_call_ref
:
25753 case DW_OP_GNU_const_type
:
25754 case DW_OP_GNU_parameter_ref
:
25755 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
25756 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
25758 case DW_OP_GNU_regval_type
:
25759 case DW_OP_GNU_deref_type
:
25760 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
25761 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
25763 case DW_OP_GNU_entry_value
:
25764 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
25765 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
25772 /* Given DIE that we're marking as used, find any other dies
25773 it references as attributes and mark them as used. */
25776 prune_unused_types_walk_attribs (dw_die_ref die
)
25781 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
25783 switch (AT_class (a
))
25785 /* Make sure DWARF procedures referenced by location descriptions will
25787 case dw_val_class_loc
:
25788 prune_unused_types_walk_loc_descr (AT_loc (a
));
25790 case dw_val_class_loc_list
:
25791 for (dw_loc_list_ref list
= AT_loc_list (a
);
25793 list
= list
->dw_loc_next
)
25794 prune_unused_types_walk_loc_descr (list
->expr
);
25797 case dw_val_class_die_ref
:
25798 /* A reference to another DIE.
25799 Make sure that it will get emitted.
25800 If it was broken out into a comdat group, don't follow it. */
25801 if (! AT_ref (a
)->comdat_type_p
25802 || a
->dw_attr
== DW_AT_specification
)
25803 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
25806 case dw_val_class_str
:
25807 /* Set the string's refcount to 0 so that prune_unused_types_mark
25808 accounts properly for it. */
25809 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
25818 /* Mark the generic parameters and arguments children DIEs of DIE. */
25821 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
25825 if (die
== NULL
|| die
->die_child
== NULL
)
25827 c
= die
->die_child
;
25830 if (is_template_parameter (c
))
25831 prune_unused_types_mark (c
, 1);
25833 } while (c
&& c
!= die
->die_child
);
25836 /* Mark DIE as being used. If DOKIDS is true, then walk down
25837 to DIE's children. */
25840 prune_unused_types_mark (dw_die_ref die
, int dokids
)
25844 if (die
->die_mark
== 0)
25846 /* We haven't done this node yet. Mark it as used. */
25848 /* If this is the DIE of a generic type instantiation,
25849 mark the children DIEs that describe its generic parms and
25851 prune_unused_types_mark_generic_parms_dies (die
);
25853 /* We also have to mark its parents as used.
25854 (But we don't want to mark our parent's kids due to this,
25855 unless it is a class.) */
25856 if (die
->die_parent
)
25857 prune_unused_types_mark (die
->die_parent
,
25858 class_scope_p (die
->die_parent
));
25860 /* Mark any referenced nodes. */
25861 prune_unused_types_walk_attribs (die
);
25863 /* If this node is a specification,
25864 also mark the definition, if it exists. */
25865 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
25866 prune_unused_types_mark (die
->die_definition
, 1);
25869 if (dokids
&& die
->die_mark
!= 2)
25871 /* We need to walk the children, but haven't done so yet.
25872 Remember that we've walked the kids. */
25875 /* If this is an array type, we need to make sure our
25876 kids get marked, even if they're types. If we're
25877 breaking out types into comdat sections, do this
25878 for all type definitions. */
25879 if (die
->die_tag
== DW_TAG_array_type
25880 || (use_debug_types
25881 && is_type_die (die
) && ! is_declaration_die (die
)))
25882 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
25884 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
25888 /* For local classes, look if any static member functions were emitted
25889 and if so, mark them. */
25892 prune_unused_types_walk_local_classes (dw_die_ref die
)
25896 if (die
->die_mark
== 2)
25899 switch (die
->die_tag
)
25901 case DW_TAG_structure_type
:
25902 case DW_TAG_union_type
:
25903 case DW_TAG_class_type
:
25906 case DW_TAG_subprogram
:
25907 if (!get_AT_flag (die
, DW_AT_declaration
)
25908 || die
->die_definition
!= NULL
)
25909 prune_unused_types_mark (die
, 1);
25916 /* Mark children. */
25917 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
25920 /* Walk the tree DIE and mark types that we actually use. */
25923 prune_unused_types_walk (dw_die_ref die
)
25927 /* Don't do anything if this node is already marked and
25928 children have been marked as well. */
25929 if (die
->die_mark
== 2)
25932 switch (die
->die_tag
)
25934 case DW_TAG_structure_type
:
25935 case DW_TAG_union_type
:
25936 case DW_TAG_class_type
:
25937 if (die
->die_perennial_p
)
25940 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
25941 if (c
->die_tag
== DW_TAG_subprogram
)
25944 /* Finding used static member functions inside of classes
25945 is needed just for local classes, because for other classes
25946 static member function DIEs with DW_AT_specification
25947 are emitted outside of the DW_TAG_*_type. If we ever change
25948 it, we'd need to call this even for non-local classes. */
25950 prune_unused_types_walk_local_classes (die
);
25952 /* It's a type node --- don't mark it. */
25955 case DW_TAG_const_type
:
25956 case DW_TAG_packed_type
:
25957 case DW_TAG_pointer_type
:
25958 case DW_TAG_reference_type
:
25959 case DW_TAG_rvalue_reference_type
:
25960 case DW_TAG_volatile_type
:
25961 case DW_TAG_typedef
:
25962 case DW_TAG_array_type
:
25963 case DW_TAG_interface_type
:
25964 case DW_TAG_friend
:
25965 case DW_TAG_enumeration_type
:
25966 case DW_TAG_subroutine_type
:
25967 case DW_TAG_string_type
:
25968 case DW_TAG_set_type
:
25969 case DW_TAG_subrange_type
:
25970 case DW_TAG_ptr_to_member_type
:
25971 case DW_TAG_file_type
:
25972 /* Type nodes are useful only when other DIEs reference them --- don't
25976 case DW_TAG_dwarf_procedure
:
25977 /* Likewise for DWARF procedures. */
25979 if (die
->die_perennial_p
)
25985 /* Mark everything else. */
25989 if (die
->die_mark
== 0)
25993 /* Now, mark any dies referenced from here. */
25994 prune_unused_types_walk_attribs (die
);
25999 /* Mark children. */
26000 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
26003 /* Increment the string counts on strings referred to from DIE's
26007 prune_unused_types_update_strings (dw_die_ref die
)
26012 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
26013 if (AT_class (a
) == dw_val_class_str
)
26015 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
26017 /* Avoid unnecessarily putting strings that are used less than
26018 twice in the hash table. */
26020 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
26022 indirect_string_node
**slot
26023 = debug_str_hash
->find_slot_with_hash (s
->str
,
26024 htab_hash_string (s
->str
),
26026 gcc_assert (*slot
== NULL
);
26032 /* Remove from the tree DIE any dies that aren't marked. */
26035 prune_unused_types_prune (dw_die_ref die
)
26039 gcc_assert (die
->die_mark
);
26040 prune_unused_types_update_strings (die
);
26042 if (! die
->die_child
)
26045 c
= die
->die_child
;
26047 dw_die_ref prev
= c
;
26048 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
26049 if (c
== die
->die_child
)
26051 /* No marked children between 'prev' and the end of the list. */
26053 /* No marked children at all. */
26054 die
->die_child
= NULL
;
26057 prev
->die_sib
= c
->die_sib
;
26058 die
->die_child
= prev
;
26063 if (c
!= prev
->die_sib
)
26065 prune_unused_types_prune (c
);
26066 } while (c
!= die
->die_child
);
26069 /* Remove dies representing declarations that we never use. */
26072 prune_unused_types (void)
26075 limbo_die_node
*node
;
26076 comdat_type_node
*ctnode
;
26077 pubname_entry
*pub
;
26078 dw_die_ref base_type
;
26080 #if ENABLE_ASSERT_CHECKING
26081 /* All the marks should already be clear. */
26082 verify_marks_clear (comp_unit_die ());
26083 for (node
= limbo_die_list
; node
; node
= node
->next
)
26084 verify_marks_clear (node
->die
);
26085 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
26086 verify_marks_clear (ctnode
->root_die
);
26087 #endif /* ENABLE_ASSERT_CHECKING */
26089 /* Mark types that are used in global variables. */
26090 premark_types_used_by_global_vars ();
26092 /* Set the mark on nodes that are actually used. */
26093 prune_unused_types_walk (comp_unit_die ());
26094 for (node
= limbo_die_list
; node
; node
= node
->next
)
26095 prune_unused_types_walk (node
->die
);
26096 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
26098 prune_unused_types_walk (ctnode
->root_die
);
26099 prune_unused_types_mark (ctnode
->type_die
, 1);
26102 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
26103 are unusual in that they are pubnames that are the children of pubtypes.
26104 They should only be marked via their parent DW_TAG_enumeration_type die,
26105 not as roots in themselves. */
26106 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
26107 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
26108 prune_unused_types_mark (pub
->die
, 1);
26109 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
26110 prune_unused_types_mark (base_type
, 1);
26112 if (debug_str_hash
)
26113 debug_str_hash
->empty ();
26114 if (skeleton_debug_str_hash
)
26115 skeleton_debug_str_hash
->empty ();
26116 prune_unused_types_prune (comp_unit_die ());
26117 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
26120 if (!node
->die
->die_mark
)
26121 *pnode
= node
->next
;
26124 prune_unused_types_prune (node
->die
);
26125 pnode
= &node
->next
;
26128 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
26129 prune_unused_types_prune (ctnode
->root_die
);
26131 /* Leave the marks clear. */
26132 prune_unmark_dies (comp_unit_die ());
26133 for (node
= limbo_die_list
; node
; node
= node
->next
)
26134 prune_unmark_dies (node
->die
);
26135 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
26136 prune_unmark_dies (ctnode
->root_die
);
26139 /* Set the parameter to true if there are any relative pathnames in
26142 file_table_relative_p (dwarf_file_data
**slot
, bool *p
)
26144 struct dwarf_file_data
*d
= *slot
;
26145 if (!IS_ABSOLUTE_PATH (d
->filename
))
26153 /* Helpers to manipulate hash table of comdat type units. */
26155 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
26157 static inline hashval_t
hash (const comdat_type_node
*);
26158 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
26162 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
26165 memcpy (&h
, type_node
->signature
, sizeof (h
));
26170 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
26171 const comdat_type_node
*type_node_2
)
26173 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
26174 DWARF_TYPE_SIGNATURE_SIZE
));
26177 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
26178 to the location it would have been added, should we know its
26179 DECL_ASSEMBLER_NAME when we added other attributes. This will
26180 probably improve compactness of debug info, removing equivalent
26181 abbrevs, and hide any differences caused by deferring the
26182 computation of the assembler name, triggered by e.g. PCH. */
26185 move_linkage_attr (dw_die_ref die
)
26187 unsigned ix
= vec_safe_length (die
->die_attr
);
26188 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
26190 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
26191 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
26195 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
26197 if (prev
->dw_attr
== DW_AT_decl_line
|| prev
->dw_attr
== DW_AT_name
)
26201 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
26203 die
->die_attr
->pop ();
26204 die
->die_attr
->quick_insert (ix
, linkage
);
26208 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
26209 referenced from typed stack ops and count how often they are used. */
26212 mark_base_types (dw_loc_descr_ref loc
)
26214 dw_die_ref base_type
= NULL
;
26216 for (; loc
; loc
= loc
->dw_loc_next
)
26218 switch (loc
->dw_loc_opc
)
26220 case DW_OP_GNU_regval_type
:
26221 case DW_OP_GNU_deref_type
:
26222 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
26224 case DW_OP_GNU_convert
:
26225 case DW_OP_GNU_reinterpret
:
26226 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
26229 case DW_OP_GNU_const_type
:
26230 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
26232 case DW_OP_GNU_entry_value
:
26233 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
26238 gcc_assert (base_type
->die_parent
== comp_unit_die ());
26239 if (base_type
->die_mark
)
26240 base_type
->die_mark
++;
26243 base_types
.safe_push (base_type
);
26244 base_type
->die_mark
= 1;
26249 /* Comparison function for sorting marked base types. */
26252 base_type_cmp (const void *x
, const void *y
)
26254 dw_die_ref dx
= *(const dw_die_ref
*) x
;
26255 dw_die_ref dy
= *(const dw_die_ref
*) y
;
26256 unsigned int byte_size1
, byte_size2
;
26257 unsigned int encoding1
, encoding2
;
26258 if (dx
->die_mark
> dy
->die_mark
)
26260 if (dx
->die_mark
< dy
->die_mark
)
26262 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
26263 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
26264 if (byte_size1
< byte_size2
)
26266 if (byte_size1
> byte_size2
)
26268 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
26269 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
26270 if (encoding1
< encoding2
)
26272 if (encoding1
> encoding2
)
26277 /* Move base types marked by mark_base_types as early as possible
26278 in the CU, sorted by decreasing usage count both to make the
26279 uleb128 references as small as possible and to make sure they
26280 will have die_offset already computed by calc_die_sizes when
26281 sizes of typed stack loc ops is computed. */
26284 move_marked_base_types (void)
26287 dw_die_ref base_type
, die
, c
;
26289 if (base_types
.is_empty ())
26292 /* Sort by decreasing usage count, they will be added again in that
26294 base_types
.qsort (base_type_cmp
);
26295 die
= comp_unit_die ();
26296 c
= die
->die_child
;
26299 dw_die_ref prev
= c
;
26301 while (c
->die_mark
)
26303 remove_child_with_prev (c
, prev
);
26304 /* As base types got marked, there must be at least
26305 one node other than DW_TAG_base_type. */
26306 gcc_assert (c
!= c
->die_sib
);
26310 while (c
!= die
->die_child
);
26311 gcc_assert (die
->die_child
);
26312 c
= die
->die_child
;
26313 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
26315 base_type
->die_mark
= 0;
26316 base_type
->die_sib
= c
->die_sib
;
26317 c
->die_sib
= base_type
;
26322 /* Helper function for resolve_addr, attempt to resolve
26323 one CONST_STRING, return true if successful. Similarly verify that
26324 SYMBOL_REFs refer to variables emitted in the current CU. */
26327 resolve_one_addr (rtx
*addr
)
26331 if (GET_CODE (rtl
) == CONST_STRING
)
26333 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
26334 tree t
= build_string (len
, XSTR (rtl
, 0));
26335 tree tlen
= size_int (len
- 1);
26337 = build_array_type (char_type_node
, build_index_type (tlen
));
26338 rtl
= lookup_constant_def (t
);
26339 if (!rtl
|| !MEM_P (rtl
))
26341 rtl
= XEXP (rtl
, 0);
26342 if (GET_CODE (rtl
) == SYMBOL_REF
26343 && SYMBOL_REF_DECL (rtl
)
26344 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
26346 vec_safe_push (used_rtx_array
, rtl
);
26351 if (GET_CODE (rtl
) == SYMBOL_REF
26352 && SYMBOL_REF_DECL (rtl
))
26354 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
26356 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
26359 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
26363 if (GET_CODE (rtl
) == CONST
)
26365 subrtx_ptr_iterator::array_type array
;
26366 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
26367 if (!resolve_one_addr (*iter
))
26374 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
26375 if possible, and create DW_TAG_dwarf_procedure that can be referenced
26376 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
26379 string_cst_pool_decl (tree t
)
26381 rtx rtl
= output_constant_def (t
, 1);
26382 unsigned char *array
;
26383 dw_loc_descr_ref l
;
26388 if (!rtl
|| !MEM_P (rtl
))
26390 rtl
= XEXP (rtl
, 0);
26391 if (GET_CODE (rtl
) != SYMBOL_REF
26392 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
26395 decl
= SYMBOL_REF_DECL (rtl
);
26396 if (!lookup_decl_die (decl
))
26398 len
= TREE_STRING_LENGTH (t
);
26399 vec_safe_push (used_rtx_array
, rtl
);
26400 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
26401 array
= ggc_vec_alloc
<unsigned char> (len
);
26402 memcpy (array
, TREE_STRING_POINTER (t
), len
);
26403 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
26404 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
26405 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
26406 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
26407 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
26408 add_AT_loc (ref
, DW_AT_location
, l
);
26409 equate_decl_number_to_die (decl
, ref
);
26414 /* Helper function of resolve_addr_in_expr. LOC is
26415 a DW_OP_addr followed by DW_OP_stack_value, either at the start
26416 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
26417 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
26418 with DW_OP_GNU_implicit_pointer if possible
26419 and return true, if unsuccessful, return false. */
26422 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
26424 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
26425 HOST_WIDE_INT offset
= 0;
26426 dw_die_ref ref
= NULL
;
26429 if (GET_CODE (rtl
) == CONST
26430 && GET_CODE (XEXP (rtl
, 0)) == PLUS
26431 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
26433 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
26434 rtl
= XEXP (XEXP (rtl
, 0), 0);
26436 if (GET_CODE (rtl
) == CONST_STRING
)
26438 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
26439 tree t
= build_string (len
, XSTR (rtl
, 0));
26440 tree tlen
= size_int (len
- 1);
26443 = build_array_type (char_type_node
, build_index_type (tlen
));
26444 rtl
= string_cst_pool_decl (t
);
26448 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
26450 decl
= SYMBOL_REF_DECL (rtl
);
26451 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
26453 ref
= lookup_decl_die (decl
);
26454 if (ref
&& (get_AT (ref
, DW_AT_location
)
26455 || get_AT (ref
, DW_AT_const_value
)))
26457 loc
->dw_loc_opc
= DW_OP_GNU_implicit_pointer
;
26458 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
26459 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
26460 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
26461 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
26462 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
26463 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
26471 /* Helper function for resolve_addr, handle one location
26472 expression, return false if at least one CONST_STRING or SYMBOL_REF in
26473 the location list couldn't be resolved. */
26476 resolve_addr_in_expr (dw_loc_descr_ref loc
)
26478 dw_loc_descr_ref keep
= NULL
;
26479 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
26480 switch (loc
->dw_loc_opc
)
26483 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
26486 || prev
->dw_loc_opc
== DW_OP_piece
26487 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
26488 && loc
->dw_loc_next
26489 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
26491 && optimize_one_addr_into_implicit_ptr (loc
))
26496 case DW_OP_GNU_addr_index
:
26497 case DW_OP_GNU_const_index
:
26498 if (loc
->dw_loc_opc
== DW_OP_GNU_addr_index
26499 || (loc
->dw_loc_opc
== DW_OP_GNU_const_index
&& loc
->dtprel
))
26501 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
26502 if (!resolve_one_addr (&rtl
))
26504 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
26505 loc
->dw_loc_oprnd1
.val_entry
=
26506 add_addr_table_entry (rtl
, ate_kind_rtx
);
26509 case DW_OP_const4u
:
26510 case DW_OP_const8u
:
26512 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
26515 case DW_OP_plus_uconst
:
26516 if (size_of_loc_descr (loc
)
26517 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
26519 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
26521 dw_loc_descr_ref repl
26522 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
26523 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
26524 add_loc_descr (&repl
, loc
->dw_loc_next
);
26528 case DW_OP_implicit_value
:
26529 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
26530 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
26533 case DW_OP_GNU_implicit_pointer
:
26534 case DW_OP_GNU_parameter_ref
:
26535 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
26538 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
26541 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
26542 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
26543 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
26546 case DW_OP_GNU_const_type
:
26547 case DW_OP_GNU_regval_type
:
26548 case DW_OP_GNU_deref_type
:
26549 case DW_OP_GNU_convert
:
26550 case DW_OP_GNU_reinterpret
:
26551 while (loc
->dw_loc_next
26552 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
)
26554 dw_die_ref base1
, base2
;
26555 unsigned enc1
, enc2
, size1
, size2
;
26556 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
26557 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
26558 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
26559 else if (loc
->dw_loc_oprnd1
.val_class
26560 == dw_val_class_unsigned_const
)
26563 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
26564 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
26565 == dw_val_class_unsigned_const
)
26567 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
26568 gcc_assert (base1
->die_tag
== DW_TAG_base_type
26569 && base2
->die_tag
== DW_TAG_base_type
);
26570 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
26571 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
26572 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
26573 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
26575 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
26576 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
26580 /* Optimize away next DW_OP_GNU_convert after
26581 adjusting LOC's base type die reference. */
26582 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
26583 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
26584 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
26586 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
26587 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
26590 /* Don't change integer DW_OP_GNU_convert after e.g. floating
26591 point typed stack entry. */
26592 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
26593 keep
= loc
->dw_loc_next
;
26603 /* Helper function of resolve_addr. DIE had DW_AT_location of
26604 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
26605 and DW_OP_addr couldn't be resolved. resolve_addr has already
26606 removed the DW_AT_location attribute. This function attempts to
26607 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
26608 to it or DW_AT_const_value attribute, if possible. */
26611 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
26613 if (TREE_CODE (decl
) != VAR_DECL
26614 || lookup_decl_die (decl
) != die
26615 || DECL_EXTERNAL (decl
)
26616 || !TREE_STATIC (decl
)
26617 || DECL_INITIAL (decl
) == NULL_TREE
26618 || DECL_P (DECL_INITIAL (decl
))
26619 || get_AT (die
, DW_AT_const_value
))
26622 tree init
= DECL_INITIAL (decl
);
26623 HOST_WIDE_INT offset
= 0;
26624 /* For variables that have been optimized away and thus
26625 don't have a memory location, see if we can emit
26626 DW_AT_const_value instead. */
26627 if (tree_add_const_value_attribute (die
, init
))
26631 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
26632 and ADDR_EXPR refers to a decl that has DW_AT_location or
26633 DW_AT_const_value (but isn't addressable, otherwise
26634 resolving the original DW_OP_addr wouldn't fail), see if
26635 we can add DW_OP_GNU_implicit_pointer. */
26637 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
26638 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
26640 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
26641 init
= TREE_OPERAND (init
, 0);
26644 if (TREE_CODE (init
) != ADDR_EXPR
)
26646 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
26647 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
26648 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
26649 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
26650 && TREE_OPERAND (init
, 0) != decl
))
26653 dw_loc_descr_ref l
;
26655 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
26657 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
26660 decl
= SYMBOL_REF_DECL (rtl
);
26663 decl
= TREE_OPERAND (init
, 0);
26664 ref
= lookup_decl_die (decl
);
26666 || (!get_AT (ref
, DW_AT_location
)
26667 && !get_AT (ref
, DW_AT_const_value
)))
26669 l
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
26670 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
26671 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
26672 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
26673 add_AT_loc (die
, DW_AT_location
, l
);
26677 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
26678 an address in .rodata section if the string literal is emitted there,
26679 or remove the containing location list or replace DW_AT_const_value
26680 with DW_AT_location and empty location expression, if it isn't found
26681 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
26682 to something that has been emitted in the current CU. */
26685 resolve_addr (dw_die_ref die
)
26689 dw_loc_list_ref
*curr
, *start
, loc
;
26692 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
26693 switch (AT_class (a
))
26695 case dw_val_class_loc_list
:
26696 start
= curr
= AT_loc_list_ptr (a
);
26699 /* The same list can be referenced more than once. See if we have
26700 already recorded the result from a previous pass. */
26702 *curr
= loc
->dw_loc_next
;
26703 else if (!loc
->resolved_addr
)
26705 /* As things stand, we do not expect or allow one die to
26706 reference a suffix of another die's location list chain.
26707 References must be identical or completely separate.
26708 There is therefore no need to cache the result of this
26709 pass on any list other than the first; doing so
26710 would lead to unnecessary writes. */
26713 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
26714 if (!resolve_addr_in_expr ((*curr
)->expr
))
26716 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
26717 dw_loc_descr_ref l
= (*curr
)->expr
;
26719 if (next
&& (*curr
)->ll_symbol
)
26721 gcc_assert (!next
->ll_symbol
);
26722 next
->ll_symbol
= (*curr
)->ll_symbol
;
26724 if (dwarf_split_debug_info
)
26725 remove_loc_list_addr_table_entries (l
);
26730 mark_base_types ((*curr
)->expr
);
26731 curr
= &(*curr
)->dw_loc_next
;
26735 loc
->resolved_addr
= 1;
26739 loc
->dw_loc_next
= *start
;
26744 remove_AT (die
, a
->dw_attr
);
26748 case dw_val_class_loc
:
26750 dw_loc_descr_ref l
= AT_loc (a
);
26751 /* For -gdwarf-2 don't attempt to optimize
26752 DW_AT_data_member_location containing
26753 DW_OP_plus_uconst - older consumers might
26754 rely on it being that op instead of a more complex,
26755 but shorter, location description. */
26756 if ((dwarf_version
> 2
26757 || a
->dw_attr
!= DW_AT_data_member_location
26759 || l
->dw_loc_opc
!= DW_OP_plus_uconst
26760 || l
->dw_loc_next
!= NULL
)
26761 && !resolve_addr_in_expr (l
))
26763 if (dwarf_split_debug_info
)
26764 remove_loc_list_addr_table_entries (l
);
26766 && l
->dw_loc_next
== NULL
26767 && l
->dw_loc_opc
== DW_OP_addr
26768 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
26769 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
26770 && a
->dw_attr
== DW_AT_location
)
26772 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
26773 remove_AT (die
, a
->dw_attr
);
26775 optimize_location_into_implicit_ptr (die
, decl
);
26778 remove_AT (die
, a
->dw_attr
);
26782 mark_base_types (l
);
26785 case dw_val_class_addr
:
26786 if (a
->dw_attr
== DW_AT_const_value
26787 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
26789 if (AT_index (a
) != NOT_INDEXED
)
26790 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
26791 remove_AT (die
, a
->dw_attr
);
26794 if (die
->die_tag
== DW_TAG_GNU_call_site
26795 && a
->dw_attr
== DW_AT_abstract_origin
)
26797 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
26798 dw_die_ref tdie
= lookup_decl_die (tdecl
);
26801 && DECL_EXTERNAL (tdecl
)
26802 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
26803 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
26805 /* Creating a full DIE for tdecl is overly expensive and
26806 at this point even wrong when in the LTO phase
26807 as it can end up generating new type DIEs we didn't
26808 output and thus optimize_external_refs will crash. */
26809 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
26810 add_AT_flag (tdie
, DW_AT_external
, 1);
26811 add_AT_flag (tdie
, DW_AT_declaration
, 1);
26812 add_linkage_attr (tdie
, tdecl
);
26813 add_name_and_src_coords_attributes (tdie
, tdecl
);
26814 equate_decl_number_to_die (tdecl
, tdie
);
26818 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
26819 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
26820 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
26824 if (AT_index (a
) != NOT_INDEXED
)
26825 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
26826 remove_AT (die
, a
->dw_attr
);
26835 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
26838 /* Helper routines for optimize_location_lists.
26839 This pass tries to share identical local lists in .debug_loc
26842 /* Iteratively hash operands of LOC opcode into HSTATE. */
26845 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
26847 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
26848 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
26850 switch (loc
->dw_loc_opc
)
26852 case DW_OP_const4u
:
26853 case DW_OP_const8u
:
26857 case DW_OP_const1u
:
26858 case DW_OP_const1s
:
26859 case DW_OP_const2u
:
26860 case DW_OP_const2s
:
26861 case DW_OP_const4s
:
26862 case DW_OP_const8s
:
26866 case DW_OP_plus_uconst
:
26902 case DW_OP_deref_size
:
26903 case DW_OP_xderef_size
:
26904 hstate
.add_object (val1
->v
.val_int
);
26911 gcc_assert (val1
->val_class
== dw_val_class_loc
);
26912 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
26913 hstate
.add_object (offset
);
26916 case DW_OP_implicit_value
:
26917 hstate
.add_object (val1
->v
.val_unsigned
);
26918 switch (val2
->val_class
)
26920 case dw_val_class_const
:
26921 hstate
.add_object (val2
->v
.val_int
);
26923 case dw_val_class_vec
:
26925 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
26926 unsigned int len
= val2
->v
.val_vec
.length
;
26928 hstate
.add_int (elt_size
);
26929 hstate
.add_int (len
);
26930 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
26933 case dw_val_class_const_double
:
26934 hstate
.add_object (val2
->v
.val_double
.low
);
26935 hstate
.add_object (val2
->v
.val_double
.high
);
26937 case dw_val_class_wide_int
:
26938 hstate
.add (val2
->v
.val_wide
->get_val (),
26939 get_full_len (*val2
->v
.val_wide
)
26940 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
26942 case dw_val_class_addr
:
26943 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
26946 gcc_unreachable ();
26950 case DW_OP_bit_piece
:
26951 hstate
.add_object (val1
->v
.val_int
);
26952 hstate
.add_object (val2
->v
.val_int
);
26958 unsigned char dtprel
= 0xd1;
26959 hstate
.add_object (dtprel
);
26961 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
26963 case DW_OP_GNU_addr_index
:
26964 case DW_OP_GNU_const_index
:
26968 unsigned char dtprel
= 0xd1;
26969 hstate
.add_object (dtprel
);
26971 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
26974 case DW_OP_GNU_implicit_pointer
:
26975 hstate
.add_int (val2
->v
.val_int
);
26977 case DW_OP_GNU_entry_value
:
26978 hstate
.add_object (val1
->v
.val_loc
);
26980 case DW_OP_GNU_regval_type
:
26981 case DW_OP_GNU_deref_type
:
26983 unsigned int byte_size
26984 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
26985 unsigned int encoding
26986 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
26987 hstate
.add_object (val1
->v
.val_int
);
26988 hstate
.add_object (byte_size
);
26989 hstate
.add_object (encoding
);
26992 case DW_OP_GNU_convert
:
26993 case DW_OP_GNU_reinterpret
:
26994 if (val1
->val_class
== dw_val_class_unsigned_const
)
26996 hstate
.add_object (val1
->v
.val_unsigned
);
27000 case DW_OP_GNU_const_type
:
27002 unsigned int byte_size
27003 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
27004 unsigned int encoding
27005 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
27006 hstate
.add_object (byte_size
);
27007 hstate
.add_object (encoding
);
27008 if (loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
27010 hstate
.add_object (val2
->val_class
);
27011 switch (val2
->val_class
)
27013 case dw_val_class_const
:
27014 hstate
.add_object (val2
->v
.val_int
);
27016 case dw_val_class_vec
:
27018 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
27019 unsigned int len
= val2
->v
.val_vec
.length
;
27021 hstate
.add_object (elt_size
);
27022 hstate
.add_object (len
);
27023 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
27026 case dw_val_class_const_double
:
27027 hstate
.add_object (val2
->v
.val_double
.low
);
27028 hstate
.add_object (val2
->v
.val_double
.high
);
27030 case dw_val_class_wide_int
:
27031 hstate
.add (val2
->v
.val_wide
->get_val (),
27032 get_full_len (*val2
->v
.val_wide
)
27033 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
27036 gcc_unreachable ();
27042 /* Other codes have no operands. */
27047 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
27050 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
27052 dw_loc_descr_ref l
;
27053 bool sizes_computed
= false;
27054 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
27055 size_of_locs (loc
);
27057 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
27059 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
27060 hstate
.add_object (opc
);
27061 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
27063 size_of_locs (loc
);
27064 sizes_computed
= true;
27066 hash_loc_operands (l
, hstate
);
27070 /* Compute hash of the whole location list LIST_HEAD. */
27073 hash_loc_list (dw_loc_list_ref list_head
)
27075 dw_loc_list_ref curr
= list_head
;
27076 inchash::hash hstate
;
27078 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
27080 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
27081 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
27083 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
27084 hash_locs (curr
->expr
, hstate
);
27086 list_head
->hash
= hstate
.end ();
27089 /* Return true if X and Y opcodes have the same operands. */
27092 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
27094 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
27095 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
27096 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
27097 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
27099 switch (x
->dw_loc_opc
)
27101 case DW_OP_const4u
:
27102 case DW_OP_const8u
:
27106 case DW_OP_const1u
:
27107 case DW_OP_const1s
:
27108 case DW_OP_const2u
:
27109 case DW_OP_const2s
:
27110 case DW_OP_const4s
:
27111 case DW_OP_const8s
:
27115 case DW_OP_plus_uconst
:
27151 case DW_OP_deref_size
:
27152 case DW_OP_xderef_size
:
27153 return valx1
->v
.val_int
== valy1
->v
.val_int
;
27156 /* If splitting debug info, the use of DW_OP_GNU_addr_index
27157 can cause irrelevant differences in dw_loc_addr. */
27158 gcc_assert (valx1
->val_class
== dw_val_class_loc
27159 && valy1
->val_class
== dw_val_class_loc
27160 && (dwarf_split_debug_info
27161 || x
->dw_loc_addr
== y
->dw_loc_addr
));
27162 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
27163 case DW_OP_implicit_value
:
27164 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
27165 || valx2
->val_class
!= valy2
->val_class
)
27167 switch (valx2
->val_class
)
27169 case dw_val_class_const
:
27170 return valx2
->v
.val_int
== valy2
->v
.val_int
;
27171 case dw_val_class_vec
:
27172 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
27173 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
27174 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
27175 valx2
->v
.val_vec
.elt_size
27176 * valx2
->v
.val_vec
.length
) == 0;
27177 case dw_val_class_const_double
:
27178 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
27179 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
27180 case dw_val_class_wide_int
:
27181 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
27182 case dw_val_class_addr
:
27183 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
27185 gcc_unreachable ();
27188 case DW_OP_bit_piece
:
27189 return valx1
->v
.val_int
== valy1
->v
.val_int
27190 && valx2
->v
.val_int
== valy2
->v
.val_int
;
27193 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
27194 case DW_OP_GNU_addr_index
:
27195 case DW_OP_GNU_const_index
:
27197 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
27198 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
27199 return rtx_equal_p (ax1
, ay1
);
27201 case DW_OP_GNU_implicit_pointer
:
27202 return valx1
->val_class
== dw_val_class_die_ref
27203 && valx1
->val_class
== valy1
->val_class
27204 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
27205 && valx2
->v
.val_int
== valy2
->v
.val_int
;
27206 case DW_OP_GNU_entry_value
:
27207 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
27208 case DW_OP_GNU_const_type
:
27209 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
27210 || valx2
->val_class
!= valy2
->val_class
)
27212 switch (valx2
->val_class
)
27214 case dw_val_class_const
:
27215 return valx2
->v
.val_int
== valy2
->v
.val_int
;
27216 case dw_val_class_vec
:
27217 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
27218 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
27219 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
27220 valx2
->v
.val_vec
.elt_size
27221 * valx2
->v
.val_vec
.length
) == 0;
27222 case dw_val_class_const_double
:
27223 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
27224 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
27225 case dw_val_class_wide_int
:
27226 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
27228 gcc_unreachable ();
27230 case DW_OP_GNU_regval_type
:
27231 case DW_OP_GNU_deref_type
:
27232 return valx1
->v
.val_int
== valy1
->v
.val_int
27233 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
27234 case DW_OP_GNU_convert
:
27235 case DW_OP_GNU_reinterpret
:
27236 if (valx1
->val_class
!= valy1
->val_class
)
27238 if (valx1
->val_class
== dw_val_class_unsigned_const
)
27239 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
27240 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
27241 case DW_OP_GNU_parameter_ref
:
27242 return valx1
->val_class
== dw_val_class_die_ref
27243 && valx1
->val_class
== valy1
->val_class
27244 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
27246 /* Other codes have no operands. */
27251 /* Return true if DWARF location expressions X and Y are the same. */
27254 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
27256 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
27257 if (x
->dw_loc_opc
!= y
->dw_loc_opc
27258 || x
->dtprel
!= y
->dtprel
27259 || !compare_loc_operands (x
, y
))
27261 return x
== NULL
&& y
== NULL
;
27264 /* Hashtable helpers. */
27266 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
27268 static inline hashval_t
hash (const dw_loc_list_struct
*);
27269 static inline bool equal (const dw_loc_list_struct
*,
27270 const dw_loc_list_struct
*);
27273 /* Return precomputed hash of location list X. */
27276 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
27281 /* Return true if location lists A and B are the same. */
27284 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
27285 const dw_loc_list_struct
*b
)
27289 if (a
->hash
!= b
->hash
)
27291 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
27292 if (strcmp (a
->begin
, b
->begin
) != 0
27293 || strcmp (a
->end
, b
->end
) != 0
27294 || (a
->section
== NULL
) != (b
->section
== NULL
)
27295 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
27296 || !compare_locs (a
->expr
, b
->expr
))
27298 return a
== NULL
&& b
== NULL
;
27301 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
27304 /* Recursively optimize location lists referenced from DIE
27305 children and share them whenever possible. */
27308 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
27313 dw_loc_list_struct
**slot
;
27315 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
27316 if (AT_class (a
) == dw_val_class_loc_list
)
27318 dw_loc_list_ref list
= AT_loc_list (a
);
27319 /* TODO: perform some optimizations here, before hashing
27320 it and storing into the hash table. */
27321 hash_loc_list (list
);
27322 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
27326 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
27329 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
27333 /* Recursively assign each location list a unique index into the debug_addr
27337 index_location_lists (dw_die_ref die
)
27343 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
27344 if (AT_class (a
) == dw_val_class_loc_list
)
27346 dw_loc_list_ref list
= AT_loc_list (a
);
27347 dw_loc_list_ref curr
;
27348 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
27350 /* Don't index an entry that has already been indexed
27351 or won't be output. */
27352 if (curr
->begin_entry
!= NULL
27353 || (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
))
27357 = add_addr_table_entry (xstrdup (curr
->begin
),
27362 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
27365 /* Optimize location lists referenced from DIE
27366 children and share them whenever possible. */
27369 optimize_location_lists (dw_die_ref die
)
27371 loc_list_hash_type
htab (500);
27372 optimize_location_lists_1 (die
, &htab
);
27375 /* Traverse the limbo die list, and add parent/child links. The only
27376 dies without parents that should be here are concrete instances of
27377 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
27378 For concrete instances, we can get the parent die from the abstract
27382 flush_limbo_die_list (void)
27384 limbo_die_node
*node
;
27386 /* get_context_die calls force_decl_die, which can put new DIEs on the
27387 limbo list in LTO mode when nested functions are put in a different
27388 partition than that of their parent function. */
27389 while ((node
= limbo_die_list
))
27391 dw_die_ref die
= node
->die
;
27392 limbo_die_list
= node
->next
;
27394 if (die
->die_parent
== NULL
)
27396 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
27398 if (origin
&& origin
->die_parent
)
27399 add_child_die (origin
->die_parent
, die
);
27400 else if (is_cu_die (die
))
27402 else if (seen_error ())
27403 /* It's OK to be confused by errors in the input. */
27404 add_child_die (comp_unit_die (), die
);
27407 /* In certain situations, the lexical block containing a
27408 nested function can be optimized away, which results
27409 in the nested function die being orphaned. Likewise
27410 with the return type of that nested function. Force
27411 this to be a child of the containing function.
27413 It may happen that even the containing function got fully
27414 inlined and optimized out. In that case we are lost and
27415 assign the empty child. This should not be big issue as
27416 the function is likely unreachable too. */
27417 gcc_assert (node
->created_for
);
27419 if (DECL_P (node
->created_for
))
27420 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
27421 else if (TYPE_P (node
->created_for
))
27422 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
27424 origin
= comp_unit_die ();
27426 add_child_die (origin
, die
);
27432 /* Output stuff that dwarf requires at the end of every file,
27433 and generate the DWARF-2 debugging info. */
27436 dwarf2out_finish (const char *filename
)
27438 comdat_type_node
*ctnode
;
27439 dw_die_ref main_comp_unit_die
;
27441 /* Flush out any latecomers to the limbo party. */
27442 flush_limbo_die_list ();
27444 /* We shouldn't have any symbols with delayed asm names for
27445 DIEs generated after early finish. */
27446 gcc_assert (deferred_asm_name
== NULL
);
27448 /* PCH might result in DW_AT_producer string being restored from the
27449 header compilation, so always fill it with empty string initially
27450 and overwrite only here. */
27451 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
27452 producer_string
= gen_producer_string ();
27453 producer
->dw_attr_val
.v
.val_str
->refcount
--;
27454 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
27456 gen_remaining_tmpl_value_param_die_attribute ();
27458 /* Add the name for the main input file now. We delayed this from
27459 dwarf2out_init to avoid complications with PCH.
27460 For LTO produced units use a fixed artificial name to avoid
27461 leaking tempfile names into the dwarf. */
27463 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
27465 add_name_attribute (comp_unit_die (), "<artificial>");
27466 if (!IS_ABSOLUTE_PATH (filename
) || targetm
.force_at_comp_dir
)
27467 add_comp_dir_attribute (comp_unit_die ());
27468 else if (get_AT (comp_unit_die (), DW_AT_comp_dir
) == NULL
)
27471 file_table
->traverse
<bool *, file_table_relative_p
> (&p
);
27473 add_comp_dir_attribute (comp_unit_die ());
27476 #if ENABLE_ASSERT_CHECKING
27478 dw_die_ref die
= comp_unit_die (), c
;
27479 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
27482 resolve_addr (comp_unit_die ());
27483 move_marked_base_types ();
27485 if (flag_eliminate_unused_debug_types
)
27486 prune_unused_types ();
27488 /* Generate separate COMDAT sections for type DIEs. */
27489 if (use_debug_types
)
27491 break_out_comdat_types (comp_unit_die ());
27493 /* Each new type_unit DIE was added to the limbo die list when created.
27494 Since these have all been added to comdat_type_list, clear the
27496 limbo_die_list
= NULL
;
27498 /* For each new comdat type unit, copy declarations for incomplete
27499 types to make the new unit self-contained (i.e., no direct
27500 references to the main compile unit). */
27501 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
27502 copy_decls_for_unworthy_types (ctnode
->root_die
);
27503 copy_decls_for_unworthy_types (comp_unit_die ());
27505 /* In the process of copying declarations from one unit to another,
27506 we may have left some declarations behind that are no longer
27507 referenced. Prune them. */
27508 prune_unused_types ();
27511 /* Generate separate CUs for each of the include files we've seen.
27512 They will go into limbo_die_list. */
27513 if (flag_eliminate_dwarf2_dups
)
27514 break_out_includes (comp_unit_die ());
27516 /* Traverse the DIE's and add sibling attributes to those DIE's that
27518 add_sibling_attributes (comp_unit_die ());
27519 limbo_die_node
*node
;
27520 for (node
= limbo_die_list
; node
; node
= node
->next
)
27521 add_sibling_attributes (node
->die
);
27522 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
27523 add_sibling_attributes (ctnode
->root_die
);
27525 /* When splitting DWARF info, we put some attributes in the
27526 skeleton compile_unit DIE that remains in the .o, while
27527 most attributes go in the DWO compile_unit_die. */
27528 if (dwarf_split_debug_info
)
27529 main_comp_unit_die
= gen_compile_unit_die (NULL
);
27531 main_comp_unit_die
= comp_unit_die ();
27533 /* Output a terminator label for the .text section. */
27534 switch_to_section (text_section
);
27535 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
27536 if (cold_text_section
)
27538 switch_to_section (cold_text_section
);
27539 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
27542 /* We can only use the low/high_pc attributes if all of the code was
27544 if (!have_multiple_function_sections
27545 || (dwarf_version
< 3 && dwarf_strict
))
27547 /* Don't add if the CU has no associated code. */
27548 if (text_section_used
)
27549 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
27550 text_end_label
, true);
27556 bool range_list_added
= false;
27558 if (text_section_used
)
27559 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
27560 text_end_label
, &range_list_added
, true);
27561 if (cold_text_section_used
)
27562 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
27563 cold_end_label
, &range_list_added
, true);
27565 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
27567 if (DECL_IGNORED_P (fde
->decl
))
27569 if (!fde
->in_std_section
)
27570 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
27571 fde
->dw_fde_end
, &range_list_added
,
27573 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
27574 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
27575 fde
->dw_fde_second_end
, &range_list_added
,
27579 if (range_list_added
)
27581 /* We need to give .debug_loc and .debug_ranges an appropriate
27582 "base address". Use zero so that these addresses become
27583 absolute. Historically, we've emitted the unexpected
27584 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
27585 Emit both to give time for other tools to adapt. */
27586 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
27587 if (! dwarf_strict
&& dwarf_version
< 4)
27588 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
27594 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
27595 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
27596 debug_line_section_label
);
27599 add_AT_macptr (comp_unit_die (),
27600 dwarf_strict
? DW_AT_macro_info
: DW_AT_GNU_macros
,
27601 macinfo_section_label
);
27603 if (dwarf_split_debug_info
)
27605 /* optimize_location_lists calculates the size of the lists,
27606 so index them first, and assign indices to the entries.
27607 Although optimize_location_lists will remove entries from
27608 the table, it only does so for duplicates, and therefore
27609 only reduces ref_counts to 1. */
27610 index_location_lists (comp_unit_die ());
27612 if (addr_index_table
!= NULL
)
27614 unsigned int index
= 0;
27616 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
27621 if (have_location_lists
)
27622 optimize_location_lists (comp_unit_die ());
27624 save_macinfo_strings ();
27626 if (dwarf_split_debug_info
)
27628 unsigned int index
= 0;
27630 /* Add attributes common to skeleton compile_units and
27631 type_units. Because these attributes include strings, it
27632 must be done before freezing the string table. Top-level
27633 skeleton die attrs are added when the skeleton type unit is
27634 created, so ensure it is created by this point. */
27635 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
27636 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
27639 /* Output all of the compilation units. We put the main one last so that
27640 the offsets are available to output_pubnames. */
27641 for (node
= limbo_die_list
; node
; node
= node
->next
)
27642 output_comp_unit (node
->die
, 0);
27644 hash_table
<comdat_type_hasher
> comdat_type_table (100);
27645 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
27647 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
27649 /* Don't output duplicate types. */
27650 if (*slot
!= HTAB_EMPTY_ENTRY
)
27653 /* Add a pointer to the line table for the main compilation unit
27654 so that the debugger can make sense of DW_AT_decl_file
27656 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
27657 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
27658 (!dwarf_split_debug_info
27659 ? debug_line_section_label
27660 : debug_skeleton_line_section_label
));
27662 output_comdat_type_unit (ctnode
);
27666 /* The AT_pubnames attribute needs to go in all skeleton dies, including
27667 both the main_cu and all skeleton TUs. Making this call unconditional
27668 would end up either adding a second copy of the AT_pubnames attribute, or
27669 requiring a special case in add_top_level_skeleton_die_attrs. */
27670 if (!dwarf_split_debug_info
)
27671 add_AT_pubnames (comp_unit_die ());
27673 if (dwarf_split_debug_info
)
27676 unsigned char checksum
[16];
27677 struct md5_ctx ctx
;
27679 /* Compute a checksum of the comp_unit to use as the dwo_id. */
27680 md5_init_ctx (&ctx
);
27682 die_checksum (comp_unit_die (), &ctx
, &mark
);
27683 unmark_all_dies (comp_unit_die ());
27684 md5_finish_ctx (&ctx
, checksum
);
27686 /* Use the first 8 bytes of the checksum as the dwo_id,
27687 and add it to both comp-unit DIEs. */
27688 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
27689 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
27691 /* Add the base offset of the ranges table to the skeleton
27693 if (ranges_table_in_use
)
27694 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
27695 ranges_section_label
);
27697 switch_to_section (debug_addr_section
);
27698 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
27699 output_addr_table ();
27702 /* Output the main compilation unit if non-empty or if .debug_macinfo
27703 or .debug_macro will be emitted. */
27704 output_comp_unit (comp_unit_die (), have_macinfo
);
27706 if (dwarf_split_debug_info
&& info_section_emitted
)
27707 output_skeleton_debug_sections (main_comp_unit_die
);
27709 /* Output the abbreviation table. */
27710 if (abbrev_die_table_in_use
!= 1)
27712 switch_to_section (debug_abbrev_section
);
27713 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
27714 output_abbrev_section ();
27717 /* Output location list section if necessary. */
27718 if (have_location_lists
)
27720 /* Output the location lists info. */
27721 switch_to_section (debug_loc_section
);
27722 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
27723 output_location_lists (comp_unit_die ());
27726 output_pubtables ();
27728 /* Output the address range information if a CU (.debug_info section)
27729 was emitted. We output an empty table even if we had no functions
27730 to put in it. This because the consumer has no way to tell the
27731 difference between an empty table that we omitted and failure to
27732 generate a table that would have contained data. */
27733 if (info_section_emitted
)
27735 switch_to_section (debug_aranges_section
);
27739 /* Output ranges section if necessary. */
27740 if (ranges_table_in_use
)
27742 switch_to_section (debug_ranges_section
);
27743 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
27747 /* Have to end the macro section. */
27750 switch_to_section (debug_macinfo_section
);
27751 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
27753 dw2_asm_output_data (1, 0, "End compilation unit");
27756 /* Output the source line correspondence table. We must do this
27757 even if there is no line information. Otherwise, on an empty
27758 translation unit, we will generate a present, but empty,
27759 .debug_info section. IRIX 6.5 `nm' will then complain when
27760 examining the file. This is done late so that any filenames
27761 used by the debug_info section are marked as 'used'. */
27762 switch_to_section (debug_line_section
);
27763 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
27764 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
27765 output_line_info (false);
27767 if (dwarf_split_debug_info
&& info_section_emitted
)
27769 switch_to_section (debug_skeleton_line_section
);
27770 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
27771 output_line_info (true);
27774 /* If we emitted any indirect strings, output the string table too. */
27775 if (debug_str_hash
|| skeleton_debug_str_hash
)
27776 output_indirect_strings ();
27779 /* Perform any cleanups needed after the early debug generation pass
27783 dwarf2out_early_finish (void)
27785 /* Walk through the list of incomplete types again, trying once more to
27786 emit full debugging info for them. */
27787 retry_incomplete_types ();
27789 /* The point here is to flush out the limbo list so that it is empty
27790 and we don't need to stream it for LTO. */
27791 flush_limbo_die_list ();
27793 gen_scheduled_generic_parms_dies ();
27794 gen_remaining_tmpl_value_param_die_attribute ();
27796 /* Add DW_AT_linkage_name for all deferred DIEs. */
27797 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
27799 tree decl
= node
->created_for
;
27800 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
27801 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
27802 ended up in deferred_asm_name before we knew it was
27803 constant and never written to disk. */
27804 && DECL_ASSEMBLER_NAME (decl
))
27806 add_linkage_attr (node
->die
, decl
);
27807 move_linkage_attr (node
->die
);
27810 deferred_asm_name
= NULL
;
27813 /* Reset all state within dwarf2out.c so that we can rerun the compiler
27814 within the same process. For use by toplev::finalize. */
27817 dwarf2out_c_finalize (void)
27819 last_var_location_insn
= NULL
;
27820 cached_next_real_insn
= NULL
;
27821 used_rtx_array
= NULL
;
27822 incomplete_types
= NULL
;
27823 decl_scope_table
= NULL
;
27824 debug_info_section
= NULL
;
27825 debug_skeleton_info_section
= NULL
;
27826 debug_abbrev_section
= NULL
;
27827 debug_skeleton_abbrev_section
= NULL
;
27828 debug_aranges_section
= NULL
;
27829 debug_addr_section
= NULL
;
27830 debug_macinfo_section
= NULL
;
27831 debug_line_section
= NULL
;
27832 debug_skeleton_line_section
= NULL
;
27833 debug_loc_section
= NULL
;
27834 debug_pubnames_section
= NULL
;
27835 debug_pubtypes_section
= NULL
;
27836 debug_str_section
= NULL
;
27837 debug_str_dwo_section
= NULL
;
27838 debug_str_offsets_section
= NULL
;
27839 debug_ranges_section
= NULL
;
27840 debug_frame_section
= NULL
;
27842 debug_str_hash
= NULL
;
27843 skeleton_debug_str_hash
= NULL
;
27844 dw2_string_counter
= 0;
27845 have_multiple_function_sections
= false;
27846 text_section_used
= false;
27847 cold_text_section_used
= false;
27848 cold_text_section
= NULL
;
27849 current_unit_personality
= NULL
;
27851 next_die_offset
= 0;
27852 single_comp_unit_die
= NULL
;
27853 comdat_type_list
= NULL
;
27854 limbo_die_list
= NULL
;
27856 decl_die_table
= NULL
;
27857 common_block_die_table
= NULL
;
27858 decl_loc_table
= NULL
;
27859 call_arg_locations
= NULL
;
27860 call_arg_loc_last
= NULL
;
27861 call_site_count
= -1;
27862 tail_call_site_count
= -1;
27863 cached_dw_loc_list_table
= NULL
;
27864 abbrev_die_table
= NULL
;
27865 abbrev_die_table_allocated
= 0;
27866 abbrev_die_table_in_use
= 0;
27867 delete dwarf_proc_stack_usage_map
;
27868 dwarf_proc_stack_usage_map
= NULL
;
27869 line_info_label_num
= 0;
27870 cur_line_info_table
= NULL
;
27871 text_section_line_info
= NULL
;
27872 cold_text_section_line_info
= NULL
;
27873 separate_line_info
= NULL
;
27874 info_section_emitted
= false;
27875 pubname_table
= NULL
;
27876 pubtype_table
= NULL
;
27877 macinfo_table
= NULL
;
27878 ranges_table
= NULL
;
27879 ranges_table_allocated
= 0;
27880 ranges_table_in_use
= 0;
27881 ranges_by_label
= 0;
27882 ranges_by_label_allocated
= 0;
27883 ranges_by_label_in_use
= 0;
27884 have_location_lists
= false;
27887 last_emitted_file
= NULL
;
27889 tmpl_value_parm_die_table
= NULL
;
27890 generic_type_instances
= NULL
;
27891 frame_pointer_fb_offset
= 0;
27892 frame_pointer_fb_offset_valid
= false;
27893 base_types
.release ();
27894 XDELETEVEC (producer_string
);
27895 producer_string
= NULL
;
27898 #include "gt-dwarf2out.h"