1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2014 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"
64 #include "stringpool.h"
65 #include "stor-layout.h"
69 #include "hash-table.h"
72 #include "hard-reg-set.h"
74 #include "insn-config.h"
81 #include "dwarf2out.h"
82 #include "dwarf2asm.h"
86 #include "diagnostic.h"
87 #include "tree-pretty-print.h"
90 #include "common/common-target.h"
91 #include "langhooks.h"
99 #include "gdb/gdb-index.h"
101 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
102 static rtx last_var_location_insn
;
103 static rtx cached_next_real_insn
;
105 #ifdef VMS_DEBUGGING_INFO
106 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
108 /* Define this macro to be a nonzero value if the directory specifications
109 which are output in the debug info should end with a separator. */
110 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
111 /* Define this macro to evaluate to a nonzero value if GCC should refrain
112 from generating indirect strings in DWARF2 debug information, for instance
113 if your target is stuck with an old version of GDB that is unable to
114 process them properly or uses VMS Debug. */
115 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
117 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
118 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
121 /* ??? Poison these here until it can be done generically. They've been
122 totally replaced in this file; make sure it stays that way. */
123 #undef DWARF2_UNWIND_INFO
124 #undef DWARF2_FRAME_INFO
125 #if (GCC_VERSION >= 3000)
126 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
129 /* The size of the target's pointer type. */
131 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
134 /* Array of RTXes referenced by the debugging information, which therefore
135 must be kept around forever. */
136 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
138 /* A pointer to the base of a list of incomplete types which might be
139 completed at some later time. incomplete_types_list needs to be a
140 vec<tree, va_gc> *because we want to tell the garbage collector about
142 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
144 /* A pointer to the base of a table of references to declaration
145 scopes. This table is a display which tracks the nesting
146 of declaration scopes at the current scope and containing
147 scopes. This table is used to find the proper place to
148 define type declaration DIE's. */
149 static GTY(()) vec
<tree
, va_gc
> *decl_scope_table
;
151 /* Pointers to various DWARF2 sections. */
152 static GTY(()) section
*debug_info_section
;
153 static GTY(()) section
*debug_skeleton_info_section
;
154 static GTY(()) section
*debug_abbrev_section
;
155 static GTY(()) section
*debug_skeleton_abbrev_section
;
156 static GTY(()) section
*debug_aranges_section
;
157 static GTY(()) section
*debug_addr_section
;
158 static GTY(()) section
*debug_macinfo_section
;
159 static GTY(()) section
*debug_line_section
;
160 static GTY(()) section
*debug_skeleton_line_section
;
161 static GTY(()) section
*debug_loc_section
;
162 static GTY(()) section
*debug_pubnames_section
;
163 static GTY(()) section
*debug_pubtypes_section
;
164 static GTY(()) section
*debug_str_section
;
165 static GTY(()) section
*debug_str_dwo_section
;
166 static GTY(()) section
*debug_str_offsets_section
;
167 static GTY(()) section
*debug_ranges_section
;
168 static GTY(()) section
*debug_frame_section
;
170 /* Maximum size (in bytes) of an artificially generated label. */
171 #define MAX_ARTIFICIAL_LABEL_BYTES 30
173 /* According to the (draft) DWARF 3 specification, the initial length
174 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
175 bytes are 0xffffffff, followed by the length stored in the next 8
178 However, the SGI/MIPS ABI uses an initial length which is equal to
179 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
181 #ifndef DWARF_INITIAL_LENGTH_SIZE
182 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
185 /* Round SIZE up to the nearest BOUNDARY. */
186 #define DWARF_ROUND(SIZE,BOUNDARY) \
187 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
189 /* CIE identifier. */
190 #if HOST_BITS_PER_WIDE_INT >= 64
191 #define DWARF_CIE_ID \
192 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
194 #define DWARF_CIE_ID DW_CIE_ID
198 /* A vector for a table that contains frame description
199 information for each routine. */
200 #define NOT_INDEXED (-1U)
201 #define NO_INDEX_ASSIGNED (-2U)
203 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
205 struct GTY(()) indirect_string_node
{
207 unsigned int refcount
;
208 enum dwarf_form form
;
213 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
215 /* With split_debug_info, both the comp_dir and dwo_name go in the
216 main object file, rather than the dwo, similar to the force_direct
217 parameter elsewhere but with additional complications:
219 1) The string is needed in both the main object file and the dwo.
220 That is, the comp_dir and dwo_name will appear in both places.
222 2) Strings can use three forms: DW_FORM_string, DW_FORM_strp or
223 DW_FORM_GNU_str_index.
225 3) GCC chooses the form to use late, depending on the size and
228 Rather than forcing the all debug string handling functions and
229 callers to deal with these complications, simply use a separate,
230 special-cased string table for any attribute that should go in the
231 main object file. This limits the complexity to just the places
234 static GTY ((param_is (struct indirect_string_node
)))
235 htab_t skeleton_debug_str_hash
;
237 static GTY(()) int dw2_string_counter
;
239 /* True if the compilation unit places functions in more than one section. */
240 static GTY(()) bool have_multiple_function_sections
= false;
242 /* Whether the default text and cold text sections have been used at all. */
244 static GTY(()) bool text_section_used
= false;
245 static GTY(()) bool cold_text_section_used
= false;
247 /* The default cold text section. */
248 static GTY(()) section
*cold_text_section
;
250 /* The DIE for C++1y 'auto' in a function return type. */
251 static GTY(()) dw_die_ref auto_die
;
253 /* The DIE for C++1y 'decltype(auto)' in a function return type. */
254 static GTY(()) dw_die_ref decltype_auto_die
;
256 /* Forward declarations for functions defined in this file. */
258 static char *stripattributes (const char *);
259 static void output_call_frame_info (int);
260 static void dwarf2out_note_section_used (void);
262 /* Personality decl of current unit. Used only when assembler does not support
264 static GTY(()) rtx current_unit_personality
;
266 /* Data and reference forms for relocatable data. */
267 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
268 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
270 #ifndef DEBUG_FRAME_SECTION
271 #define DEBUG_FRAME_SECTION ".debug_frame"
274 #ifndef FUNC_BEGIN_LABEL
275 #define FUNC_BEGIN_LABEL "LFB"
278 #ifndef FUNC_END_LABEL
279 #define FUNC_END_LABEL "LFE"
282 #ifndef PROLOGUE_END_LABEL
283 #define PROLOGUE_END_LABEL "LPE"
286 #ifndef EPILOGUE_BEGIN_LABEL
287 #define EPILOGUE_BEGIN_LABEL "LEB"
290 #ifndef FRAME_BEGIN_LABEL
291 #define FRAME_BEGIN_LABEL "Lframe"
293 #define CIE_AFTER_SIZE_LABEL "LSCIE"
294 #define CIE_END_LABEL "LECIE"
295 #define FDE_LABEL "LSFDE"
296 #define FDE_AFTER_SIZE_LABEL "LASFDE"
297 #define FDE_END_LABEL "LEFDE"
298 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
299 #define LINE_NUMBER_END_LABEL "LELT"
300 #define LN_PROLOG_AS_LABEL "LASLTP"
301 #define LN_PROLOG_END_LABEL "LELTP"
302 #define DIE_LABEL_PREFIX "DW"
304 /* Match the base name of a file to the base name of a compilation unit. */
307 matches_main_base (const char *path
)
309 /* Cache the last query. */
310 static const char *last_path
= NULL
;
311 static int last_match
= 0;
312 if (path
!= last_path
)
315 int length
= base_of_path (path
, &base
);
317 last_match
= (length
== main_input_baselength
318 && memcmp (base
, main_input_basename
, length
) == 0);
323 #ifdef DEBUG_DEBUG_STRUCT
326 dump_struct_debug (tree type
, enum debug_info_usage usage
,
327 enum debug_struct_file criterion
, int generic
,
328 int matches
, int result
)
330 /* Find the type name. */
331 tree type_decl
= TYPE_STUB_DECL (type
);
333 const char *name
= 0;
334 if (TREE_CODE (t
) == TYPE_DECL
)
337 name
= IDENTIFIER_POINTER (t
);
339 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
341 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
342 matches
? "bas" : "hdr",
343 generic
? "gen" : "ord",
344 usage
== DINFO_USAGE_DFN
? ";" :
345 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
347 (void*) type_decl
, name
);
350 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
351 dump_struct_debug (type, usage, criterion, generic, matches, result)
355 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
360 /* Get the number of HOST_WIDE_INTs needed to represent the precision
364 get_full_len (const wide_int
&op
)
366 return ((op
.get_precision () + HOST_BITS_PER_WIDE_INT
- 1)
367 / HOST_BITS_PER_WIDE_INT
);
371 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
373 enum debug_struct_file criterion
;
375 bool generic
= lang_hooks
.types
.generic_p (type
);
378 criterion
= debug_struct_generic
[usage
];
380 criterion
= debug_struct_ordinary
[usage
];
382 if (criterion
== DINFO_STRUCT_FILE_NONE
)
383 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
384 if (criterion
== DINFO_STRUCT_FILE_ANY
)
385 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
387 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
389 if (type_decl
!= NULL
)
391 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
392 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
394 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
395 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
398 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
401 /* Return a pointer to a copy of the section string name S with all
402 attributes stripped off, and an asterisk prepended (for assemble_name). */
405 stripattributes (const char *s
)
407 char *stripped
= XNEWVEC (char, strlen (s
) + 2);
412 while (*s
&& *s
!= ',')
419 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
420 switch to the data section instead, and write out a synthetic start label
421 for collect2 the first time around. */
424 switch_to_eh_frame_section (bool back
)
428 #ifdef EH_FRAME_SECTION_NAME
429 if (eh_frame_section
== 0)
433 if (EH_TABLES_CAN_BE_READ_ONLY
)
439 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
441 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
443 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
446 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
447 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
448 && (per_encoding
& 0x70) != DW_EH_PE_absptr
449 && (per_encoding
& 0x70) != DW_EH_PE_aligned
450 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
451 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
452 ? 0 : SECTION_WRITE
);
455 flags
= SECTION_WRITE
;
456 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
458 #endif /* EH_FRAME_SECTION_NAME */
460 if (eh_frame_section
)
461 switch_to_section (eh_frame_section
);
464 /* We have no special eh_frame section. Put the information in
465 the data section and emit special labels to guide collect2. */
466 switch_to_section (data_section
);
470 label
= get_file_function_name ("F");
471 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
472 targetm
.asm_out
.globalize_label (asm_out_file
,
473 IDENTIFIER_POINTER (label
));
474 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
479 /* Switch [BACK] to the eh or debug frame table section, depending on
483 switch_to_frame_table_section (int for_eh
, bool back
)
486 switch_to_eh_frame_section (back
);
489 if (!debug_frame_section
)
490 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
491 SECTION_DEBUG
, NULL
);
492 switch_to_section (debug_frame_section
);
496 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
498 enum dw_cfi_oprnd_type
499 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
504 case DW_CFA_GNU_window_save
:
505 case DW_CFA_remember_state
:
506 case DW_CFA_restore_state
:
507 return dw_cfi_oprnd_unused
;
510 case DW_CFA_advance_loc1
:
511 case DW_CFA_advance_loc2
:
512 case DW_CFA_advance_loc4
:
513 case DW_CFA_MIPS_advance_loc8
:
514 return dw_cfi_oprnd_addr
;
517 case DW_CFA_offset_extended
:
519 case DW_CFA_offset_extended_sf
:
520 case DW_CFA_def_cfa_sf
:
522 case DW_CFA_restore_extended
:
523 case DW_CFA_undefined
:
524 case DW_CFA_same_value
:
525 case DW_CFA_def_cfa_register
:
526 case DW_CFA_register
:
527 case DW_CFA_expression
:
528 return dw_cfi_oprnd_reg_num
;
530 case DW_CFA_def_cfa_offset
:
531 case DW_CFA_GNU_args_size
:
532 case DW_CFA_def_cfa_offset_sf
:
533 return dw_cfi_oprnd_offset
;
535 case DW_CFA_def_cfa_expression
:
536 return dw_cfi_oprnd_loc
;
543 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
545 enum dw_cfi_oprnd_type
546 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
551 case DW_CFA_def_cfa_sf
:
553 case DW_CFA_offset_extended_sf
:
554 case DW_CFA_offset_extended
:
555 return dw_cfi_oprnd_offset
;
557 case DW_CFA_register
:
558 return dw_cfi_oprnd_reg_num
;
560 case DW_CFA_expression
:
561 return dw_cfi_oprnd_loc
;
564 return dw_cfi_oprnd_unused
;
568 /* Output one FDE. */
571 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
572 char *section_start_label
, int fde_encoding
, char *augmentation
,
573 bool any_lsda_needed
, int lsda_encoding
)
575 const char *begin
, *end
;
576 static unsigned int j
;
579 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
581 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
583 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
584 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
585 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
586 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
587 " indicating 64-bit DWARF extension");
588 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
590 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
593 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
595 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
596 debug_frame_section
, "FDE CIE offset");
598 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
599 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
603 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
604 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
605 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
606 "FDE initial location");
607 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
608 end
, begin
, "FDE address range");
612 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
613 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
620 int size
= size_of_encoded_value (lsda_encoding
);
622 if (lsda_encoding
== DW_EH_PE_aligned
)
624 int offset
= ( 4 /* Length */
626 + 2 * size_of_encoded_value (fde_encoding
)
627 + 1 /* Augmentation size */ );
628 int pad
= -offset
& (PTR_SIZE
- 1);
631 gcc_assert (size_of_uleb128 (size
) == 1);
634 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
636 if (fde
->uses_eh_lsda
)
638 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
639 fde
->funcdef_number
);
640 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
641 gen_rtx_SYMBOL_REF (Pmode
, l1
),
643 "Language Specific Data Area");
647 if (lsda_encoding
== DW_EH_PE_aligned
)
648 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
649 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
650 "Language Specific Data Area (none)");
654 dw2_asm_output_data_uleb128 (0, "Augmentation size");
657 /* Loop through the Call Frame Instructions associated with this FDE. */
658 fde
->dw_fde_current_label
= begin
;
660 size_t from
, until
, i
;
663 until
= vec_safe_length (fde
->dw_fde_cfi
);
665 if (fde
->dw_fde_second_begin
== NULL
)
668 until
= fde
->dw_fde_switch_cfi_index
;
670 from
= fde
->dw_fde_switch_cfi_index
;
672 for (i
= from
; i
< until
; i
++)
673 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
676 /* If we are to emit a ref/link from function bodies to their frame tables,
677 do it now. This is typically performed to make sure that tables
678 associated with functions are dragged with them and not discarded in
679 garbage collecting links. We need to do this on a per function basis to
680 cope with -ffunction-sections. */
682 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
683 /* Switch to the function section, emit the ref to the tables, and
684 switch *back* into the table section. */
685 switch_to_section (function_section (fde
->decl
));
686 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
687 switch_to_frame_table_section (for_eh
, true);
690 /* Pad the FDE out to an address sized boundary. */
691 ASM_OUTPUT_ALIGN (asm_out_file
,
692 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
693 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
698 /* Return true if frame description entry FDE is needed for EH. */
701 fde_needed_for_eh_p (dw_fde_ref fde
)
703 if (flag_asynchronous_unwind_tables
)
706 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
709 if (fde
->uses_eh_lsda
)
712 /* If exceptions are enabled, we have collected nothrow info. */
713 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
719 /* Output the call frame information used to record information
720 that relates to calculating the frame pointer, and records the
721 location of saved registers. */
724 output_call_frame_info (int for_eh
)
729 char l1
[20], l2
[20], section_start_label
[20];
730 bool any_lsda_needed
= false;
731 char augmentation
[6];
732 int augmentation_size
;
733 int fde_encoding
= DW_EH_PE_absptr
;
734 int per_encoding
= DW_EH_PE_absptr
;
735 int lsda_encoding
= DW_EH_PE_absptr
;
737 rtx personality
= NULL
;
740 /* Don't emit a CIE if there won't be any FDEs. */
744 /* Nothing to do if the assembler's doing it all. */
745 if (dwarf2out_do_cfi_asm ())
748 /* If we don't have any functions we'll want to unwind out of, don't emit
749 any EH unwind information. If we make FDEs linkonce, we may have to
750 emit an empty label for an FDE that wouldn't otherwise be emitted. We
751 want to avoid having an FDE kept around when the function it refers to
752 is discarded. Example where this matters: a primary function template
753 in C++ requires EH information, an explicit specialization doesn't. */
756 bool any_eh_needed
= false;
758 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
760 if (fde
->uses_eh_lsda
)
761 any_eh_needed
= any_lsda_needed
= true;
762 else if (fde_needed_for_eh_p (fde
))
763 any_eh_needed
= true;
764 else if (TARGET_USES_WEAK_UNWIND_INFO
)
765 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
772 /* We're going to be generating comments, so turn on app. */
776 /* Switch to the proper frame section, first time. */
777 switch_to_frame_table_section (for_eh
, false);
779 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
780 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
782 /* Output the CIE. */
783 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
784 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
785 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
786 dw2_asm_output_data (4, 0xffffffff,
787 "Initial length escape value indicating 64-bit DWARF extension");
788 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
789 "Length of Common Information Entry");
790 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
792 /* Now that the CIE pointer is PC-relative for EH,
793 use 0 to identify the CIE. */
794 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
795 (for_eh
? 0 : DWARF_CIE_ID
),
796 "CIE Identifier Tag");
798 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
799 use CIE version 1, unless that would produce incorrect results
800 due to overflowing the return register column. */
801 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
803 if (return_reg
>= 256 || dwarf_version
> 2)
805 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
808 augmentation_size
= 0;
810 personality
= current_unit_personality
;
816 z Indicates that a uleb128 is present to size the
817 augmentation section.
818 L Indicates the encoding (and thus presence) of
819 an LSDA pointer in the FDE augmentation.
820 R Indicates a non-default pointer encoding for
822 P Indicates the presence of an encoding + language
823 personality routine in the CIE augmentation. */
825 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
826 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
827 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
829 p
= augmentation
+ 1;
833 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
834 assemble_external_libcall (personality
);
839 augmentation_size
+= 1;
841 if (fde_encoding
!= DW_EH_PE_absptr
)
844 augmentation_size
+= 1;
846 if (p
> augmentation
+ 1)
848 augmentation
[0] = 'z';
852 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
853 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
855 int offset
= ( 4 /* Length */
857 + 1 /* CIE version */
858 + strlen (augmentation
) + 1 /* Augmentation */
859 + size_of_uleb128 (1) /* Code alignment */
860 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
862 + 1 /* Augmentation size */
863 + 1 /* Personality encoding */ );
864 int pad
= -offset
& (PTR_SIZE
- 1);
866 augmentation_size
+= pad
;
868 /* Augmentations should be small, so there's scarce need to
869 iterate for a solution. Die if we exceed one uleb128 byte. */
870 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
874 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
875 if (dw_cie_version
>= 4)
877 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
878 dw2_asm_output_data (1, 0, "CIE Segment Size");
880 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
881 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
882 "CIE Data Alignment Factor");
884 if (dw_cie_version
== 1)
885 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
887 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
891 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
894 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
895 eh_data_format_name (per_encoding
));
896 dw2_asm_output_encoded_addr_rtx (per_encoding
,
902 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
903 eh_data_format_name (lsda_encoding
));
905 if (fde_encoding
!= DW_EH_PE_absptr
)
906 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
907 eh_data_format_name (fde_encoding
));
910 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
911 output_cfi (cfi
, NULL
, for_eh
);
913 /* Pad the CIE out to an address sized boundary. */
914 ASM_OUTPUT_ALIGN (asm_out_file
,
915 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
916 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
918 /* Loop through all of the FDE's. */
919 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
923 /* Don't emit EH unwind info for leaf functions that don't need it. */
924 if (for_eh
&& !fde_needed_for_eh_p (fde
))
927 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
928 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
929 augmentation
, any_lsda_needed
, lsda_encoding
);
932 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
933 dw2_asm_output_data (4, 0, "End of Table");
935 /* Turn off app to make assembly quicker. */
940 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
943 dwarf2out_do_cfi_startproc (bool second
)
947 rtx personality
= get_personality_function (current_function_decl
);
949 fprintf (asm_out_file
, "\t.cfi_startproc\n");
953 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
956 /* ??? The GAS support isn't entirely consistent. We have to
957 handle indirect support ourselves, but PC-relative is done
958 in the assembler. Further, the assembler can't handle any
959 of the weirder relocation types. */
960 if (enc
& DW_EH_PE_indirect
)
961 ref
= dw2_force_const_mem (ref
, true);
963 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
964 output_addr_const (asm_out_file
, ref
);
965 fputc ('\n', asm_out_file
);
968 if (crtl
->uses_eh_lsda
)
972 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
973 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
974 current_function_funcdef_no
);
975 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
976 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
978 if (enc
& DW_EH_PE_indirect
)
979 ref
= dw2_force_const_mem (ref
, true);
981 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
982 output_addr_const (asm_out_file
, ref
);
983 fputc ('\n', asm_out_file
);
987 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
988 this allocation may be done before pass_final. */
991 dwarf2out_alloc_current_fde (void)
995 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
996 fde
->decl
= current_function_decl
;
997 fde
->funcdef_number
= current_function_funcdef_no
;
998 fde
->fde_index
= vec_safe_length (fde_vec
);
999 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1000 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1001 fde
->nothrow
= crtl
->nothrow
;
1002 fde
->drap_reg
= INVALID_REGNUM
;
1003 fde
->vdrap_reg
= INVALID_REGNUM
;
1005 /* Record the FDE associated with this function. */
1007 vec_safe_push (fde_vec
, fde
);
1012 /* Output a marker (i.e. a label) for the beginning of a function, before
1016 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1017 const char *file ATTRIBUTE_UNUSED
)
1019 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1025 current_function_func_begin_label
= NULL
;
1027 do_frame
= dwarf2out_do_frame ();
1029 /* ??? current_function_func_begin_label is also used by except.c for
1030 call-site information. We must emit this label if it might be used. */
1032 && (!flag_exceptions
1033 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1036 fnsec
= function_section (current_function_decl
);
1037 switch_to_section (fnsec
);
1038 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1039 current_function_funcdef_no
);
1040 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1041 current_function_funcdef_no
);
1042 dup_label
= xstrdup (label
);
1043 current_function_func_begin_label
= dup_label
;
1045 /* We can elide the fde allocation if we're not emitting debug info. */
1049 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1050 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1051 would include pass_dwarf2_frame. If we've not created the FDE yet,
1055 fde
= dwarf2out_alloc_current_fde ();
1057 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1058 fde
->dw_fde_begin
= dup_label
;
1059 fde
->dw_fde_current_label
= dup_label
;
1060 fde
->in_std_section
= (fnsec
== text_section
1061 || (cold_text_section
&& fnsec
== cold_text_section
));
1063 /* We only want to output line number information for the genuine dwarf2
1064 prologue case, not the eh frame case. */
1065 #ifdef DWARF2_DEBUGGING_INFO
1067 dwarf2out_source_line (line
, file
, 0, true);
1070 if (dwarf2out_do_cfi_asm ())
1071 dwarf2out_do_cfi_startproc (false);
1074 rtx personality
= get_personality_function (current_function_decl
);
1075 if (!current_unit_personality
)
1076 current_unit_personality
= personality
;
1078 /* We cannot keep a current personality per function as without CFI
1079 asm, at the point where we emit the CFI data, there is no current
1080 function anymore. */
1081 if (personality
&& current_unit_personality
!= personality
)
1082 sorry ("multiple EH personalities are supported only with assemblers "
1083 "supporting .cfi_personality directive");
1087 /* Output a marker (i.e. a label) for the end of the generated code
1088 for a function prologue. This gets called *after* the prologue code has
1092 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1093 const char *file ATTRIBUTE_UNUSED
)
1095 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1097 /* Output a label to mark the endpoint of the code generated for this
1099 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1100 current_function_funcdef_no
);
1101 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1102 current_function_funcdef_no
);
1103 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1106 /* Output a marker (i.e. a label) for the beginning of the generated code
1107 for a function epilogue. This gets called *before* the prologue code has
1111 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1112 const char *file ATTRIBUTE_UNUSED
)
1114 dw_fde_ref fde
= cfun
->fde
;
1115 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1117 if (fde
->dw_fde_vms_begin_epilogue
)
1120 /* Output a label to mark the endpoint of the code generated for this
1122 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1123 current_function_funcdef_no
);
1124 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1125 current_function_funcdef_no
);
1126 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1129 /* Output a marker (i.e. a label) for the absolute end of the generated code
1130 for a function definition. This gets called *after* the epilogue code has
1134 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1135 const char *file ATTRIBUTE_UNUSED
)
1138 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1140 last_var_location_insn
= NULL_RTX
;
1141 cached_next_real_insn
= NULL_RTX
;
1143 if (dwarf2out_do_cfi_asm ())
1144 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1146 /* Output a label to mark the endpoint of the code generated for this
1148 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1149 current_function_funcdef_no
);
1150 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1152 gcc_assert (fde
!= NULL
);
1153 if (fde
->dw_fde_second_begin
== NULL
)
1154 fde
->dw_fde_end
= xstrdup (label
);
1158 dwarf2out_frame_finish (void)
1160 /* Output call frame information. */
1161 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1162 output_call_frame_info (0);
1164 /* Output another copy for the unwinder. */
1165 if ((flag_unwind_tables
|| flag_exceptions
)
1166 && targetm_common
.except_unwind_info (&global_options
) == UI_DWARF2
)
1167 output_call_frame_info (1);
1170 /* Note that the current function section is being used for code. */
1173 dwarf2out_note_section_used (void)
1175 section
*sec
= current_function_section ();
1176 if (sec
== text_section
)
1177 text_section_used
= true;
1178 else if (sec
== cold_text_section
)
1179 cold_text_section_used
= true;
1182 static void var_location_switch_text_section (void);
1183 static void set_cur_line_info_table (section
*);
1186 dwarf2out_switch_text_section (void)
1189 dw_fde_ref fde
= cfun
->fde
;
1191 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1193 if (!in_cold_section_p
)
1195 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1196 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1197 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1201 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1202 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1203 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1205 have_multiple_function_sections
= true;
1207 /* There is no need to mark used sections when not debugging. */
1208 if (cold_text_section
!= NULL
)
1209 dwarf2out_note_section_used ();
1211 if (dwarf2out_do_cfi_asm ())
1212 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1214 /* Now do the real section switch. */
1215 sect
= current_function_section ();
1216 switch_to_section (sect
);
1218 fde
->second_in_std_section
1219 = (sect
== text_section
1220 || (cold_text_section
&& sect
== cold_text_section
));
1222 if (dwarf2out_do_cfi_asm ())
1223 dwarf2out_do_cfi_startproc (true);
1225 var_location_switch_text_section ();
1227 if (cold_text_section
!= NULL
)
1228 set_cur_line_info_table (sect
);
1231 /* And now, the subset of the debugging information support code necessary
1232 for emitting location expressions. */
1234 /* Data about a single source file. */
1235 struct GTY(()) dwarf_file_data
{
1236 const char * filename
;
1240 typedef struct GTY(()) deferred_locations_struct
1244 } deferred_locations
;
1247 static GTY(()) vec
<deferred_locations
, va_gc
> *deferred_locations_list
;
1250 /* Describe an entry into the .debug_addr section. */
1254 ate_kind_rtx_dtprel
,
1258 typedef struct GTY(()) addr_table_entry_struct
{
1260 unsigned int refcount
;
1262 union addr_table_entry_struct_union
1264 rtx
GTY ((tag ("0"))) rtl
;
1265 char * GTY ((tag ("1"))) label
;
1267 GTY ((desc ("%1.kind"))) addr
;
1271 /* Location lists are ranges + location descriptions for that range,
1272 so you can track variables that are in different places over
1273 their entire life. */
1274 typedef struct GTY(()) dw_loc_list_struct
{
1275 dw_loc_list_ref dw_loc_next
;
1276 const char *begin
; /* Label and addr_entry for start of range */
1277 addr_table_entry
*begin_entry
;
1278 const char *end
; /* Label for end of range */
1279 char *ll_symbol
; /* Label for beginning of location list.
1280 Only on head of list */
1281 const char *section
; /* Section this loclist is relative to */
1282 dw_loc_descr_ref expr
;
1284 /* True if all addresses in this and subsequent lists are known to be
1287 /* True if this list has been replaced by dw_loc_next. */
1290 /* True if the range should be emitted even if begin and end
1295 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
1297 /* Convert a DWARF stack opcode into its string name. */
1300 dwarf_stack_op_name (unsigned int op
)
1302 const char *name
= get_DW_OP_name (op
);
1307 return "OP_<unknown>";
1310 /* Return a pointer to a newly allocated location description. Location
1311 descriptions are simple expression terms that can be strung
1312 together to form more complicated location (address) descriptions. */
1314 static inline dw_loc_descr_ref
1315 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1316 unsigned HOST_WIDE_INT oprnd2
)
1318 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1320 descr
->dw_loc_opc
= op
;
1321 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1322 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1323 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1324 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1325 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1326 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1331 /* Return a pointer to a newly allocated location description for
1334 static inline dw_loc_descr_ref
1335 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
1338 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1341 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
1344 /* Add a location description term to a location description expression. */
1347 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1349 dw_loc_descr_ref
*d
;
1351 /* Find the end of the chain. */
1352 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1358 /* Compare two location operands for exact equality. */
1361 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1363 if (a
->val_class
!= b
->val_class
)
1365 switch (a
->val_class
)
1367 case dw_val_class_none
:
1369 case dw_val_class_addr
:
1370 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1372 case dw_val_class_offset
:
1373 case dw_val_class_unsigned_const
:
1374 case dw_val_class_const
:
1375 case dw_val_class_range_list
:
1376 case dw_val_class_lineptr
:
1377 case dw_val_class_macptr
:
1378 /* These are all HOST_WIDE_INT, signed or unsigned. */
1379 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1381 case dw_val_class_loc
:
1382 return a
->v
.val_loc
== b
->v
.val_loc
;
1383 case dw_val_class_loc_list
:
1384 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1385 case dw_val_class_die_ref
:
1386 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1387 case dw_val_class_fde_ref
:
1388 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1389 case dw_val_class_lbl_id
:
1390 case dw_val_class_high_pc
:
1391 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1392 case dw_val_class_str
:
1393 return a
->v
.val_str
== b
->v
.val_str
;
1394 case dw_val_class_flag
:
1395 return a
->v
.val_flag
== b
->v
.val_flag
;
1396 case dw_val_class_file
:
1397 return a
->v
.val_file
== b
->v
.val_file
;
1398 case dw_val_class_decl_ref
:
1399 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1401 case dw_val_class_const_double
:
1402 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1403 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1405 case dw_val_class_wide_int
:
1406 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1408 case dw_val_class_vec
:
1410 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1411 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1413 return (a_len
== b_len
1414 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1417 case dw_val_class_data8
:
1418 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1420 case dw_val_class_vms_delta
:
1421 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1422 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1427 /* Compare two location atoms for exact equality. */
1430 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1432 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1435 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1436 address size, but since we always allocate cleared storage it
1437 should be zero for other types of locations. */
1438 if (a
->dtprel
!= b
->dtprel
)
1441 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1442 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1445 /* Compare two complete location expressions for exact equality. */
1448 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1454 if (a
== NULL
|| b
== NULL
)
1456 if (!loc_descr_equal_p_1 (a
, b
))
1465 /* Add a constant OFFSET to a location expression. */
1468 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
1470 dw_loc_descr_ref loc
;
1473 gcc_assert (*list_head
!= NULL
);
1478 /* Find the end of the chain. */
1479 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1483 if (loc
->dw_loc_opc
== DW_OP_fbreg
1484 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1485 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1486 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1487 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1489 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1490 offset. Don't optimize if an signed integer overflow would happen. */
1492 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1493 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1496 else if (offset
> 0)
1497 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1501 loc
->dw_loc_next
= int_loc_descriptor (-offset
);
1502 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1506 /* Add a constant OFFSET to a location list. */
1509 loc_list_plus_const (dw_loc_list_ref list_head
, HOST_WIDE_INT offset
)
1512 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1513 loc_descr_plus_const (&d
->expr
, offset
);
1516 #define DWARF_REF_SIZE \
1517 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1519 static unsigned long int get_base_type_offset (dw_die_ref
);
1521 /* Return the size of a location descriptor. */
1523 static unsigned long
1524 size_of_loc_descr (dw_loc_descr_ref loc
)
1526 unsigned long size
= 1;
1528 switch (loc
->dw_loc_opc
)
1531 size
+= DWARF2_ADDR_SIZE
;
1533 case DW_OP_GNU_addr_index
:
1534 case DW_OP_GNU_const_index
:
1535 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1536 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1555 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1558 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1563 case DW_OP_plus_uconst
:
1564 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1602 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1605 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1608 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1611 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1612 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1615 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1617 case DW_OP_bit_piece
:
1618 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1619 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1621 case DW_OP_deref_size
:
1622 case DW_OP_xderef_size
:
1631 case DW_OP_call_ref
:
1632 size
+= DWARF_REF_SIZE
;
1634 case DW_OP_implicit_value
:
1635 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1636 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1638 case DW_OP_GNU_implicit_pointer
:
1639 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1641 case DW_OP_GNU_entry_value
:
1643 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1644 size
+= size_of_uleb128 (op_size
) + op_size
;
1647 case DW_OP_GNU_const_type
:
1650 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1651 size
+= size_of_uleb128 (o
) + 1;
1652 switch (loc
->dw_loc_oprnd2
.val_class
)
1654 case dw_val_class_vec
:
1655 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1656 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1658 case dw_val_class_const
:
1659 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1661 case dw_val_class_const_double
:
1662 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1664 case dw_val_class_wide_int
:
1665 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1666 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1673 case DW_OP_GNU_regval_type
:
1676 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1677 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1678 + size_of_uleb128 (o
);
1681 case DW_OP_GNU_deref_type
:
1684 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1685 size
+= 1 + size_of_uleb128 (o
);
1688 case DW_OP_GNU_convert
:
1689 case DW_OP_GNU_reinterpret
:
1690 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1691 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1695 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1696 size
+= size_of_uleb128 (o
);
1699 case DW_OP_GNU_parameter_ref
:
1709 /* Return the size of a series of location descriptors. */
1712 size_of_locs (dw_loc_descr_ref loc
)
1717 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1718 field, to avoid writing to a PCH file. */
1719 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1721 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1723 size
+= size_of_loc_descr (l
);
1728 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1730 l
->dw_loc_addr
= size
;
1731 size
+= size_of_loc_descr (l
);
1737 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
1738 static void get_ref_die_offset_label (char *, dw_die_ref
);
1739 static unsigned long int get_ref_die_offset (dw_die_ref
);
1741 /* Output location description stack opcode's operands (if any).
1742 The for_eh_or_skip parameter controls whether register numbers are
1743 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1744 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1745 info). This should be suppressed for the cases that have not been converted
1746 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1749 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
1751 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
1752 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
1754 switch (loc
->dw_loc_opc
)
1756 #ifdef DWARF2_DEBUGGING_INFO
1759 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
1764 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1765 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
1767 fputc ('\n', asm_out_file
);
1772 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
1777 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1778 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
1780 fputc ('\n', asm_out_file
);
1785 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
1786 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
1793 gcc_assert (val1
->val_class
== dw_val_class_loc
);
1794 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
1796 dw2_asm_output_data (2, offset
, NULL
);
1799 case DW_OP_implicit_value
:
1800 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1801 switch (val2
->val_class
)
1803 case dw_val_class_const
:
1804 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
1806 case dw_val_class_vec
:
1808 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
1809 unsigned int len
= val2
->v
.val_vec
.length
;
1813 if (elt_size
> sizeof (HOST_WIDE_INT
))
1818 for (i
= 0, p
= val2
->v
.val_vec
.array
;
1821 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
1822 "fp or vector constant word %u", i
);
1825 case dw_val_class_const_double
:
1827 unsigned HOST_WIDE_INT first
, second
;
1829 if (WORDS_BIG_ENDIAN
)
1831 first
= val2
->v
.val_double
.high
;
1832 second
= val2
->v
.val_double
.low
;
1836 first
= val2
->v
.val_double
.low
;
1837 second
= val2
->v
.val_double
.high
;
1839 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1841 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1845 case dw_val_class_wide_int
:
1848 int len
= get_full_len (*val2
->v
.val_wide
);
1849 if (WORDS_BIG_ENDIAN
)
1850 for (i
= len
- 1; i
>= 0; --i
)
1851 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1852 val2
->v
.val_wide
->elt (i
), NULL
);
1854 for (i
= 0; i
< len
; ++i
)
1855 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1856 val2
->v
.val_wide
->elt (i
), NULL
);
1859 case dw_val_class_addr
:
1860 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
1861 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
1876 case DW_OP_implicit_value
:
1877 /* We currently don't make any attempt to make sure these are
1878 aligned properly like we do for the main unwind info, so
1879 don't support emitting things larger than a byte if we're
1880 only doing unwinding. */
1885 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1888 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1891 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1894 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1896 case DW_OP_plus_uconst
:
1897 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1931 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1935 unsigned r
= val1
->v
.val_unsigned
;
1936 if (for_eh_or_skip
>= 0)
1937 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1938 gcc_assert (size_of_uleb128 (r
)
1939 == size_of_uleb128 (val1
->v
.val_unsigned
));
1940 dw2_asm_output_data_uleb128 (r
, NULL
);
1944 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1948 unsigned r
= val1
->v
.val_unsigned
;
1949 if (for_eh_or_skip
>= 0)
1950 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1951 gcc_assert (size_of_uleb128 (r
)
1952 == size_of_uleb128 (val1
->v
.val_unsigned
));
1953 dw2_asm_output_data_uleb128 (r
, NULL
);
1954 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
1958 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1960 case DW_OP_bit_piece
:
1961 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1962 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
1964 case DW_OP_deref_size
:
1965 case DW_OP_xderef_size
:
1966 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1972 if (targetm
.asm_out
.output_dwarf_dtprel
)
1974 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
1977 fputc ('\n', asm_out_file
);
1984 #ifdef DWARF2_DEBUGGING_INFO
1985 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
1992 case DW_OP_GNU_addr_index
:
1993 case DW_OP_GNU_const_index
:
1994 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1995 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
1996 "(index into .debug_addr)");
1999 case DW_OP_GNU_implicit_pointer
:
2001 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2002 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2003 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2004 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2005 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2006 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2010 case DW_OP_GNU_entry_value
:
2011 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2012 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2015 case DW_OP_GNU_const_type
:
2017 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2019 dw2_asm_output_data_uleb128 (o
, NULL
);
2020 switch (val2
->val_class
)
2022 case dw_val_class_const
:
2023 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2024 dw2_asm_output_data (1, l
, NULL
);
2025 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2027 case dw_val_class_vec
:
2029 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2030 unsigned int len
= val2
->v
.val_vec
.length
;
2035 dw2_asm_output_data (1, l
, NULL
);
2036 if (elt_size
> sizeof (HOST_WIDE_INT
))
2041 for (i
= 0, p
= val2
->v
.val_vec
.array
;
2044 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2045 "fp or vector constant word %u", i
);
2048 case dw_val_class_const_double
:
2050 unsigned HOST_WIDE_INT first
, second
;
2051 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2053 dw2_asm_output_data (1, 2 * l
, NULL
);
2054 if (WORDS_BIG_ENDIAN
)
2056 first
= val2
->v
.val_double
.high
;
2057 second
= val2
->v
.val_double
.low
;
2061 first
= val2
->v
.val_double
.low
;
2062 second
= val2
->v
.val_double
.high
;
2064 dw2_asm_output_data (l
, first
, NULL
);
2065 dw2_asm_output_data (l
, second
, NULL
);
2068 case dw_val_class_wide_int
:
2071 int len
= get_full_len (*val2
->v
.val_wide
);
2072 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2074 dw2_asm_output_data (1, len
* l
, NULL
);
2075 if (WORDS_BIG_ENDIAN
)
2076 for (i
= len
- 1; i
>= 0; --i
)
2077 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2079 for (i
= 0; i
< len
; ++i
)
2080 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2088 case DW_OP_GNU_regval_type
:
2090 unsigned r
= val1
->v
.val_unsigned
;
2091 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2093 if (for_eh_or_skip
>= 0)
2095 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2096 gcc_assert (size_of_uleb128 (r
)
2097 == size_of_uleb128 (val1
->v
.val_unsigned
));
2099 dw2_asm_output_data_uleb128 (r
, NULL
);
2100 dw2_asm_output_data_uleb128 (o
, NULL
);
2103 case DW_OP_GNU_deref_type
:
2105 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2107 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2108 dw2_asm_output_data_uleb128 (o
, NULL
);
2111 case DW_OP_GNU_convert
:
2112 case DW_OP_GNU_reinterpret
:
2113 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2114 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2117 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2119 dw2_asm_output_data_uleb128 (o
, NULL
);
2123 case DW_OP_GNU_parameter_ref
:
2126 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2127 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2128 dw2_asm_output_data (4, o
, NULL
);
2133 /* Other codes have no operands. */
2138 /* Output a sequence of location operations.
2139 The for_eh_or_skip parameter controls whether register numbers are
2140 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2141 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2142 info). This should be suppressed for the cases that have not been converted
2143 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2146 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2148 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2150 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2151 /* Output the opcode. */
2152 if (for_eh_or_skip
>= 0
2153 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2155 unsigned r
= (opc
- DW_OP_breg0
);
2156 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2157 gcc_assert (r
<= 31);
2158 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2160 else if (for_eh_or_skip
>= 0
2161 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2163 unsigned r
= (opc
- DW_OP_reg0
);
2164 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2165 gcc_assert (r
<= 31);
2166 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2169 dw2_asm_output_data (1, opc
,
2170 "%s", dwarf_stack_op_name (opc
));
2172 /* Output the operand(s) (if any). */
2173 output_loc_operands (loc
, for_eh_or_skip
);
2177 /* Output location description stack opcode's operands (if any).
2178 The output is single bytes on a line, suitable for .cfi_escape. */
2181 output_loc_operands_raw (dw_loc_descr_ref loc
)
2183 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2184 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2186 switch (loc
->dw_loc_opc
)
2189 case DW_OP_GNU_addr_index
:
2190 case DW_OP_GNU_const_index
:
2191 case DW_OP_implicit_value
:
2192 /* We cannot output addresses in .cfi_escape, only bytes. */
2198 case DW_OP_deref_size
:
2199 case DW_OP_xderef_size
:
2200 fputc (',', asm_out_file
);
2201 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2206 fputc (',', asm_out_file
);
2207 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2212 fputc (',', asm_out_file
);
2213 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2218 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2219 fputc (',', asm_out_file
);
2220 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2228 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2229 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2231 fputc (',', asm_out_file
);
2232 dw2_asm_output_data_raw (2, offset
);
2238 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2239 gcc_assert (size_of_uleb128 (r
)
2240 == size_of_uleb128 (val1
->v
.val_unsigned
));
2241 fputc (',', asm_out_file
);
2242 dw2_asm_output_data_uleb128_raw (r
);
2247 case DW_OP_plus_uconst
:
2249 fputc (',', asm_out_file
);
2250 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2253 case DW_OP_bit_piece
:
2254 fputc (',', asm_out_file
);
2255 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2256 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2293 fputc (',', asm_out_file
);
2294 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2299 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2300 gcc_assert (size_of_uleb128 (r
)
2301 == size_of_uleb128 (val1
->v
.val_unsigned
));
2302 fputc (',', asm_out_file
);
2303 dw2_asm_output_data_uleb128_raw (r
);
2304 fputc (',', asm_out_file
);
2305 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2309 case DW_OP_GNU_implicit_pointer
:
2310 case DW_OP_GNU_entry_value
:
2311 case DW_OP_GNU_const_type
:
2312 case DW_OP_GNU_regval_type
:
2313 case DW_OP_GNU_deref_type
:
2314 case DW_OP_GNU_convert
:
2315 case DW_OP_GNU_reinterpret
:
2316 case DW_OP_GNU_parameter_ref
:
2321 /* Other codes have no operands. */
2327 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2331 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2332 /* Output the opcode. */
2333 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2335 unsigned r
= (opc
- DW_OP_breg0
);
2336 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2337 gcc_assert (r
<= 31);
2338 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2340 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2342 unsigned r
= (opc
- DW_OP_reg0
);
2343 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2344 gcc_assert (r
<= 31);
2345 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2347 /* Output the opcode. */
2348 fprintf (asm_out_file
, "%#x", opc
);
2349 output_loc_operands_raw (loc
);
2351 if (!loc
->dw_loc_next
)
2353 loc
= loc
->dw_loc_next
;
2355 fputc (',', asm_out_file
);
2359 /* This function builds a dwarf location descriptor sequence from a
2360 dw_cfa_location, adding the given OFFSET to the result of the
2363 struct dw_loc_descr_node
*
2364 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
2366 struct dw_loc_descr_node
*head
, *tmp
;
2368 offset
+= cfa
->offset
;
2372 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2373 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2374 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2375 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2376 add_loc_descr (&head
, tmp
);
2379 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
2380 add_loc_descr (&head
, tmp
);
2384 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2389 /* This function builds a dwarf location descriptor sequence for
2390 the address at OFFSET from the CFA when stack is aligned to
2393 struct dw_loc_descr_node
*
2394 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2395 HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
2397 struct dw_loc_descr_node
*head
;
2398 unsigned int dwarf_fp
2399 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2401 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2402 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2404 head
= new_reg_loc_descr (dwarf_fp
, 0);
2405 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2406 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2407 loc_descr_plus_const (&head
, offset
);
2410 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2414 /* And now, the support for symbolic debugging information. */
2416 /* .debug_str support. */
2417 static int output_indirect_string (void **, void *);
2419 static void dwarf2out_init (const char *);
2420 static void dwarf2out_finish (const char *);
2421 static void dwarf2out_assembly_start (void);
2422 static void dwarf2out_define (unsigned int, const char *);
2423 static void dwarf2out_undef (unsigned int, const char *);
2424 static void dwarf2out_start_source_file (unsigned, const char *);
2425 static void dwarf2out_end_source_file (unsigned);
2426 static void dwarf2out_function_decl (tree
);
2427 static void dwarf2out_begin_block (unsigned, unsigned);
2428 static void dwarf2out_end_block (unsigned, unsigned);
2429 static bool dwarf2out_ignore_block (const_tree
);
2430 static void dwarf2out_global_decl (tree
);
2431 static void dwarf2out_type_decl (tree
, int);
2432 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool);
2433 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2435 static void dwarf2out_abstract_function (tree
);
2436 static void dwarf2out_var_location (rtx
);
2437 static void dwarf2out_begin_function (tree
);
2438 static void dwarf2out_end_function (unsigned int);
2439 static void dwarf2out_set_name (tree
, tree
);
2441 /* The debug hooks structure. */
2443 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2447 dwarf2out_assembly_start
,
2450 dwarf2out_start_source_file
,
2451 dwarf2out_end_source_file
,
2452 dwarf2out_begin_block
,
2453 dwarf2out_end_block
,
2454 dwarf2out_ignore_block
,
2455 dwarf2out_source_line
,
2456 dwarf2out_begin_prologue
,
2457 #if VMS_DEBUGGING_INFO
2458 dwarf2out_vms_end_prologue
,
2459 dwarf2out_vms_begin_epilogue
,
2461 debug_nothing_int_charstar
,
2462 debug_nothing_int_charstar
,
2464 dwarf2out_end_epilogue
,
2465 dwarf2out_begin_function
,
2466 dwarf2out_end_function
, /* end_function */
2467 dwarf2out_function_decl
, /* function_decl */
2468 dwarf2out_global_decl
,
2469 dwarf2out_type_decl
, /* type_decl */
2470 dwarf2out_imported_module_or_decl
,
2471 debug_nothing_tree
, /* deferred_inline_function */
2472 /* The DWARF 2 backend tries to reduce debugging bloat by not
2473 emitting the abstract description of inline functions until
2474 something tries to reference them. */
2475 dwarf2out_abstract_function
, /* outlining_inline_function */
2476 debug_nothing_rtx
, /* label */
2477 debug_nothing_int
, /* handle_pch */
2478 dwarf2out_var_location
,
2479 dwarf2out_switch_text_section
,
2481 1, /* start_end_main_source_file */
2482 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2485 /* NOTE: In the comments in this file, many references are made to
2486 "Debugging Information Entries". This term is abbreviated as `DIE'
2487 throughout the remainder of this file. */
2489 /* An internal representation of the DWARF output is built, and then
2490 walked to generate the DWARF debugging info. The walk of the internal
2491 representation is done after the entire program has been compiled.
2492 The types below are used to describe the internal representation. */
2494 /* Whether to put type DIEs into their own section .debug_types instead
2495 of making them part of the .debug_info section. Only supported for
2496 Dwarf V4 or higher and the user didn't disable them through
2497 -fno-debug-types-section. It is more efficient to put them in a
2498 separate comdat sections since the linker will then be able to
2499 remove duplicates. But not all tools support .debug_types sections
2502 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2504 /* Various DIE's use offsets relative to the beginning of the
2505 .debug_info section to refer to each other. */
2507 typedef long int dw_offset
;
2509 /* Define typedefs here to avoid circular dependencies. */
2511 typedef struct dw_attr_struct
*dw_attr_ref
;
2512 typedef struct dw_line_info_struct
*dw_line_info_ref
;
2513 typedef struct pubname_struct
*pubname_ref
;
2514 typedef struct dw_ranges_struct
*dw_ranges_ref
;
2515 typedef struct dw_ranges_by_label_struct
*dw_ranges_by_label_ref
;
2516 typedef struct comdat_type_struct
*comdat_type_node_ref
;
2518 /* The entries in the line_info table more-or-less mirror the opcodes
2519 that are used in the real dwarf line table. Arrays of these entries
2520 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2523 enum dw_line_info_opcode
{
2524 /* Emit DW_LNE_set_address; the operand is the label index. */
2527 /* Emit a row to the matrix with the given line. This may be done
2528 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2532 /* Emit a DW_LNS_set_file. */
2535 /* Emit a DW_LNS_set_column. */
2538 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2541 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2542 LI_set_prologue_end
,
2543 LI_set_epilogue_begin
,
2545 /* Emit a DW_LNE_set_discriminator. */
2546 LI_set_discriminator
2549 typedef struct GTY(()) dw_line_info_struct
{
2550 enum dw_line_info_opcode opcode
;
2552 } dw_line_info_entry
;
2555 typedef struct GTY(()) dw_line_info_table_struct
{
2556 /* The label that marks the end of this section. */
2557 const char *end_label
;
2559 /* The values for the last row of the matrix, as collected in the table.
2560 These are used to minimize the changes to the next row. */
2561 unsigned int file_num
;
2562 unsigned int line_num
;
2563 unsigned int column_num
;
2568 vec
<dw_line_info_entry
, va_gc
> *entries
;
2569 } dw_line_info_table
;
2571 typedef dw_line_info_table
*dw_line_info_table_p
;
2574 /* Each DIE attribute has a field specifying the attribute kind,
2575 a link to the next attribute in the chain, and an attribute value.
2576 Attributes are typically linked below the DIE they modify. */
2578 typedef struct GTY(()) dw_attr_struct
{
2579 enum dwarf_attribute dw_attr
;
2580 dw_val_node dw_attr_val
;
2585 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2586 The children of each node form a circular list linked by
2587 die_sib. die_child points to the node *before* the "first" child node. */
2589 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct
{
2590 union die_symbol_or_type_node
2592 const char * GTY ((tag ("0"))) die_symbol
;
2593 comdat_type_node_ref
GTY ((tag ("1"))) die_type_node
;
2595 GTY ((desc ("%0.comdat_type_p"))) die_id
;
2596 vec
<dw_attr_node
, va_gc
> *die_attr
;
2597 dw_die_ref die_parent
;
2598 dw_die_ref die_child
;
2600 dw_die_ref die_definition
; /* ref from a specification to its definition */
2601 dw_offset die_offset
;
2602 unsigned long die_abbrev
;
2604 unsigned int decl_id
;
2605 enum dwarf_tag die_tag
;
2606 /* Die is used and must not be pruned as unused. */
2607 BOOL_BITFIELD die_perennial_p
: 1;
2608 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
2609 /* Lots of spare bits. */
2613 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2614 #define FOR_EACH_CHILD(die, c, expr) do { \
2615 c = die->die_child; \
2619 } while (c != die->die_child); \
2622 /* The pubname structure */
2624 typedef struct GTY(()) pubname_struct
{
2631 struct GTY(()) dw_ranges_struct
{
2632 /* If this is positive, it's a block number, otherwise it's a
2633 bitwise-negated index into dw_ranges_by_label. */
2637 /* A structure to hold a macinfo entry. */
2639 typedef struct GTY(()) macinfo_struct
{
2641 unsigned HOST_WIDE_INT lineno
;
2647 struct GTY(()) dw_ranges_by_label_struct
{
2652 /* The comdat type node structure. */
2653 typedef struct GTY(()) comdat_type_struct
2655 dw_die_ref root_die
;
2656 dw_die_ref type_die
;
2657 dw_die_ref skeleton_die
;
2658 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
2659 struct comdat_type_struct
*next
;
2663 /* The limbo die list structure. */
2664 typedef struct GTY(()) limbo_die_struct
{
2667 struct limbo_die_struct
*next
;
2671 typedef struct skeleton_chain_struct
2675 struct skeleton_chain_struct
*parent
;
2677 skeleton_chain_node
;
2679 /* Define a macro which returns nonzero for a TYPE_DECL which was
2680 implicitly generated for a type.
2682 Note that, unlike the C front-end (which generates a NULL named
2683 TYPE_DECL node for each complete tagged type, each array type,
2684 and each function type node created) the C++ front-end generates
2685 a _named_ TYPE_DECL node for each tagged type node created.
2686 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2687 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2688 front-end, but for each type, tagged or not. */
2690 #define TYPE_DECL_IS_STUB(decl) \
2691 (DECL_NAME (decl) == NULL_TREE \
2692 || (DECL_ARTIFICIAL (decl) \
2693 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2694 /* This is necessary for stub decls that \
2695 appear in nested inline functions. */ \
2696 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2697 && (decl_ultimate_origin (decl) \
2698 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2700 /* Information concerning the compilation unit's programming
2701 language, and compiler version. */
2703 /* Fixed size portion of the DWARF compilation unit header. */
2704 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2705 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2707 /* Fixed size portion of the DWARF comdat type unit header. */
2708 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2709 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2710 + DWARF_OFFSET_SIZE)
2712 /* Fixed size portion of public names info. */
2713 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2715 /* Fixed size portion of the address range info. */
2716 #define DWARF_ARANGES_HEADER_SIZE \
2717 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2718 DWARF2_ADDR_SIZE * 2) \
2719 - DWARF_INITIAL_LENGTH_SIZE)
2721 /* Size of padding portion in the address range info. It must be
2722 aligned to twice the pointer size. */
2723 #define DWARF_ARANGES_PAD_SIZE \
2724 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2725 DWARF2_ADDR_SIZE * 2) \
2726 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2728 /* Use assembler line directives if available. */
2729 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2730 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2731 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2733 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2737 /* Minimum line offset in a special line info. opcode.
2738 This value was chosen to give a reasonable range of values. */
2739 #define DWARF_LINE_BASE -10
2741 /* First special line opcode - leave room for the standard opcodes. */
2742 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2744 /* Range of line offsets in a special line info. opcode. */
2745 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2747 /* Flag that indicates the initial value of the is_stmt_start flag.
2748 In the present implementation, we do not mark any lines as
2749 the beginning of a source statement, because that information
2750 is not made available by the GCC front-end. */
2751 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2753 /* Maximum number of operations per instruction bundle. */
2754 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2755 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2758 /* This location is used by calc_die_sizes() to keep track
2759 the offset of each DIE within the .debug_info section. */
2760 static unsigned long next_die_offset
;
2762 /* Record the root of the DIE's built for the current compilation unit. */
2763 static GTY(()) dw_die_ref single_comp_unit_die
;
2765 /* A list of type DIEs that have been separated into comdat sections. */
2766 static GTY(()) comdat_type_node
*comdat_type_list
;
2768 /* A list of DIEs with a NULL parent waiting to be relocated. */
2769 static GTY(()) limbo_die_node
*limbo_die_list
;
2771 /* A list of DIEs for which we may have to generate
2772 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2773 static GTY(()) limbo_die_node
*deferred_asm_name
;
2775 /* Filenames referenced by this compilation unit. */
2776 static GTY((param_is (struct dwarf_file_data
))) htab_t file_table
;
2778 /* A hash table of references to DIE's that describe declarations.
2779 The key is a DECL_UID() which is a unique number identifying each decl. */
2780 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
2782 /* A hash table of references to DIE's that describe COMMON blocks.
2783 The key is DECL_UID() ^ die_parent. */
2784 static GTY ((param_is (struct die_struct
))) htab_t common_block_die_table
;
2786 typedef struct GTY(()) die_arg_entry_struct
{
2792 /* Node of the variable location list. */
2793 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
2794 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2795 EXPR_LIST chain. For small bitsizes, bitsize is encoded
2796 in mode of the EXPR_LIST node and first EXPR_LIST operand
2797 is either NOTE_INSN_VAR_LOCATION for a piece with a known
2798 location or NULL for padding. For larger bitsizes,
2799 mode is 0 and first operand is a CONCAT with bitsize
2800 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2801 NULL as second operand. */
2803 const char * GTY (()) label
;
2804 struct var_loc_node
* GTY (()) next
;
2807 /* Variable location list. */
2808 struct GTY (()) var_loc_list_def
{
2809 struct var_loc_node
* GTY (()) first
;
2811 /* Pointer to the last but one or last element of the
2812 chained list. If the list is empty, both first and
2813 last are NULL, if the list contains just one node
2814 or the last node certainly is not redundant, it points
2815 to the last node, otherwise points to the last but one.
2816 Do not mark it for GC because it is marked through the chain. */
2817 struct var_loc_node
* GTY ((skip ("%h"))) last
;
2819 /* Pointer to the last element before section switch,
2820 if NULL, either sections weren't switched or first
2821 is after section switch. */
2822 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
2824 /* DECL_UID of the variable decl. */
2825 unsigned int decl_id
;
2827 typedef struct var_loc_list_def var_loc_list
;
2829 /* Call argument location list. */
2830 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
2831 rtx
GTY (()) call_arg_loc_note
;
2832 const char * GTY (()) label
;
2833 tree
GTY (()) block
;
2835 rtx
GTY (()) symbol_ref
;
2836 struct call_arg_loc_node
* GTY (()) next
;
2840 /* Table of decl location linked lists. */
2841 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
2843 /* Head and tail of call_arg_loc chain. */
2844 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
2845 static struct call_arg_loc_node
*call_arg_loc_last
;
2847 /* Number of call sites in the current function. */
2848 static int call_site_count
= -1;
2849 /* Number of tail call sites in the current function. */
2850 static int tail_call_site_count
= -1;
2852 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
2854 static vec
<dw_die_ref
> block_map
;
2856 /* A cached location list. */
2857 struct GTY (()) cached_dw_loc_list_def
{
2858 /* The DECL_UID of the decl that this entry describes. */
2859 unsigned int decl_id
;
2861 /* The cached location list. */
2862 dw_loc_list_ref loc_list
;
2864 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
2866 /* Table of cached location lists. */
2867 static GTY ((param_is (cached_dw_loc_list
))) htab_t cached_dw_loc_list_table
;
2869 /* A pointer to the base of a list of references to DIE's that
2870 are uniquely identified by their tag, presence/absence of
2871 children DIE's, and list of attribute/value pairs. */
2872 static GTY((length ("abbrev_die_table_allocated")))
2873 dw_die_ref
*abbrev_die_table
;
2875 /* Number of elements currently allocated for abbrev_die_table. */
2876 static GTY(()) unsigned abbrev_die_table_allocated
;
2878 /* Number of elements in type_die_table currently in use. */
2879 static GTY(()) unsigned abbrev_die_table_in_use
;
2881 /* Size (in elements) of increments by which we may expand the
2882 abbrev_die_table. */
2883 #define ABBREV_DIE_TABLE_INCREMENT 256
2885 /* A global counter for generating labels for line number data. */
2886 static unsigned int line_info_label_num
;
2888 /* The current table to which we should emit line number information
2889 for the current function. This will be set up at the beginning of
2890 assembly for the function. */
2891 static dw_line_info_table
*cur_line_info_table
;
2893 /* The two default tables of line number info. */
2894 static GTY(()) dw_line_info_table
*text_section_line_info
;
2895 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
2897 /* The set of all non-default tables of line number info. */
2898 static GTY(()) vec
<dw_line_info_table_p
, va_gc
> *separate_line_info
;
2900 /* A flag to tell pubnames/types export if there is an info section to
2902 static bool info_section_emitted
;
2904 /* A pointer to the base of a table that contains a list of publicly
2905 accessible names. */
2906 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
2908 /* A pointer to the base of a table that contains a list of publicly
2909 accessible types. */
2910 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
2912 /* A pointer to the base of a table that contains a list of macro
2913 defines/undefines (and file start/end markers). */
2914 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
2916 /* True if .debug_macinfo or .debug_macros section is going to be
2918 #define have_macinfo \
2919 (debug_info_level >= DINFO_LEVEL_VERBOSE \
2920 && !macinfo_table->is_empty ())
2922 /* Array of dies for which we should generate .debug_ranges info. */
2923 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
2925 /* Number of elements currently allocated for ranges_table. */
2926 static GTY(()) unsigned ranges_table_allocated
;
2928 /* Number of elements in ranges_table currently in use. */
2929 static GTY(()) unsigned ranges_table_in_use
;
2931 /* Array of pairs of labels referenced in ranges_table. */
2932 static GTY ((length ("ranges_by_label_allocated")))
2933 dw_ranges_by_label_ref ranges_by_label
;
2935 /* Number of elements currently allocated for ranges_by_label. */
2936 static GTY(()) unsigned ranges_by_label_allocated
;
2938 /* Number of elements in ranges_by_label currently in use. */
2939 static GTY(()) unsigned ranges_by_label_in_use
;
2941 /* Size (in elements) of increments by which we may expand the
2943 #define RANGES_TABLE_INCREMENT 64
2945 /* Whether we have location lists that need outputting */
2946 static GTY(()) bool have_location_lists
;
2948 /* Unique label counter. */
2949 static GTY(()) unsigned int loclabel_num
;
2951 /* Unique label counter for point-of-call tables. */
2952 static GTY(()) unsigned int poc_label_num
;
2954 /* Record whether the function being analyzed contains inlined functions. */
2955 static int current_function_has_inlines
;
2957 /* The last file entry emitted by maybe_emit_file(). */
2958 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
2960 /* Number of internal labels generated by gen_internal_sym(). */
2961 static GTY(()) int label_num
;
2963 /* Cached result of previous call to lookup_filename. */
2964 static GTY(()) struct dwarf_file_data
* file_table_last_lookup
;
2966 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
2968 /* Instances of generic types for which we need to generate debug
2969 info that describe their generic parameters and arguments. That
2970 generation needs to happen once all types are properly laid out so
2971 we do it at the end of compilation. */
2972 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
2974 /* Offset from the "steady-state frame pointer" to the frame base,
2975 within the current function. */
2976 static HOST_WIDE_INT frame_pointer_fb_offset
;
2977 static bool frame_pointer_fb_offset_valid
;
2979 static vec
<dw_die_ref
> base_types
;
2981 /* Forward declarations for functions defined in this file. */
2983 static int is_pseudo_reg (const_rtx
);
2984 static tree
type_main_variant (tree
);
2985 static int is_tagged_type (const_tree
);
2986 static const char *dwarf_tag_name (unsigned);
2987 static const char *dwarf_attr_name (unsigned);
2988 static const char *dwarf_form_name (unsigned);
2989 static tree
decl_ultimate_origin (const_tree
);
2990 static tree
decl_class_context (tree
);
2991 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
2992 static inline enum dw_val_class
AT_class (dw_attr_ref
);
2993 static inline unsigned int AT_index (dw_attr_ref
);
2994 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
2995 static inline unsigned AT_flag (dw_attr_ref
);
2996 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
2997 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
2998 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
2999 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
3000 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3001 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3002 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3003 unsigned int, unsigned char *);
3004 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3005 static hashval_t
debug_str_do_hash (const void *);
3006 static int debug_str_eq (const void *, const void *);
3007 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3008 static inline const char *AT_string (dw_attr_ref
);
3009 static enum dwarf_form
AT_string_form (dw_attr_ref
);
3010 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3011 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3012 static inline dw_die_ref
AT_ref (dw_attr_ref
);
3013 static inline int AT_ref_external (dw_attr_ref
);
3014 static inline void set_AT_ref_external (dw_attr_ref
, int);
3015 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3016 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3017 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
3018 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3020 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
3021 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3022 static void remove_addr_table_entry (addr_table_entry
*);
3023 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3024 static inline rtx
AT_addr (dw_attr_ref
);
3025 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3026 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3027 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3028 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3029 unsigned HOST_WIDE_INT
);
3030 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3031 unsigned long, bool);
3032 static inline const char *AT_lbl (dw_attr_ref
);
3033 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
3034 static const char *get_AT_low_pc (dw_die_ref
);
3035 static const char *get_AT_hi_pc (dw_die_ref
);
3036 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3037 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3038 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3039 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3040 static bool is_cxx (void);
3041 static bool is_fortran (void);
3042 static bool is_ada (void);
3043 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
3044 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3045 static void add_child_die (dw_die_ref
, dw_die_ref
);
3046 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3047 static dw_die_ref
lookup_type_die (tree
);
3048 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3049 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3050 static void equate_type_number_to_die (tree
, dw_die_ref
);
3051 static hashval_t
decl_die_table_hash (const void *);
3052 static int decl_die_table_eq (const void *, const void *);
3053 static dw_die_ref
lookup_decl_die (tree
);
3054 static hashval_t
common_block_die_table_hash (const void *);
3055 static int common_block_die_table_eq (const void *, const void *);
3056 static hashval_t
decl_loc_table_hash (const void *);
3057 static int decl_loc_table_eq (const void *, const void *);
3058 static var_loc_list
*lookup_decl_loc (const_tree
);
3059 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3060 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *);
3061 static void print_spaces (FILE *);
3062 static void print_die (dw_die_ref
, FILE *);
3063 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
3064 static dw_die_ref
pop_compile_unit (dw_die_ref
);
3065 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3066 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
3067 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3068 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3069 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3070 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3071 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_ref
,
3072 struct md5_ctx
*, int *);
3073 struct checksum_attributes
;
3074 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3075 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3076 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3077 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3078 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3079 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3080 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
3081 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3082 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
3083 static void compute_section_prefix (dw_die_ref
);
3084 static int is_type_die (dw_die_ref
);
3085 static int is_comdat_die (dw_die_ref
);
3086 static int is_symbol_die (dw_die_ref
);
3087 static inline bool is_template_instantiation (dw_die_ref
);
3088 static void assign_symbol_names (dw_die_ref
);
3089 static void break_out_includes (dw_die_ref
);
3090 static int is_declaration_die (dw_die_ref
);
3091 static int should_move_die_to_comdat (dw_die_ref
);
3092 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3093 static dw_die_ref
clone_die (dw_die_ref
);
3094 static dw_die_ref
clone_tree (dw_die_ref
);
3095 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3096 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3097 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3098 static dw_die_ref
generate_skeleton (dw_die_ref
);
3099 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3102 static void break_out_comdat_types (dw_die_ref
);
3103 static void copy_decls_for_unworthy_types (dw_die_ref
);
3105 static void add_sibling_attributes (dw_die_ref
);
3106 static void output_location_lists (dw_die_ref
);
3107 static int constant_size (unsigned HOST_WIDE_INT
);
3108 static unsigned long size_of_die (dw_die_ref
);
3109 static void calc_die_sizes (dw_die_ref
);
3110 static void calc_base_type_die_sizes (void);
3111 static void mark_dies (dw_die_ref
);
3112 static void unmark_dies (dw_die_ref
);
3113 static void unmark_all_dies (dw_die_ref
);
3114 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3115 static unsigned long size_of_aranges (void);
3116 static enum dwarf_form
value_format (dw_attr_ref
);
3117 static void output_value_format (dw_attr_ref
);
3118 static void output_abbrev_section (void);
3119 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3120 static void output_die_symbol (dw_die_ref
);
3121 static void output_die (dw_die_ref
);
3122 static void output_compilation_unit_header (void);
3123 static void output_comp_unit (dw_die_ref
, int);
3124 static void output_comdat_type_unit (comdat_type_node
*);
3125 static const char *dwarf2_name (tree
, int);
3126 static void add_pubname (tree
, dw_die_ref
);
3127 static void add_enumerator_pubname (const char *, dw_die_ref
);
3128 static void add_pubname_string (const char *, dw_die_ref
);
3129 static void add_pubtype (tree
, dw_die_ref
);
3130 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3131 static void output_aranges (unsigned long);
3132 static unsigned int add_ranges_num (int);
3133 static unsigned int add_ranges (const_tree
);
3134 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3136 static void output_ranges (void);
3137 static dw_line_info_table
*new_line_info_table (void);
3138 static void output_line_info (bool);
3139 static void output_file_names (void);
3140 static dw_die_ref
base_type_die (tree
);
3141 static int is_base_type (tree
);
3142 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, dw_die_ref
);
3143 static dw_die_ref
modified_type_die (tree
, int, int, dw_die_ref
);
3144 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3145 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3146 static int type_is_enum (const_tree
);
3147 static unsigned int dbx_reg_number (const_rtx
);
3148 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3149 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3150 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3151 enum var_init_status
);
3152 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3153 enum var_init_status
);
3154 static dw_loc_descr_ref
based_loc_descr (rtx
, HOST_WIDE_INT
,
3155 enum var_init_status
);
3156 static int is_based_loc (const_rtx
);
3157 static int resolve_one_addr (rtx
*, void *);
3158 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3159 enum var_init_status
);
3160 static dw_loc_descr_ref
loc_descriptor (rtx
, enum machine_mode mode
,
3161 enum var_init_status
);
3162 static dw_loc_list_ref
loc_list_from_tree (tree
, int);
3163 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int);
3164 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3165 static tree
field_type (const_tree
);
3166 static unsigned int simple_type_align_in_bits (const_tree
);
3167 static unsigned int simple_decl_align_in_bits (const_tree
);
3168 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3169 static HOST_WIDE_INT
field_byte_offset (const_tree
);
3170 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3172 static void add_data_member_location_attribute (dw_die_ref
, tree
);
3173 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3174 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3175 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3176 static void insert_float (const_rtx
, unsigned char *);
3177 static rtx
rtl_for_decl_location (tree
);
3178 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool,
3179 enum dwarf_attribute
);
3180 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3181 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3182 static void add_name_attribute (dw_die_ref
, const char *);
3183 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3184 static void add_comp_dir_attribute (dw_die_ref
);
3185 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
3186 static void add_subscript_info (dw_die_ref
, tree
, bool);
3187 static void add_byte_size_attribute (dw_die_ref
, tree
);
3188 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3189 static void add_bit_size_attribute (dw_die_ref
, tree
);
3190 static void add_prototyped_attribute (dw_die_ref
, tree
);
3191 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3192 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3193 static void add_src_coords_attributes (dw_die_ref
, tree
);
3194 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
3195 static void push_decl_scope (tree
);
3196 static void pop_decl_scope (void);
3197 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3198 static inline int local_scope_p (dw_die_ref
);
3199 static inline int class_scope_p (dw_die_ref
);
3200 static inline int class_or_namespace_scope_p (dw_die_ref
);
3201 static void add_type_attribute (dw_die_ref
, tree
, int, int, dw_die_ref
);
3202 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3203 static const char *type_tag (const_tree
);
3204 static tree
member_declared_type (const_tree
);
3206 static const char *decl_start_label (tree
);
3208 static void gen_array_type_die (tree
, dw_die_ref
);
3209 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3211 static void gen_entry_point_die (tree
, dw_die_ref
);
3213 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3214 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3215 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3216 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3217 static void gen_formal_types_die (tree
, dw_die_ref
);
3218 static void gen_subprogram_die (tree
, dw_die_ref
);
3219 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3220 static void gen_const_die (tree
, dw_die_ref
);
3221 static void gen_label_die (tree
, dw_die_ref
);
3222 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
3223 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
3224 static void gen_field_die (tree
, dw_die_ref
);
3225 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3226 static dw_die_ref
gen_compile_unit_die (const char *);
3227 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
3228 static void gen_member_die (tree
, dw_die_ref
);
3229 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3230 enum debug_info_usage
);
3231 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3232 static void gen_typedef_die (tree
, dw_die_ref
);
3233 static void gen_type_die (tree
, dw_die_ref
);
3234 static void gen_block_die (tree
, dw_die_ref
, int);
3235 static void decls_for_scope (tree
, dw_die_ref
, int);
3236 static inline int is_redundant_typedef (const_tree
);
3237 static bool is_naming_typedef_decl (const_tree
);
3238 static inline dw_die_ref
get_context_die (tree
);
3239 static void gen_namespace_die (tree
, dw_die_ref
);
3240 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3241 static dw_die_ref
gen_decl_die (tree
, tree
, dw_die_ref
);
3242 static dw_die_ref
force_decl_die (tree
);
3243 static dw_die_ref
force_type_die (tree
);
3244 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3245 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3246 static struct dwarf_file_data
* lookup_filename (const char *);
3247 static void retry_incomplete_types (void);
3248 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3249 static void gen_generic_params_dies (tree
);
3250 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3251 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3252 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3253 static int file_info_cmp (const void *, const void *);
3254 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3255 const char *, const char *);
3256 static void output_loc_list (dw_loc_list_ref
);
3257 static char *gen_internal_sym (const char *);
3258 static bool want_pubnames (void);
3260 static void prune_unmark_dies (dw_die_ref
);
3261 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3262 static void prune_unused_types_mark (dw_die_ref
, int);
3263 static void prune_unused_types_walk (dw_die_ref
);
3264 static void prune_unused_types_walk_attribs (dw_die_ref
);
3265 static void prune_unused_types_prune (dw_die_ref
);
3266 static void prune_unused_types (void);
3267 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3268 static inline const char *AT_vms_delta1 (dw_attr_ref
);
3269 static inline const char *AT_vms_delta2 (dw_attr_ref
);
3270 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3271 const char *, const char *);
3272 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3273 static void gen_remaining_tmpl_value_param_die_attribute (void);
3274 static bool generic_type_p (tree
);
3275 static void schedule_generic_params_dies_gen (tree t
);
3276 static void gen_scheduled_generic_parms_dies (void);
3278 static const char *comp_dir_string (void);
3280 static hashval_t
hash_loc_operands (dw_loc_descr_ref
, hashval_t
);
3282 /* enum for tracking thread-local variables whose address is really an offset
3283 relative to the TLS pointer, which will need link-time relocation, but will
3284 not need relocation by the DWARF consumer. */
3292 /* Return the operator to use for an address of a variable. For dtprel_true, we
3293 use DW_OP_const*. For regular variables, which need both link-time
3294 relocation and consumer-level relocation (e.g., to account for shared objects
3295 loaded at a random address), we use DW_OP_addr*. */
3297 static inline enum dwarf_location_atom
3298 dw_addr_op (enum dtprel_bool dtprel
)
3300 if (dtprel
== dtprel_true
)
3301 return (dwarf_split_debug_info
? DW_OP_GNU_const_index
3302 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3304 return dwarf_split_debug_info
? DW_OP_GNU_addr_index
: DW_OP_addr
;
3307 /* Return a pointer to a newly allocated address location description. If
3308 dwarf_split_debug_info is true, then record the address with the appropriate
3310 static inline dw_loc_descr_ref
3311 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3313 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3315 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3316 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3317 ref
->dtprel
= dtprel
;
3318 if (dwarf_split_debug_info
)
3319 ref
->dw_loc_oprnd1
.val_entry
3320 = add_addr_table_entry (addr
,
3321 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3323 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3328 /* Section names used to hold DWARF debugging information. */
3330 #ifndef DEBUG_INFO_SECTION
3331 #define DEBUG_INFO_SECTION ".debug_info"
3333 #ifndef DEBUG_DWO_INFO_SECTION
3334 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3336 #ifndef DEBUG_ABBREV_SECTION
3337 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3339 #ifndef DEBUG_DWO_ABBREV_SECTION
3340 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3342 #ifndef DEBUG_ARANGES_SECTION
3343 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3345 #ifndef DEBUG_ADDR_SECTION
3346 #define DEBUG_ADDR_SECTION ".debug_addr"
3348 #ifndef DEBUG_NORM_MACINFO_SECTION
3349 #define DEBUG_NORM_MACINFO_SECTION ".debug_macinfo"
3351 #ifndef DEBUG_DWO_MACINFO_SECTION
3352 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3354 #ifndef DEBUG_MACINFO_SECTION
3355 #define DEBUG_MACINFO_SECTION \
3356 (!dwarf_split_debug_info \
3357 ? (DEBUG_NORM_MACINFO_SECTION) : (DEBUG_DWO_MACINFO_SECTION))
3359 #ifndef DEBUG_NORM_MACRO_SECTION
3360 #define DEBUG_NORM_MACRO_SECTION ".debug_macro"
3362 #ifndef DEBUG_DWO_MACRO_SECTION
3363 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3365 #ifndef DEBUG_MACRO_SECTION
3366 #define DEBUG_MACRO_SECTION \
3367 (!dwarf_split_debug_info \
3368 ? (DEBUG_NORM_MACRO_SECTION) : (DEBUG_DWO_MACRO_SECTION))
3370 #ifndef DEBUG_LINE_SECTION
3371 #define DEBUG_LINE_SECTION ".debug_line"
3373 #ifndef DEBUG_DWO_LINE_SECTION
3374 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3376 #ifndef DEBUG_LOC_SECTION
3377 #define DEBUG_LOC_SECTION ".debug_loc"
3379 #ifndef DEBUG_DWO_LOC_SECTION
3380 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3382 #ifndef DEBUG_PUBNAMES_SECTION
3383 #define DEBUG_PUBNAMES_SECTION \
3384 ((debug_generate_pub_sections == 2) \
3385 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3387 #ifndef DEBUG_PUBTYPES_SECTION
3388 #define DEBUG_PUBTYPES_SECTION \
3389 ((debug_generate_pub_sections == 2) \
3390 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3392 #define DEBUG_NORM_STR_OFFSETS_SECTION ".debug_str_offsets"
3393 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3394 #ifndef DEBUG_STR_OFFSETS_SECTION
3395 #define DEBUG_STR_OFFSETS_SECTION \
3396 (!dwarf_split_debug_info \
3397 ? (DEBUG_NORM_STR_OFFSETS_SECTION) : (DEBUG_DWO_STR_OFFSETS_SECTION))
3399 #ifndef DEBUG_STR_DWO_SECTION
3400 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3402 #ifndef DEBUG_STR_SECTION
3403 #define DEBUG_STR_SECTION ".debug_str"
3405 #ifndef DEBUG_RANGES_SECTION
3406 #define DEBUG_RANGES_SECTION ".debug_ranges"
3409 /* Standard ELF section names for compiled code and data. */
3410 #ifndef TEXT_SECTION_NAME
3411 #define TEXT_SECTION_NAME ".text"
3414 /* Section flags for .debug_macinfo/.debug_macro section. */
3415 #define DEBUG_MACRO_SECTION_FLAGS \
3416 (dwarf_split_debug_info ? SECTION_DEBUG | SECTION_EXCLUDE : SECTION_DEBUG)
3418 /* Section flags for .debug_str section. */
3419 #define DEBUG_STR_SECTION_FLAGS \
3420 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3421 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3424 /* Section flags for .debug_str.dwo section. */
3425 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3427 /* Labels we insert at beginning sections we can reference instead of
3428 the section names themselves. */
3430 #ifndef TEXT_SECTION_LABEL
3431 #define TEXT_SECTION_LABEL "Ltext"
3433 #ifndef COLD_TEXT_SECTION_LABEL
3434 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3436 #ifndef DEBUG_LINE_SECTION_LABEL
3437 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3439 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3440 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3442 #ifndef DEBUG_INFO_SECTION_LABEL
3443 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3445 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3446 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3448 #ifndef DEBUG_ABBREV_SECTION_LABEL
3449 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3451 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3452 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3454 #ifndef DEBUG_ADDR_SECTION_LABEL
3455 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3457 #ifndef DEBUG_LOC_SECTION_LABEL
3458 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3460 #ifndef DEBUG_RANGES_SECTION_LABEL
3461 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3463 #ifndef DEBUG_MACINFO_SECTION_LABEL
3464 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3466 #ifndef DEBUG_MACRO_SECTION_LABEL
3467 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3469 #define SKELETON_COMP_DIE_ABBREV 1
3470 #define SKELETON_TYPE_DIE_ABBREV 2
3472 /* Definitions of defaults for formats and names of various special
3473 (artificial) labels which may be generated within this file (when the -g
3474 options is used and DWARF2_DEBUGGING_INFO is in effect.
3475 If necessary, these may be overridden from within the tm.h file, but
3476 typically, overriding these defaults is unnecessary. */
3478 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3479 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3480 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3481 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3482 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3483 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3484 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3485 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3486 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3487 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3488 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3489 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3490 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3491 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3493 #ifndef TEXT_END_LABEL
3494 #define TEXT_END_LABEL "Letext"
3496 #ifndef COLD_END_LABEL
3497 #define COLD_END_LABEL "Letext_cold"
3499 #ifndef BLOCK_BEGIN_LABEL
3500 #define BLOCK_BEGIN_LABEL "LBB"
3502 #ifndef BLOCK_END_LABEL
3503 #define BLOCK_END_LABEL "LBE"
3505 #ifndef LINE_CODE_LABEL
3506 #define LINE_CODE_LABEL "LM"
3510 /* Return the root of the DIE's built for the current compilation unit. */
3512 comp_unit_die (void)
3514 if (!single_comp_unit_die
)
3515 single_comp_unit_die
= gen_compile_unit_die (NULL
);
3516 return single_comp_unit_die
;
3519 /* We allow a language front-end to designate a function that is to be
3520 called to "demangle" any name before it is put into a DIE. */
3522 static const char *(*demangle_name_func
) (const char *);
3525 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3527 demangle_name_func
= func
;
3530 /* Test if rtl node points to a pseudo register. */
3533 is_pseudo_reg (const_rtx rtl
)
3535 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3536 || (GET_CODE (rtl
) == SUBREG
3537 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3540 /* Return a reference to a type, with its const and volatile qualifiers
3544 type_main_variant (tree type
)
3546 type
= TYPE_MAIN_VARIANT (type
);
3548 /* ??? There really should be only one main variant among any group of
3549 variants of a given type (and all of the MAIN_VARIANT values for all
3550 members of the group should point to that one type) but sometimes the C
3551 front-end messes this up for array types, so we work around that bug
3553 if (TREE_CODE (type
) == ARRAY_TYPE
)
3554 while (type
!= TYPE_MAIN_VARIANT (type
))
3555 type
= TYPE_MAIN_VARIANT (type
);
3560 /* Return nonzero if the given type node represents a tagged type. */
3563 is_tagged_type (const_tree type
)
3565 enum tree_code code
= TREE_CODE (type
);
3567 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
3568 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
3571 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3574 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
3576 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
3579 /* Return die_offset of a DIE reference to a base type. */
3581 static unsigned long int
3582 get_base_type_offset (dw_die_ref ref
)
3584 if (ref
->die_offset
)
3585 return ref
->die_offset
;
3586 if (comp_unit_die ()->die_abbrev
)
3588 calc_base_type_die_sizes ();
3589 gcc_assert (ref
->die_offset
);
3591 return ref
->die_offset
;
3594 /* Return die_offset of a DIE reference other than base type. */
3596 static unsigned long int
3597 get_ref_die_offset (dw_die_ref ref
)
3599 gcc_assert (ref
->die_offset
);
3600 return ref
->die_offset
;
3603 /* Convert a DIE tag into its string name. */
3606 dwarf_tag_name (unsigned int tag
)
3608 const char *name
= get_DW_TAG_name (tag
);
3613 return "DW_TAG_<unknown>";
3616 /* Convert a DWARF attribute code into its string name. */
3619 dwarf_attr_name (unsigned int attr
)
3625 #if VMS_DEBUGGING_INFO
3626 case DW_AT_HP_prologue
:
3627 return "DW_AT_HP_prologue";
3629 case DW_AT_MIPS_loop_unroll_factor
:
3630 return "DW_AT_MIPS_loop_unroll_factor";
3633 #if VMS_DEBUGGING_INFO
3634 case DW_AT_HP_epilogue
:
3635 return "DW_AT_HP_epilogue";
3637 case DW_AT_MIPS_stride
:
3638 return "DW_AT_MIPS_stride";
3642 name
= get_DW_AT_name (attr
);
3647 return "DW_AT_<unknown>";
3650 /* Convert a DWARF value form code into its string name. */
3653 dwarf_form_name (unsigned int form
)
3655 const char *name
= get_DW_FORM_name (form
);
3660 return "DW_FORM_<unknown>";
3663 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3664 instance of an inlined instance of a decl which is local to an inline
3665 function, so we have to trace all of the way back through the origin chain
3666 to find out what sort of node actually served as the original seed for the
3670 decl_ultimate_origin (const_tree decl
)
3672 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
3675 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
3676 nodes in the function to point to themselves; ignore that if
3677 we're trying to output the abstract instance of this function. */
3678 if (DECL_ABSTRACT (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
3681 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3682 most distant ancestor, this should never happen. */
3683 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
3685 return DECL_ABSTRACT_ORIGIN (decl
);
3688 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3689 of a virtual function may refer to a base class, so we check the 'this'
3693 decl_class_context (tree decl
)
3695 tree context
= NULL_TREE
;
3697 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
3698 context
= DECL_CONTEXT (decl
);
3700 context
= TYPE_MAIN_VARIANT
3701 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
3703 if (context
&& !TYPE_P (context
))
3704 context
= NULL_TREE
;
3709 /* Add an attribute/value pair to a DIE. */
3712 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
3714 /* Maybe this should be an assert? */
3718 vec_safe_reserve (die
->die_attr
, 1);
3719 vec_safe_push (die
->die_attr
, *attr
);
3722 static inline enum dw_val_class
3723 AT_class (dw_attr_ref a
)
3725 return a
->dw_attr_val
.val_class
;
3728 /* Return the index for any attribute that will be referenced with a
3729 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
3730 are stored in dw_attr_val.v.val_str for reference counting
3733 static inline unsigned int
3734 AT_index (dw_attr_ref a
)
3736 if (AT_class (a
) == dw_val_class_str
)
3737 return a
->dw_attr_val
.v
.val_str
->index
;
3738 else if (a
->dw_attr_val
.val_entry
!= NULL
)
3739 return a
->dw_attr_val
.val_entry
->index
;
3743 /* Add a flag value attribute to a DIE. */
3746 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
3750 attr
.dw_attr
= attr_kind
;
3751 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
3752 attr
.dw_attr_val
.val_entry
= NULL
;
3753 attr
.dw_attr_val
.v
.val_flag
= flag
;
3754 add_dwarf_attr (die
, &attr
);
3757 static inline unsigned
3758 AT_flag (dw_attr_ref a
)
3760 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
3761 return a
->dw_attr_val
.v
.val_flag
;
3764 /* Add a signed integer attribute value to a DIE. */
3767 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
3771 attr
.dw_attr
= attr_kind
;
3772 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
3773 attr
.dw_attr_val
.val_entry
= NULL
;
3774 attr
.dw_attr_val
.v
.val_int
= int_val
;
3775 add_dwarf_attr (die
, &attr
);
3778 static inline HOST_WIDE_INT
3779 AT_int (dw_attr_ref a
)
3781 gcc_assert (a
&& AT_class (a
) == dw_val_class_const
);
3782 return a
->dw_attr_val
.v
.val_int
;
3785 /* Add an unsigned integer attribute value to a DIE. */
3788 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3789 unsigned HOST_WIDE_INT unsigned_val
)
3793 attr
.dw_attr
= attr_kind
;
3794 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
3795 attr
.dw_attr_val
.val_entry
= NULL
;
3796 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
3797 add_dwarf_attr (die
, &attr
);
3800 static inline unsigned HOST_WIDE_INT
3801 AT_unsigned (dw_attr_ref a
)
3803 gcc_assert (a
&& AT_class (a
) == dw_val_class_unsigned_const
);
3804 return a
->dw_attr_val
.v
.val_unsigned
;
3807 /* Add an unsigned wide integer attribute value to a DIE. */
3810 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3815 attr
.dw_attr
= attr_kind
;
3816 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
3817 attr
.dw_attr_val
.v
.val_wide
= ggc_cleared_alloc
<wide_int
> ();
3818 *attr
.dw_attr_val
.v
.val_wide
= w
;
3819 add_dwarf_attr (die
, &attr
);
3822 /* Add an unsigned double integer attribute value to a DIE. */
3825 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3826 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
3830 attr
.dw_attr
= attr_kind
;
3831 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
3832 attr
.dw_attr_val
.val_entry
= NULL
;
3833 attr
.dw_attr_val
.v
.val_double
.high
= high
;
3834 attr
.dw_attr_val
.v
.val_double
.low
= low
;
3835 add_dwarf_attr (die
, &attr
);
3838 /* Add a floating point attribute value to a DIE and return it. */
3841 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3842 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
3846 attr
.dw_attr
= attr_kind
;
3847 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
3848 attr
.dw_attr_val
.val_entry
= NULL
;
3849 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
3850 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
3851 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
3852 add_dwarf_attr (die
, &attr
);
3855 /* Add an 8-byte data attribute value to a DIE. */
3858 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3859 unsigned char data8
[8])
3863 attr
.dw_attr
= attr_kind
;
3864 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
3865 attr
.dw_attr_val
.val_entry
= NULL
;
3866 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
3867 add_dwarf_attr (die
, &attr
);
3870 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
3871 dwarf_split_debug_info, address attributes in dies destined for the
3872 final executable have force_direct set to avoid using indexed
3876 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
3882 lbl_id
= xstrdup (lbl_low
);
3883 attr
.dw_attr
= DW_AT_low_pc
;
3884 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
3885 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
3886 if (dwarf_split_debug_info
&& !force_direct
)
3887 attr
.dw_attr_val
.val_entry
3888 = add_addr_table_entry (lbl_id
, ate_kind_label
);
3890 attr
.dw_attr_val
.val_entry
= NULL
;
3891 add_dwarf_attr (die
, &attr
);
3893 attr
.dw_attr
= DW_AT_high_pc
;
3894 if (dwarf_version
< 4)
3895 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
3897 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
3898 lbl_id
= xstrdup (lbl_high
);
3899 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
3900 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
3901 && dwarf_split_debug_info
&& !force_direct
)
3902 attr
.dw_attr_val
.val_entry
3903 = add_addr_table_entry (lbl_id
, ate_kind_label
);
3905 attr
.dw_attr_val
.val_entry
= NULL
;
3906 add_dwarf_attr (die
, &attr
);
3909 /* Hash and equality functions for debug_str_hash. */
3912 debug_str_do_hash (const void *x
)
3914 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
3918 debug_str_eq (const void *x1
, const void *x2
)
3920 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
3921 (const char *)x2
) == 0;
3924 /* Add STR to the given string hash table. */
3926 static struct indirect_string_node
*
3927 find_AT_string_in_table (const char *str
, htab_t table
)
3929 struct indirect_string_node
*node
;
3932 slot
= htab_find_slot_with_hash (table
, str
,
3933 htab_hash_string (str
), INSERT
);
3936 node
= ggc_cleared_alloc
<indirect_string_node
> ();
3937 node
->str
= ggc_strdup (str
);
3941 node
= (struct indirect_string_node
*) *slot
;
3947 /* Add STR to the indirect string hash table. */
3949 static struct indirect_string_node
*
3950 find_AT_string (const char *str
)
3952 if (! debug_str_hash
)
3953 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
3954 debug_str_eq
, NULL
);
3956 return find_AT_string_in_table (str
, debug_str_hash
);
3959 /* Add a string attribute value to a DIE. */
3962 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
3965 struct indirect_string_node
*node
;
3967 node
= find_AT_string (str
);
3969 attr
.dw_attr
= attr_kind
;
3970 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
3971 attr
.dw_attr_val
.val_entry
= NULL
;
3972 attr
.dw_attr_val
.v
.val_str
= node
;
3973 add_dwarf_attr (die
, &attr
);
3976 static inline const char *
3977 AT_string (dw_attr_ref a
)
3979 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
3980 return a
->dw_attr_val
.v
.val_str
->str
;
3983 /* Call this function directly to bypass AT_string_form's logic to put
3984 the string inline in the die. */
3987 set_indirect_string (struct indirect_string_node
*node
)
3990 /* Already indirect is a no op. */
3991 if (node
->form
== DW_FORM_strp
|| node
->form
== DW_FORM_GNU_str_index
)
3993 gcc_assert (node
->label
);
3996 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
3997 ++dw2_string_counter
;
3998 node
->label
= xstrdup (label
);
4000 if (!dwarf_split_debug_info
)
4002 node
->form
= DW_FORM_strp
;
4003 node
->index
= NOT_INDEXED
;
4007 node
->form
= DW_FORM_GNU_str_index
;
4008 node
->index
= NO_INDEX_ASSIGNED
;
4012 /* Find out whether a string should be output inline in DIE
4013 or out-of-line in .debug_str section. */
4015 static enum dwarf_form
4016 find_string_form (struct indirect_string_node
*node
)
4023 len
= strlen (node
->str
) + 1;
4025 /* If the string is shorter or equal to the size of the reference, it is
4026 always better to put it inline. */
4027 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4028 return node
->form
= DW_FORM_string
;
4030 /* If we cannot expect the linker to merge strings in .debug_str
4031 section, only put it into .debug_str if it is worth even in this
4033 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4034 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4035 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4036 return node
->form
= DW_FORM_string
;
4038 set_indirect_string (node
);
4043 /* Find out whether the string referenced from the attribute should be
4044 output inline in DIE or out-of-line in .debug_str section. */
4046 static enum dwarf_form
4047 AT_string_form (dw_attr_ref a
)
4049 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4050 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4053 /* Add a DIE reference attribute value to a DIE. */
4056 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4060 #ifdef ENABLE_CHECKING
4061 gcc_assert (targ_die
!= NULL
);
4063 /* With LTO we can end up trying to reference something we didn't create
4064 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4065 if (targ_die
== NULL
)
4069 attr
.dw_attr
= attr_kind
;
4070 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4071 attr
.dw_attr_val
.val_entry
= NULL
;
4072 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4073 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4074 add_dwarf_attr (die
, &attr
);
4077 /* Change DIE reference REF to point to NEW_DIE instead. */
4080 change_AT_die_ref (dw_attr_ref ref
, dw_die_ref new_die
)
4082 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4083 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4084 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4087 /* Add an AT_specification attribute to a DIE, and also make the back
4088 pointer from the specification to the definition. */
4091 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4093 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4094 gcc_assert (!targ_die
->die_definition
);
4095 targ_die
->die_definition
= die
;
4098 static inline dw_die_ref
4099 AT_ref (dw_attr_ref a
)
4101 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4102 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4106 AT_ref_external (dw_attr_ref a
)
4108 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4109 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4115 set_AT_ref_external (dw_attr_ref a
, int i
)
4117 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4118 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4121 /* Add an FDE reference attribute value to a DIE. */
4124 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4128 attr
.dw_attr
= attr_kind
;
4129 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4130 attr
.dw_attr_val
.val_entry
= NULL
;
4131 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4132 add_dwarf_attr (die
, &attr
);
4135 /* Add a location description attribute value to a DIE. */
4138 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4142 attr
.dw_attr
= attr_kind
;
4143 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4144 attr
.dw_attr_val
.val_entry
= NULL
;
4145 attr
.dw_attr_val
.v
.val_loc
= loc
;
4146 add_dwarf_attr (die
, &attr
);
4149 static inline dw_loc_descr_ref
4150 AT_loc (dw_attr_ref a
)
4152 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4153 return a
->dw_attr_val
.v
.val_loc
;
4157 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4161 attr
.dw_attr
= attr_kind
;
4162 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4163 attr
.dw_attr_val
.val_entry
= NULL
;
4164 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4165 add_dwarf_attr (die
, &attr
);
4166 have_location_lists
= true;
4169 static inline dw_loc_list_ref
4170 AT_loc_list (dw_attr_ref a
)
4172 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4173 return a
->dw_attr_val
.v
.val_loc_list
;
4176 static inline dw_loc_list_ref
*
4177 AT_loc_list_ptr (dw_attr_ref a
)
4179 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4180 return &a
->dw_attr_val
.v
.val_loc_list
;
4183 /* Table of entries into the .debug_addr section. */
4185 static GTY ((param_is (addr_table_entry
))) htab_t addr_index_table
;
4187 /* Hash an address_table_entry. */
4190 addr_table_entry_do_hash (const void *x
)
4192 const addr_table_entry
*a
= (const addr_table_entry
*) x
;
4196 return iterative_hash_rtx (a
->addr
.rtl
, 0);
4197 case ate_kind_rtx_dtprel
:
4198 return iterative_hash_rtx (a
->addr
.rtl
, 1);
4199 case ate_kind_label
:
4200 return htab_hash_string (a
->addr
.label
);
4206 /* Determine equality for two address_table_entries. */
4209 addr_table_entry_eq (const void *x1
, const void *x2
)
4211 const addr_table_entry
*a1
= (const addr_table_entry
*) x1
;
4212 const addr_table_entry
*a2
= (const addr_table_entry
*) x2
;
4214 if (a1
->kind
!= a2
->kind
)
4219 case ate_kind_rtx_dtprel
:
4220 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4221 case ate_kind_label
:
4222 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
4228 /* Initialize an addr_table_entry. */
4231 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
4237 case ate_kind_rtx_dtprel
:
4238 e
->addr
.rtl
= (rtx
) addr
;
4240 case ate_kind_label
:
4241 e
->addr
.label
= (char *) addr
;
4245 e
->index
= NO_INDEX_ASSIGNED
;
4248 /* Add attr to the address table entry to the table. Defer setting an
4249 index until output time. */
4251 static addr_table_entry
*
4252 add_addr_table_entry (void *addr
, enum ate_kind kind
)
4254 addr_table_entry
*node
;
4255 addr_table_entry finder
;
4258 gcc_assert (dwarf_split_debug_info
);
4259 if (! addr_index_table
)
4260 addr_index_table
= htab_create_ggc (10, addr_table_entry_do_hash
,
4261 addr_table_entry_eq
, NULL
);
4262 init_addr_table_entry (&finder
, kind
, addr
);
4263 slot
= htab_find_slot (addr_index_table
, &finder
, INSERT
);
4265 if (*slot
== HTAB_EMPTY_ENTRY
)
4267 node
= ggc_cleared_alloc
<addr_table_entry
> ();
4268 init_addr_table_entry (node
, kind
, addr
);
4272 node
= (addr_table_entry
*) *slot
;
4278 /* Remove an entry from the addr table by decrementing its refcount.
4279 Strictly, decrementing the refcount would be enough, but the
4280 assertion that the entry is actually in the table has found
4284 remove_addr_table_entry (addr_table_entry
*entry
)
4286 addr_table_entry
*node
;
4288 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
4289 node
= (addr_table_entry
*) htab_find (addr_index_table
, entry
);
4290 /* After an index is assigned, the table is frozen. */
4291 gcc_assert (node
->refcount
> 0 && node
->index
== NO_INDEX_ASSIGNED
);
4295 /* Given a location list, remove all addresses it refers to from the
4299 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
4301 for (; descr
; descr
= descr
->dw_loc_next
)
4302 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
4304 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
4305 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
4309 /* A helper function for dwarf2out_finish called through
4310 htab_traverse. Assign an addr_table_entry its index. All entries
4311 must be collected into the table when this function is called,
4312 because the indexing code relies on htab_traverse to traverse nodes
4313 in the same order for each run. */
4316 index_addr_table_entry (void **h
, void *v
)
4318 addr_table_entry
*node
= (addr_table_entry
*) *h
;
4319 unsigned int *index
= (unsigned int *) v
;
4321 /* Don't index unreferenced nodes. */
4322 if (node
->refcount
== 0)
4325 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
4326 node
->index
= *index
;
4332 /* Add an address constant attribute value to a DIE. When using
4333 dwarf_split_debug_info, address attributes in dies destined for the
4334 final executable should be direct references--setting the parameter
4335 force_direct ensures this behavior. */
4338 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
4343 attr
.dw_attr
= attr_kind
;
4344 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
4345 attr
.dw_attr_val
.v
.val_addr
= addr
;
4346 if (dwarf_split_debug_info
&& !force_direct
)
4347 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
4349 attr
.dw_attr_val
.val_entry
= NULL
;
4350 add_dwarf_attr (die
, &attr
);
4353 /* Get the RTX from to an address DIE attribute. */
4356 AT_addr (dw_attr_ref a
)
4358 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
4359 return a
->dw_attr_val
.v
.val_addr
;
4362 /* Add a file attribute value to a DIE. */
4365 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4366 struct dwarf_file_data
*fd
)
4370 attr
.dw_attr
= attr_kind
;
4371 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
4372 attr
.dw_attr_val
.val_entry
= NULL
;
4373 attr
.dw_attr_val
.v
.val_file
= fd
;
4374 add_dwarf_attr (die
, &attr
);
4377 /* Get the dwarf_file_data from a file DIE attribute. */
4379 static inline struct dwarf_file_data
*
4380 AT_file (dw_attr_ref a
)
4382 gcc_assert (a
&& AT_class (a
) == dw_val_class_file
);
4383 return a
->dw_attr_val
.v
.val_file
;
4386 /* Add a vms delta attribute value to a DIE. */
4389 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4390 const char *lbl1
, const char *lbl2
)
4394 attr
.dw_attr
= attr_kind
;
4395 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
4396 attr
.dw_attr_val
.val_entry
= NULL
;
4397 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
4398 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
4399 add_dwarf_attr (die
, &attr
);
4402 /* Add a label identifier attribute value to a DIE. */
4405 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4410 attr
.dw_attr
= attr_kind
;
4411 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4412 attr
.dw_attr_val
.val_entry
= NULL
;
4413 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4414 if (dwarf_split_debug_info
)
4415 attr
.dw_attr_val
.val_entry
4416 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
4418 add_dwarf_attr (die
, &attr
);
4421 /* Add a section offset attribute value to a DIE, an offset into the
4422 debug_line section. */
4425 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4430 attr
.dw_attr
= attr_kind
;
4431 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
4432 attr
.dw_attr_val
.val_entry
= NULL
;
4433 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4434 add_dwarf_attr (die
, &attr
);
4437 /* Add a section offset attribute value to a DIE, an offset into the
4438 debug_macinfo section. */
4441 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4446 attr
.dw_attr
= attr_kind
;
4447 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
4448 attr
.dw_attr_val
.val_entry
= NULL
;
4449 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4450 add_dwarf_attr (die
, &attr
);
4453 /* Add an offset attribute value to a DIE. */
4456 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4457 unsigned HOST_WIDE_INT offset
)
4461 attr
.dw_attr
= attr_kind
;
4462 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
4463 attr
.dw_attr_val
.val_entry
= NULL
;
4464 attr
.dw_attr_val
.v
.val_offset
= offset
;
4465 add_dwarf_attr (die
, &attr
);
4468 /* Add a range_list attribute value to a DIE. When using
4469 dwarf_split_debug_info, address attributes in dies destined for the
4470 final executable should be direct references--setting the parameter
4471 force_direct ensures this behavior. */
4473 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4474 #define RELOCATED_OFFSET (NULL)
4477 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4478 long unsigned int offset
, bool force_direct
)
4482 attr
.dw_attr
= attr_kind
;
4483 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
4484 /* For the range_list attribute, use val_entry to store whether the
4485 offset should follow split-debug-info or normal semantics. This
4486 value is read in output_range_list_offset. */
4487 if (dwarf_split_debug_info
&& !force_direct
)
4488 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
4490 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
4491 attr
.dw_attr_val
.v
.val_offset
= offset
;
4492 add_dwarf_attr (die
, &attr
);
4495 /* Return the start label of a delta attribute. */
4497 static inline const char *
4498 AT_vms_delta1 (dw_attr_ref a
)
4500 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4501 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
4504 /* Return the end label of a delta attribute. */
4506 static inline const char *
4507 AT_vms_delta2 (dw_attr_ref a
)
4509 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4510 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
4513 static inline const char *
4514 AT_lbl (dw_attr_ref a
)
4516 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
4517 || AT_class (a
) == dw_val_class_lineptr
4518 || AT_class (a
) == dw_val_class_macptr
4519 || AT_class (a
) == dw_val_class_high_pc
));
4520 return a
->dw_attr_val
.v
.val_lbl_id
;
4523 /* Get the attribute of type attr_kind. */
4526 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4530 dw_die_ref spec
= NULL
;
4535 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4536 if (a
->dw_attr
== attr_kind
)
4538 else if (a
->dw_attr
== DW_AT_specification
4539 || a
->dw_attr
== DW_AT_abstract_origin
)
4543 return get_AT (spec
, attr_kind
);
4548 /* Returns the parent of the declaration of DIE. */
4551 get_die_parent (dw_die_ref die
)
4558 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
4559 || (t
= get_AT_ref (die
, DW_AT_specification
)))
4562 return die
->die_parent
;
4565 /* Return the "low pc" attribute value, typically associated with a subprogram
4566 DIE. Return null if the "low pc" attribute is either not present, or if it
4567 cannot be represented as an assembler label identifier. */
4569 static inline const char *
4570 get_AT_low_pc (dw_die_ref die
)
4572 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
4574 return a
? AT_lbl (a
) : NULL
;
4577 /* Return the "high pc" attribute value, typically associated with a subprogram
4578 DIE. Return null if the "high pc" attribute is either not present, or if it
4579 cannot be represented as an assembler label identifier. */
4581 static inline const char *
4582 get_AT_hi_pc (dw_die_ref die
)
4584 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
4586 return a
? AT_lbl (a
) : NULL
;
4589 /* Return the value of the string attribute designated by ATTR_KIND, or
4590 NULL if it is not present. */
4592 static inline const char *
4593 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4595 dw_attr_ref a
= get_AT (die
, attr_kind
);
4597 return a
? AT_string (a
) : NULL
;
4600 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4601 if it is not present. */
4604 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4606 dw_attr_ref a
= get_AT (die
, attr_kind
);
4608 return a
? AT_flag (a
) : 0;
4611 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4612 if it is not present. */
4614 static inline unsigned
4615 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4617 dw_attr_ref a
= get_AT (die
, attr_kind
);
4619 return a
? AT_unsigned (a
) : 0;
4622 static inline dw_die_ref
4623 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4625 dw_attr_ref a
= get_AT (die
, attr_kind
);
4627 return a
? AT_ref (a
) : NULL
;
4630 static inline struct dwarf_file_data
*
4631 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4633 dw_attr_ref a
= get_AT (die
, attr_kind
);
4635 return a
? AT_file (a
) : NULL
;
4638 /* Return TRUE if the language is C++. */
4643 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4645 return lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
;
4648 /* Return TRUE if the language is Java. */
4653 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4655 return lang
== DW_LANG_Java
;
4658 /* Return TRUE if the language is Fortran. */
4663 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4665 return (lang
== DW_LANG_Fortran77
4666 || lang
== DW_LANG_Fortran90
4667 || lang
== DW_LANG_Fortran95
);
4670 /* Return TRUE if the language is Ada. */
4675 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4677 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
4680 /* Remove the specified attribute if present. */
4683 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4691 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4692 if (a
->dw_attr
== attr_kind
)
4694 if (AT_class (a
) == dw_val_class_str
)
4695 if (a
->dw_attr_val
.v
.val_str
->refcount
)
4696 a
->dw_attr_val
.v
.val_str
->refcount
--;
4698 /* vec::ordered_remove should help reduce the number of abbrevs
4700 die
->die_attr
->ordered_remove (ix
);
4705 /* Remove CHILD from its parent. PREV must have the property that
4706 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4709 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
4711 gcc_assert (child
->die_parent
== prev
->die_parent
);
4712 gcc_assert (prev
->die_sib
== child
);
4715 gcc_assert (child
->die_parent
->die_child
== child
);
4719 prev
->die_sib
= child
->die_sib
;
4720 if (child
->die_parent
->die_child
== child
)
4721 child
->die_parent
->die_child
= prev
;
4724 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4725 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4728 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
4730 dw_die_ref parent
= old_child
->die_parent
;
4732 gcc_assert (parent
== prev
->die_parent
);
4733 gcc_assert (prev
->die_sib
== old_child
);
4735 new_child
->die_parent
= parent
;
4736 if (prev
== old_child
)
4738 gcc_assert (parent
->die_child
== old_child
);
4739 new_child
->die_sib
= new_child
;
4743 prev
->die_sib
= new_child
;
4744 new_child
->die_sib
= old_child
->die_sib
;
4746 if (old_child
->die_parent
->die_child
== old_child
)
4747 old_child
->die_parent
->die_child
= new_child
;
4750 /* Move all children from OLD_PARENT to NEW_PARENT. */
4753 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
4756 new_parent
->die_child
= old_parent
->die_child
;
4757 old_parent
->die_child
= NULL
;
4758 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
4761 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4765 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
4771 dw_die_ref prev
= c
;
4773 while (c
->die_tag
== tag
)
4775 remove_child_with_prev (c
, prev
);
4776 /* Might have removed every child. */
4777 if (c
== c
->die_sib
)
4781 } while (c
!= die
->die_child
);
4784 /* Add a CHILD_DIE as the last child of DIE. */
4787 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
4789 /* FIXME this should probably be an assert. */
4790 if (! die
|| ! child_die
)
4792 gcc_assert (die
!= child_die
);
4794 child_die
->die_parent
= die
;
4797 child_die
->die_sib
= die
->die_child
->die_sib
;
4798 die
->die_child
->die_sib
= child_die
;
4801 child_die
->die_sib
= child_die
;
4802 die
->die_child
= child_die
;
4805 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4806 is the specification, to the end of PARENT's list of children.
4807 This is done by removing and re-adding it. */
4810 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
4814 /* We want the declaration DIE from inside the class, not the
4815 specification DIE at toplevel. */
4816 if (child
->die_parent
!= parent
)
4818 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
4824 gcc_assert (child
->die_parent
== parent
4825 || (child
->die_parent
4826 == get_AT_ref (parent
, DW_AT_specification
)));
4828 for (p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
4829 if (p
->die_sib
== child
)
4831 remove_child_with_prev (child
, p
);
4835 add_child_die (parent
, child
);
4838 /* Return a pointer to a newly created DIE node. */
4840 static inline dw_die_ref
4841 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
4843 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
4845 die
->die_tag
= tag_value
;
4847 if (parent_die
!= NULL
)
4848 add_child_die (parent_die
, die
);
4851 limbo_die_node
*limbo_node
;
4853 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
4854 limbo_node
->die
= die
;
4855 limbo_node
->created_for
= t
;
4856 limbo_node
->next
= limbo_die_list
;
4857 limbo_die_list
= limbo_node
;
4863 /* Return the DIE associated with the given type specifier. */
4865 static inline dw_die_ref
4866 lookup_type_die (tree type
)
4868 return TYPE_SYMTAB_DIE (type
);
4871 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
4872 anonymous type named by the typedef TYPE_DIE, return the DIE of the
4873 anonymous type instead the one of the naming typedef. */
4875 static inline dw_die_ref
4876 strip_naming_typedef (tree type
, dw_die_ref type_die
)
4879 && TREE_CODE (type
) == RECORD_TYPE
4881 && type_die
->die_tag
== DW_TAG_typedef
4882 && is_naming_typedef_decl (TYPE_NAME (type
)))
4883 type_die
= get_AT_ref (type_die
, DW_AT_type
);
4887 /* Like lookup_type_die, but if type is an anonymous type named by a
4888 typedef[1], return the DIE of the anonymous type instead the one of
4889 the naming typedef. This is because in gen_typedef_die, we did
4890 equate the anonymous struct named by the typedef with the DIE of
4891 the naming typedef. So by default, lookup_type_die on an anonymous
4892 struct yields the DIE of the naming typedef.
4894 [1]: Read the comment of is_naming_typedef_decl to learn about what
4895 a naming typedef is. */
4897 static inline dw_die_ref
4898 lookup_type_die_strip_naming_typedef (tree type
)
4900 dw_die_ref die
= lookup_type_die (type
);
4901 return strip_naming_typedef (type
, die
);
4904 /* Equate a DIE to a given type specifier. */
4907 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
4909 TYPE_SYMTAB_DIE (type
) = type_die
;
4912 /* Returns a hash value for X (which really is a die_struct). */
4915 decl_die_table_hash (const void *x
)
4917 return (hashval_t
) ((const_dw_die_ref
) x
)->decl_id
;
4920 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
4923 decl_die_table_eq (const void *x
, const void *y
)
4925 return (((const_dw_die_ref
) x
)->decl_id
== DECL_UID ((const_tree
) y
));
4928 /* Return the DIE associated with a given declaration. */
4930 static inline dw_die_ref
4931 lookup_decl_die (tree decl
)
4933 return (dw_die_ref
) htab_find_with_hash (decl_die_table
, decl
, DECL_UID (decl
));
4936 /* Returns a hash value for X (which really is a var_loc_list). */
4939 decl_loc_table_hash (const void *x
)
4941 return (hashval_t
) ((const var_loc_list
*) x
)->decl_id
;
4944 /* Return nonzero if decl_id of var_loc_list X is the same as
4948 decl_loc_table_eq (const void *x
, const void *y
)
4950 return (((const var_loc_list
*) x
)->decl_id
== DECL_UID ((const_tree
) y
));
4953 /* Return the var_loc list associated with a given declaration. */
4955 static inline var_loc_list
*
4956 lookup_decl_loc (const_tree decl
)
4958 if (!decl_loc_table
)
4960 return (var_loc_list
*)
4961 htab_find_with_hash (decl_loc_table
, decl
, DECL_UID (decl
));
4964 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
4967 cached_dw_loc_list_table_hash (const void *x
)
4969 return (hashval_t
) ((const cached_dw_loc_list
*) x
)->decl_id
;
4972 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
4976 cached_dw_loc_list_table_eq (const void *x
, const void *y
)
4978 return (((const cached_dw_loc_list
*) x
)->decl_id
4979 == DECL_UID ((const_tree
) y
));
4982 /* Equate a DIE to a particular declaration. */
4985 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
4987 unsigned int decl_id
= DECL_UID (decl
);
4990 slot
= htab_find_slot_with_hash (decl_die_table
, decl
, decl_id
, INSERT
);
4992 decl_die
->decl_id
= decl_id
;
4995 /* Return how many bits covers PIECE EXPR_LIST. */
4998 decl_piece_bitsize (rtx piece
)
5000 int ret
= (int) GET_MODE (piece
);
5003 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
5004 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
5005 return INTVAL (XEXP (XEXP (piece
, 0), 0));
5008 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5011 decl_piece_varloc_ptr (rtx piece
)
5013 if ((int) GET_MODE (piece
))
5014 return &XEXP (piece
, 0);
5016 return &XEXP (XEXP (piece
, 0), 1);
5019 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5020 Next is the chain of following piece nodes. */
5023 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
5025 if (bitsize
<= (int) MAX_MACHINE_MODE
)
5026 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
5028 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
5033 /* Return rtx that should be stored into loc field for
5034 LOC_NOTE and BITPOS/BITSIZE. */
5037 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
5038 HOST_WIDE_INT bitsize
)
5042 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
5044 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
5049 /* This function either modifies location piece list *DEST in
5050 place (if SRC and INNER is NULL), or copies location piece list
5051 *SRC to *DEST while modifying it. Location BITPOS is modified
5052 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5053 not copied and if needed some padding around it is added.
5054 When modifying in place, DEST should point to EXPR_LIST where
5055 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5056 to the start of the whole list and INNER points to the EXPR_LIST
5057 where earlier pieces cover PIECE_BITPOS bits. */
5060 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
5061 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
5062 HOST_WIDE_INT bitsize
, rtx loc_note
)
5065 bool copy
= inner
!= NULL
;
5069 /* First copy all nodes preceding the current bitpos. */
5070 while (src
!= inner
)
5072 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5073 decl_piece_bitsize (*src
), NULL_RTX
);
5074 dest
= &XEXP (*dest
, 1);
5075 src
= &XEXP (*src
, 1);
5078 /* Add padding if needed. */
5079 if (bitpos
!= piece_bitpos
)
5081 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
5082 copy
? NULL_RTX
: *dest
);
5083 dest
= &XEXP (*dest
, 1);
5085 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
5088 /* A piece with correct bitpos and bitsize already exist,
5089 just update the location for it and return. */
5090 *decl_piece_varloc_ptr (*dest
) = loc_note
;
5093 /* Add the piece that changed. */
5094 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
5095 dest
= &XEXP (*dest
, 1);
5096 /* Skip over pieces that overlap it. */
5097 diff
= bitpos
- piece_bitpos
+ bitsize
;
5100 while (diff
> 0 && *src
)
5103 diff
-= decl_piece_bitsize (piece
);
5105 src
= &XEXP (piece
, 1);
5108 *src
= XEXP (piece
, 1);
5109 free_EXPR_LIST_node (piece
);
5112 /* Add padding if needed. */
5113 if (diff
< 0 && *src
)
5117 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
5118 dest
= &XEXP (*dest
, 1);
5122 /* Finally copy all nodes following it. */
5125 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5126 decl_piece_bitsize (*src
), NULL_RTX
);
5127 dest
= &XEXP (*dest
, 1);
5128 src
= &XEXP (*src
, 1);
5132 /* Add a variable location node to the linked list for DECL. */
5134 static struct var_loc_node
*
5135 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
)
5137 unsigned int decl_id
;
5140 struct var_loc_node
*loc
= NULL
;
5141 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
5143 if (TREE_CODE (decl
) == VAR_DECL
5144 && DECL_HAS_DEBUG_EXPR_P (decl
))
5146 tree realdecl
= DECL_DEBUG_EXPR (decl
);
5147 if (handled_component_p (realdecl
)
5148 || (TREE_CODE (realdecl
) == MEM_REF
5149 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5151 HOST_WIDE_INT maxsize
;
5154 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
, &maxsize
);
5155 if (!DECL_P (innerdecl
)
5156 || DECL_IGNORED_P (innerdecl
)
5157 || TREE_STATIC (innerdecl
)
5159 || bitpos
+ bitsize
> 256
5160 || bitsize
!= maxsize
)
5166 decl_id
= DECL_UID (decl
);
5167 slot
= htab_find_slot_with_hash (decl_loc_table
, decl
, decl_id
, INSERT
);
5170 temp
= ggc_cleared_alloc
<var_loc_list
> ();
5171 temp
->decl_id
= decl_id
;
5175 temp
= (var_loc_list
*) *slot
;
5177 /* For PARM_DECLs try to keep around the original incoming value,
5178 even if that means we'll emit a zero-range .debug_loc entry. */
5180 && temp
->first
== temp
->last
5181 && TREE_CODE (decl
) == PARM_DECL
5182 && NOTE_P (temp
->first
->loc
)
5183 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
5184 && DECL_INCOMING_RTL (decl
)
5185 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
5186 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
5187 == GET_CODE (DECL_INCOMING_RTL (decl
))
5188 && prev_real_insn (temp
->first
->loc
) == NULL_RTX
5190 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
5191 NOTE_VAR_LOCATION_LOC (loc_note
))
5192 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
5193 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
5195 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5196 temp
->first
->next
= loc
;
5198 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5200 else if (temp
->last
)
5202 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
5203 rtx
*piece_loc
= NULL
, last_loc_note
;
5204 int piece_bitpos
= 0;
5208 gcc_assert (last
->next
== NULL
);
5210 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
5212 piece_loc
= &last
->loc
;
5215 int cur_bitsize
= decl_piece_bitsize (*piece_loc
);
5216 if (piece_bitpos
+ cur_bitsize
> bitpos
)
5218 piece_bitpos
+= cur_bitsize
;
5219 piece_loc
= &XEXP (*piece_loc
, 1);
5223 /* TEMP->LAST here is either pointer to the last but one or
5224 last element in the chained list, LAST is pointer to the
5226 if (label
&& strcmp (last
->label
, label
) == 0)
5228 /* For SRA optimized variables if there weren't any real
5229 insns since last note, just modify the last node. */
5230 if (piece_loc
!= NULL
)
5232 adjust_piece_list (piece_loc
, NULL
, NULL
,
5233 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5236 /* If the last note doesn't cover any instructions, remove it. */
5237 if (temp
->last
!= last
)
5239 temp
->last
->next
= NULL
;
5242 gcc_assert (strcmp (last
->label
, label
) != 0);
5246 gcc_assert (temp
->first
== temp
->last
5247 || (temp
->first
->next
== temp
->last
5248 && TREE_CODE (decl
) == PARM_DECL
));
5249 memset (temp
->last
, '\0', sizeof (*temp
->last
));
5250 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5254 if (bitsize
== -1 && NOTE_P (last
->loc
))
5255 last_loc_note
= last
->loc
;
5256 else if (piece_loc
!= NULL
5257 && *piece_loc
!= NULL_RTX
5258 && piece_bitpos
== bitpos
5259 && decl_piece_bitsize (*piece_loc
) == bitsize
)
5260 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
5262 last_loc_note
= NULL_RTX
;
5263 /* If the current location is the same as the end of the list,
5264 and either both or neither of the locations is uninitialized,
5265 we have nothing to do. */
5266 if (last_loc_note
== NULL_RTX
5267 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
5268 NOTE_VAR_LOCATION_LOC (loc_note
)))
5269 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5270 != NOTE_VAR_LOCATION_STATUS (loc_note
))
5271 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5272 == VAR_INIT_STATUS_UNINITIALIZED
)
5273 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
5274 == VAR_INIT_STATUS_UNINITIALIZED
))))
5276 /* Add LOC to the end of list and update LAST. If the last
5277 element of the list has been removed above, reuse its
5278 memory for the new node, otherwise allocate a new one. */
5282 memset (loc
, '\0', sizeof (*loc
));
5285 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5286 if (bitsize
== -1 || piece_loc
== NULL
)
5287 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5289 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
5290 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5292 /* Ensure TEMP->LAST will point either to the new last but one
5293 element of the chain, or to the last element in it. */
5294 if (last
!= temp
->last
)
5302 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5305 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5310 /* Keep track of the number of spaces used to indent the
5311 output of the debugging routines that print the structure of
5312 the DIE internal representation. */
5313 static int print_indent
;
5315 /* Indent the line the number of spaces given by print_indent. */
5318 print_spaces (FILE *outfile
)
5320 fprintf (outfile
, "%*s", print_indent
, "");
5323 /* Print a type signature in hex. */
5326 print_signature (FILE *outfile
, char *sig
)
5330 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
5331 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
5334 /* Print the information associated with a given DIE, and its children.
5335 This routine is a debugging aid only. */
5338 print_die (dw_die_ref die
, FILE *outfile
)
5344 print_spaces (outfile
);
5345 fprintf (outfile
, "DIE %4ld: %s (%p)\n",
5346 die
->die_offset
, dwarf_tag_name (die
->die_tag
),
5348 print_spaces (outfile
);
5349 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
5350 fprintf (outfile
, " offset: %ld", die
->die_offset
);
5351 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
5353 if (die
->comdat_type_p
)
5355 print_spaces (outfile
);
5356 fprintf (outfile
, " signature: ");
5357 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
5358 fprintf (outfile
, "\n");
5361 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5363 print_spaces (outfile
);
5364 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
5366 switch (AT_class (a
))
5368 case dw_val_class_addr
:
5369 fprintf (outfile
, "address");
5371 case dw_val_class_offset
:
5372 fprintf (outfile
, "offset");
5374 case dw_val_class_loc
:
5375 fprintf (outfile
, "location descriptor");
5377 case dw_val_class_loc_list
:
5378 fprintf (outfile
, "location list -> label:%s",
5379 AT_loc_list (a
)->ll_symbol
);
5381 case dw_val_class_range_list
:
5382 fprintf (outfile
, "range list");
5384 case dw_val_class_const
:
5385 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
5387 case dw_val_class_unsigned_const
:
5388 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
5390 case dw_val_class_const_double
:
5391 fprintf (outfile
, "constant ("HOST_WIDE_INT_PRINT_DEC
","\
5392 HOST_WIDE_INT_PRINT_UNSIGNED
")",
5393 a
->dw_attr_val
.v
.val_double
.high
,
5394 a
->dw_attr_val
.v
.val_double
.low
);
5396 case dw_val_class_wide_int
:
5398 int i
= a
->dw_attr_val
.v
.val_wide
->get_len ();
5399 fprintf (outfile
, "constant (");
5401 if (a
->dw_attr_val
.v
.val_wide
->elt (i
- 1) == 0)
5402 fprintf (outfile
, "0x");
5403 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
5404 a
->dw_attr_val
.v
.val_wide
->elt (--i
));
5406 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
5407 a
->dw_attr_val
.v
.val_wide
->elt (i
));
5408 fprintf (outfile
, ")");
5411 case dw_val_class_vec
:
5412 fprintf (outfile
, "floating-point or vector constant");
5414 case dw_val_class_flag
:
5415 fprintf (outfile
, "%u", AT_flag (a
));
5417 case dw_val_class_die_ref
:
5418 if (AT_ref (a
) != NULL
)
5420 if (AT_ref (a
)->comdat_type_p
)
5422 fprintf (outfile
, "die -> signature: ");
5423 print_signature (outfile
,
5424 AT_ref (a
)->die_id
.die_type_node
->signature
);
5426 else if (AT_ref (a
)->die_id
.die_symbol
)
5427 fprintf (outfile
, "die -> label: %s",
5428 AT_ref (a
)->die_id
.die_symbol
);
5430 fprintf (outfile
, "die -> %ld", AT_ref (a
)->die_offset
);
5431 fprintf (outfile
, " (%p)", (void *) AT_ref (a
));
5434 fprintf (outfile
, "die -> <null>");
5436 case dw_val_class_vms_delta
:
5437 fprintf (outfile
, "delta: @slotcount(%s-%s)",
5438 AT_vms_delta2 (a
), AT_vms_delta1 (a
));
5440 case dw_val_class_lbl_id
:
5441 case dw_val_class_lineptr
:
5442 case dw_val_class_macptr
:
5443 case dw_val_class_high_pc
:
5444 fprintf (outfile
, "label: %s", AT_lbl (a
));
5446 case dw_val_class_str
:
5447 if (AT_string (a
) != NULL
)
5448 fprintf (outfile
, "\"%s\"", AT_string (a
));
5450 fprintf (outfile
, "<null>");
5452 case dw_val_class_file
:
5453 fprintf (outfile
, "\"%s\" (%d)", AT_file (a
)->filename
,
5454 AT_file (a
)->emitted_number
);
5456 case dw_val_class_data8
:
5460 for (i
= 0; i
< 8; i
++)
5461 fprintf (outfile
, "%02x", a
->dw_attr_val
.v
.val_data8
[i
]);
5468 fprintf (outfile
, "\n");
5471 if (die
->die_child
!= NULL
)
5474 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
5477 if (print_indent
== 0)
5478 fprintf (outfile
, "\n");
5481 /* Print the information collected for a given DIE. */
5484 debug_dwarf_die (dw_die_ref die
)
5486 print_die (die
, stderr
);
5490 debug (die_struct
&ref
)
5492 print_die (&ref
, stderr
);
5496 debug (die_struct
*ptr
)
5501 fprintf (stderr
, "<nil>\n");
5505 /* Print all DWARF information collected for the compilation unit.
5506 This routine is a debugging aid only. */
5512 print_die (comp_unit_die (), stderr
);
5515 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5516 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5517 DIE that marks the start of the DIEs for this include file. */
5520 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
5522 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
5523 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
5525 new_unit
->die_sib
= old_unit
;
5529 /* Close an include-file CU and reopen the enclosing one. */
5532 pop_compile_unit (dw_die_ref old_unit
)
5534 dw_die_ref new_unit
= old_unit
->die_sib
;
5536 old_unit
->die_sib
= NULL
;
5540 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5541 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5542 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5544 /* Calculate the checksum of a location expression. */
5547 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5552 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
5554 hash
= hash_loc_operands (loc
, hash
);
5558 /* Calculate the checksum of an attribute. */
5561 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
5563 dw_loc_descr_ref loc
;
5566 CHECKSUM (at
->dw_attr
);
5568 /* We don't care that this was compiled with a different compiler
5569 snapshot; if the output is the same, that's what matters. */
5570 if (at
->dw_attr
== DW_AT_producer
)
5573 switch (AT_class (at
))
5575 case dw_val_class_const
:
5576 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
5578 case dw_val_class_unsigned_const
:
5579 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
5581 case dw_val_class_const_double
:
5582 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
5584 case dw_val_class_wide_int
:
5585 CHECKSUM (*at
->dw_attr_val
.v
.val_wide
);
5587 case dw_val_class_vec
:
5588 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
5589 (at
->dw_attr_val
.v
.val_vec
.length
5590 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
5592 case dw_val_class_flag
:
5593 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
5595 case dw_val_class_str
:
5596 CHECKSUM_STRING (AT_string (at
));
5599 case dw_val_class_addr
:
5601 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5602 CHECKSUM_STRING (XSTR (r
, 0));
5605 case dw_val_class_offset
:
5606 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
5609 case dw_val_class_loc
:
5610 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5611 loc_checksum (loc
, ctx
);
5614 case dw_val_class_die_ref
:
5615 die_checksum (AT_ref (at
), ctx
, mark
);
5618 case dw_val_class_fde_ref
:
5619 case dw_val_class_vms_delta
:
5620 case dw_val_class_lbl_id
:
5621 case dw_val_class_lineptr
:
5622 case dw_val_class_macptr
:
5623 case dw_val_class_high_pc
:
5626 case dw_val_class_file
:
5627 CHECKSUM_STRING (AT_file (at
)->filename
);
5630 case dw_val_class_data8
:
5631 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
5639 /* Calculate the checksum of a DIE. */
5642 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
5648 /* To avoid infinite recursion. */
5651 CHECKSUM (die
->die_mark
);
5654 die
->die_mark
= ++(*mark
);
5656 CHECKSUM (die
->die_tag
);
5658 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5659 attr_checksum (a
, ctx
, mark
);
5661 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
5665 #undef CHECKSUM_BLOCK
5666 #undef CHECKSUM_STRING
5668 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
5669 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5670 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5671 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
5672 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
5673 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
5674 #define CHECKSUM_ATTR(FOO) \
5675 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
5677 /* Calculate the checksum of a number in signed LEB128 format. */
5680 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
5687 byte
= (value
& 0x7f);
5689 more
= !((value
== 0 && (byte
& 0x40) == 0)
5690 || (value
== -1 && (byte
& 0x40) != 0));
5699 /* Calculate the checksum of a number in unsigned LEB128 format. */
5702 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
5706 unsigned char byte
= (value
& 0x7f);
5709 /* More bytes to follow. */
5717 /* Checksum the context of the DIE. This adds the names of any
5718 surrounding namespaces or structures to the checksum. */
5721 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
5725 int tag
= die
->die_tag
;
5727 if (tag
!= DW_TAG_namespace
5728 && tag
!= DW_TAG_structure_type
5729 && tag
!= DW_TAG_class_type
)
5732 name
= get_AT_string (die
, DW_AT_name
);
5734 spec
= get_AT_ref (die
, DW_AT_specification
);
5738 if (die
->die_parent
!= NULL
)
5739 checksum_die_context (die
->die_parent
, ctx
);
5741 CHECKSUM_ULEB128 ('C');
5742 CHECKSUM_ULEB128 (tag
);
5744 CHECKSUM_STRING (name
);
5747 /* Calculate the checksum of a location expression. */
5750 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5752 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
5753 were emitted as a DW_FORM_sdata instead of a location expression. */
5754 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
5756 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5757 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
5761 /* Otherwise, just checksum the raw location expression. */
5766 CHECKSUM_ULEB128 (loc
->dtprel
);
5767 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
5768 hash
= hash_loc_operands (loc
, hash
);
5770 loc
= loc
->dw_loc_next
;
5774 /* Calculate the checksum of an attribute. */
5777 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_ref at
,
5778 struct md5_ctx
*ctx
, int *mark
)
5780 dw_loc_descr_ref loc
;
5783 if (AT_class (at
) == dw_val_class_die_ref
)
5785 dw_die_ref target_die
= AT_ref (at
);
5787 /* For pointer and reference types, we checksum only the (qualified)
5788 name of the target type (if there is a name). For friend entries,
5789 we checksum only the (qualified) name of the target type or function.
5790 This allows the checksum to remain the same whether the target type
5791 is complete or not. */
5792 if ((at
->dw_attr
== DW_AT_type
5793 && (tag
== DW_TAG_pointer_type
5794 || tag
== DW_TAG_reference_type
5795 || tag
== DW_TAG_rvalue_reference_type
5796 || tag
== DW_TAG_ptr_to_member_type
))
5797 || (at
->dw_attr
== DW_AT_friend
5798 && tag
== DW_TAG_friend
))
5800 dw_attr_ref name_attr
= get_AT (target_die
, DW_AT_name
);
5802 if (name_attr
!= NULL
)
5804 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
5808 CHECKSUM_ULEB128 ('N');
5809 CHECKSUM_ULEB128 (at
->dw_attr
);
5810 if (decl
->die_parent
!= NULL
)
5811 checksum_die_context (decl
->die_parent
, ctx
);
5812 CHECKSUM_ULEB128 ('E');
5813 CHECKSUM_STRING (AT_string (name_attr
));
5818 /* For all other references to another DIE, we check to see if the
5819 target DIE has already been visited. If it has, we emit a
5820 backward reference; if not, we descend recursively. */
5821 if (target_die
->die_mark
> 0)
5823 CHECKSUM_ULEB128 ('R');
5824 CHECKSUM_ULEB128 (at
->dw_attr
);
5825 CHECKSUM_ULEB128 (target_die
->die_mark
);
5829 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
5833 target_die
->die_mark
= ++(*mark
);
5834 CHECKSUM_ULEB128 ('T');
5835 CHECKSUM_ULEB128 (at
->dw_attr
);
5836 if (decl
->die_parent
!= NULL
)
5837 checksum_die_context (decl
->die_parent
, ctx
);
5838 die_checksum_ordered (target_die
, ctx
, mark
);
5843 CHECKSUM_ULEB128 ('A');
5844 CHECKSUM_ULEB128 (at
->dw_attr
);
5846 switch (AT_class (at
))
5848 case dw_val_class_const
:
5849 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5850 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
5853 case dw_val_class_unsigned_const
:
5854 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5855 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
5858 case dw_val_class_const_double
:
5859 CHECKSUM_ULEB128 (DW_FORM_block
);
5860 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
5861 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
5864 case dw_val_class_wide_int
:
5865 CHECKSUM_ULEB128 (DW_FORM_block
);
5866 CHECKSUM_ULEB128 (sizeof (*at
->dw_attr_val
.v
.val_wide
));
5867 CHECKSUM (*at
->dw_attr_val
.v
.val_wide
);
5870 case dw_val_class_vec
:
5871 CHECKSUM_ULEB128 (DW_FORM_block
);
5872 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
5873 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
5874 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
5875 (at
->dw_attr_val
.v
.val_vec
.length
5876 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
5879 case dw_val_class_flag
:
5880 CHECKSUM_ULEB128 (DW_FORM_flag
);
5881 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
5884 case dw_val_class_str
:
5885 CHECKSUM_ULEB128 (DW_FORM_string
);
5886 CHECKSUM_STRING (AT_string (at
));
5889 case dw_val_class_addr
:
5891 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5892 CHECKSUM_ULEB128 (DW_FORM_string
);
5893 CHECKSUM_STRING (XSTR (r
, 0));
5896 case dw_val_class_offset
:
5897 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5898 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
5901 case dw_val_class_loc
:
5902 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5903 loc_checksum_ordered (loc
, ctx
);
5906 case dw_val_class_fde_ref
:
5907 case dw_val_class_lbl_id
:
5908 case dw_val_class_lineptr
:
5909 case dw_val_class_macptr
:
5910 case dw_val_class_high_pc
:
5913 case dw_val_class_file
:
5914 CHECKSUM_ULEB128 (DW_FORM_string
);
5915 CHECKSUM_STRING (AT_file (at
)->filename
);
5918 case dw_val_class_data8
:
5919 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
5927 struct checksum_attributes
5929 dw_attr_ref at_name
;
5930 dw_attr_ref at_type
;
5931 dw_attr_ref at_friend
;
5932 dw_attr_ref at_accessibility
;
5933 dw_attr_ref at_address_class
;
5934 dw_attr_ref at_allocated
;
5935 dw_attr_ref at_artificial
;
5936 dw_attr_ref at_associated
;
5937 dw_attr_ref at_binary_scale
;
5938 dw_attr_ref at_bit_offset
;
5939 dw_attr_ref at_bit_size
;
5940 dw_attr_ref at_bit_stride
;
5941 dw_attr_ref at_byte_size
;
5942 dw_attr_ref at_byte_stride
;
5943 dw_attr_ref at_const_value
;
5944 dw_attr_ref at_containing_type
;
5945 dw_attr_ref at_count
;
5946 dw_attr_ref at_data_location
;
5947 dw_attr_ref at_data_member_location
;
5948 dw_attr_ref at_decimal_scale
;
5949 dw_attr_ref at_decimal_sign
;
5950 dw_attr_ref at_default_value
;
5951 dw_attr_ref at_digit_count
;
5952 dw_attr_ref at_discr
;
5953 dw_attr_ref at_discr_list
;
5954 dw_attr_ref at_discr_value
;
5955 dw_attr_ref at_encoding
;
5956 dw_attr_ref at_endianity
;
5957 dw_attr_ref at_explicit
;
5958 dw_attr_ref at_is_optional
;
5959 dw_attr_ref at_location
;
5960 dw_attr_ref at_lower_bound
;
5961 dw_attr_ref at_mutable
;
5962 dw_attr_ref at_ordering
;
5963 dw_attr_ref at_picture_string
;
5964 dw_attr_ref at_prototyped
;
5965 dw_attr_ref at_small
;
5966 dw_attr_ref at_segment
;
5967 dw_attr_ref at_string_length
;
5968 dw_attr_ref at_threads_scaled
;
5969 dw_attr_ref at_upper_bound
;
5970 dw_attr_ref at_use_location
;
5971 dw_attr_ref at_use_UTF8
;
5972 dw_attr_ref at_variable_parameter
;
5973 dw_attr_ref at_virtuality
;
5974 dw_attr_ref at_visibility
;
5975 dw_attr_ref at_vtable_elem_location
;
5978 /* Collect the attributes that we will want to use for the checksum. */
5981 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
5986 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5997 attrs
->at_friend
= a
;
5999 case DW_AT_accessibility
:
6000 attrs
->at_accessibility
= a
;
6002 case DW_AT_address_class
:
6003 attrs
->at_address_class
= a
;
6005 case DW_AT_allocated
:
6006 attrs
->at_allocated
= a
;
6008 case DW_AT_artificial
:
6009 attrs
->at_artificial
= a
;
6011 case DW_AT_associated
:
6012 attrs
->at_associated
= a
;
6014 case DW_AT_binary_scale
:
6015 attrs
->at_binary_scale
= a
;
6017 case DW_AT_bit_offset
:
6018 attrs
->at_bit_offset
= a
;
6020 case DW_AT_bit_size
:
6021 attrs
->at_bit_size
= a
;
6023 case DW_AT_bit_stride
:
6024 attrs
->at_bit_stride
= a
;
6026 case DW_AT_byte_size
:
6027 attrs
->at_byte_size
= a
;
6029 case DW_AT_byte_stride
:
6030 attrs
->at_byte_stride
= a
;
6032 case DW_AT_const_value
:
6033 attrs
->at_const_value
= a
;
6035 case DW_AT_containing_type
:
6036 attrs
->at_containing_type
= a
;
6039 attrs
->at_count
= a
;
6041 case DW_AT_data_location
:
6042 attrs
->at_data_location
= a
;
6044 case DW_AT_data_member_location
:
6045 attrs
->at_data_member_location
= a
;
6047 case DW_AT_decimal_scale
:
6048 attrs
->at_decimal_scale
= a
;
6050 case DW_AT_decimal_sign
:
6051 attrs
->at_decimal_sign
= a
;
6053 case DW_AT_default_value
:
6054 attrs
->at_default_value
= a
;
6056 case DW_AT_digit_count
:
6057 attrs
->at_digit_count
= a
;
6060 attrs
->at_discr
= a
;
6062 case DW_AT_discr_list
:
6063 attrs
->at_discr_list
= a
;
6065 case DW_AT_discr_value
:
6066 attrs
->at_discr_value
= a
;
6068 case DW_AT_encoding
:
6069 attrs
->at_encoding
= a
;
6071 case DW_AT_endianity
:
6072 attrs
->at_endianity
= a
;
6074 case DW_AT_explicit
:
6075 attrs
->at_explicit
= a
;
6077 case DW_AT_is_optional
:
6078 attrs
->at_is_optional
= a
;
6080 case DW_AT_location
:
6081 attrs
->at_location
= a
;
6083 case DW_AT_lower_bound
:
6084 attrs
->at_lower_bound
= a
;
6087 attrs
->at_mutable
= a
;
6089 case DW_AT_ordering
:
6090 attrs
->at_ordering
= a
;
6092 case DW_AT_picture_string
:
6093 attrs
->at_picture_string
= a
;
6095 case DW_AT_prototyped
:
6096 attrs
->at_prototyped
= a
;
6099 attrs
->at_small
= a
;
6102 attrs
->at_segment
= a
;
6104 case DW_AT_string_length
:
6105 attrs
->at_string_length
= a
;
6107 case DW_AT_threads_scaled
:
6108 attrs
->at_threads_scaled
= a
;
6110 case DW_AT_upper_bound
:
6111 attrs
->at_upper_bound
= a
;
6113 case DW_AT_use_location
:
6114 attrs
->at_use_location
= a
;
6116 case DW_AT_use_UTF8
:
6117 attrs
->at_use_UTF8
= a
;
6119 case DW_AT_variable_parameter
:
6120 attrs
->at_variable_parameter
= a
;
6122 case DW_AT_virtuality
:
6123 attrs
->at_virtuality
= a
;
6125 case DW_AT_visibility
:
6126 attrs
->at_visibility
= a
;
6128 case DW_AT_vtable_elem_location
:
6129 attrs
->at_vtable_elem_location
= a
;
6137 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6140 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6144 struct checksum_attributes attrs
;
6146 CHECKSUM_ULEB128 ('D');
6147 CHECKSUM_ULEB128 (die
->die_tag
);
6149 memset (&attrs
, 0, sizeof (attrs
));
6151 decl
= get_AT_ref (die
, DW_AT_specification
);
6153 collect_checksum_attributes (&attrs
, decl
);
6154 collect_checksum_attributes (&attrs
, die
);
6156 CHECKSUM_ATTR (attrs
.at_name
);
6157 CHECKSUM_ATTR (attrs
.at_accessibility
);
6158 CHECKSUM_ATTR (attrs
.at_address_class
);
6159 CHECKSUM_ATTR (attrs
.at_allocated
);
6160 CHECKSUM_ATTR (attrs
.at_artificial
);
6161 CHECKSUM_ATTR (attrs
.at_associated
);
6162 CHECKSUM_ATTR (attrs
.at_binary_scale
);
6163 CHECKSUM_ATTR (attrs
.at_bit_offset
);
6164 CHECKSUM_ATTR (attrs
.at_bit_size
);
6165 CHECKSUM_ATTR (attrs
.at_bit_stride
);
6166 CHECKSUM_ATTR (attrs
.at_byte_size
);
6167 CHECKSUM_ATTR (attrs
.at_byte_stride
);
6168 CHECKSUM_ATTR (attrs
.at_const_value
);
6169 CHECKSUM_ATTR (attrs
.at_containing_type
);
6170 CHECKSUM_ATTR (attrs
.at_count
);
6171 CHECKSUM_ATTR (attrs
.at_data_location
);
6172 CHECKSUM_ATTR (attrs
.at_data_member_location
);
6173 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
6174 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
6175 CHECKSUM_ATTR (attrs
.at_default_value
);
6176 CHECKSUM_ATTR (attrs
.at_digit_count
);
6177 CHECKSUM_ATTR (attrs
.at_discr
);
6178 CHECKSUM_ATTR (attrs
.at_discr_list
);
6179 CHECKSUM_ATTR (attrs
.at_discr_value
);
6180 CHECKSUM_ATTR (attrs
.at_encoding
);
6181 CHECKSUM_ATTR (attrs
.at_endianity
);
6182 CHECKSUM_ATTR (attrs
.at_explicit
);
6183 CHECKSUM_ATTR (attrs
.at_is_optional
);
6184 CHECKSUM_ATTR (attrs
.at_location
);
6185 CHECKSUM_ATTR (attrs
.at_lower_bound
);
6186 CHECKSUM_ATTR (attrs
.at_mutable
);
6187 CHECKSUM_ATTR (attrs
.at_ordering
);
6188 CHECKSUM_ATTR (attrs
.at_picture_string
);
6189 CHECKSUM_ATTR (attrs
.at_prototyped
);
6190 CHECKSUM_ATTR (attrs
.at_small
);
6191 CHECKSUM_ATTR (attrs
.at_segment
);
6192 CHECKSUM_ATTR (attrs
.at_string_length
);
6193 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
6194 CHECKSUM_ATTR (attrs
.at_upper_bound
);
6195 CHECKSUM_ATTR (attrs
.at_use_location
);
6196 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
6197 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
6198 CHECKSUM_ATTR (attrs
.at_virtuality
);
6199 CHECKSUM_ATTR (attrs
.at_visibility
);
6200 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
6201 CHECKSUM_ATTR (attrs
.at_type
);
6202 CHECKSUM_ATTR (attrs
.at_friend
);
6204 /* Checksum the child DIEs. */
6207 dw_attr_ref name_attr
;
6210 name_attr
= get_AT (c
, DW_AT_name
);
6211 if (is_template_instantiation (c
))
6213 /* Ignore instantiations of member type and function templates. */
6215 else if (name_attr
!= NULL
6216 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
6218 /* Use a shallow checksum for named nested types and member
6220 CHECKSUM_ULEB128 ('S');
6221 CHECKSUM_ULEB128 (c
->die_tag
);
6222 CHECKSUM_STRING (AT_string (name_attr
));
6226 /* Use a deep checksum for other children. */
6227 /* Mark this DIE so it gets processed when unmarking. */
6228 if (c
->die_mark
== 0)
6230 die_checksum_ordered (c
, ctx
, mark
);
6232 } while (c
!= die
->die_child
);
6234 CHECKSUM_ULEB128 (0);
6237 /* Add a type name and tag to a hash. */
6239 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
6241 CHECKSUM_ULEB128 (tag
);
6242 CHECKSUM_STRING (name
);
6246 #undef CHECKSUM_STRING
6247 #undef CHECKSUM_ATTR
6248 #undef CHECKSUM_LEB128
6249 #undef CHECKSUM_ULEB128
6251 /* Generate the type signature for DIE. This is computed by generating an
6252 MD5 checksum over the DIE's tag, its relevant attributes, and its
6253 children. Attributes that are references to other DIEs are processed
6254 by recursion, using the MARK field to prevent infinite recursion.
6255 If the DIE is nested inside a namespace or another type, we also
6256 need to include that context in the signature. The lower 64 bits
6257 of the resulting MD5 checksum comprise the signature. */
6260 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
6264 unsigned char checksum
[16];
6269 name
= get_AT_string (die
, DW_AT_name
);
6270 decl
= get_AT_ref (die
, DW_AT_specification
);
6271 parent
= get_die_parent (die
);
6273 /* First, compute a signature for just the type name (and its surrounding
6274 context, if any. This is stored in the type unit DIE for link-time
6275 ODR (one-definition rule) checking. */
6277 if (is_cxx () && name
!= NULL
)
6279 md5_init_ctx (&ctx
);
6281 /* Checksum the names of surrounding namespaces and structures. */
6283 checksum_die_context (parent
, &ctx
);
6285 /* Checksum the current DIE. */
6286 die_odr_checksum (die
->die_tag
, name
, &ctx
);
6287 md5_finish_ctx (&ctx
, checksum
);
6289 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
6292 /* Next, compute the complete type signature. */
6294 md5_init_ctx (&ctx
);
6296 die
->die_mark
= mark
;
6298 /* Checksum the names of surrounding namespaces and structures. */
6300 checksum_die_context (parent
, &ctx
);
6302 /* Checksum the DIE and its children. */
6303 die_checksum_ordered (die
, &ctx
, &mark
);
6304 unmark_all_dies (die
);
6305 md5_finish_ctx (&ctx
, checksum
);
6307 /* Store the signature in the type node and link the type DIE and the
6308 type node together. */
6309 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
6310 DWARF_TYPE_SIGNATURE_SIZE
);
6311 die
->comdat_type_p
= true;
6312 die
->die_id
.die_type_node
= type_node
;
6313 type_node
->type_die
= die
;
6315 /* If the DIE is a specification, link its declaration to the type node
6319 decl
->comdat_type_p
= true;
6320 decl
->die_id
.die_type_node
= type_node
;
6324 /* Do the location expressions look same? */
6326 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
6328 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
6329 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
6330 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
6333 /* Do the values look the same? */
6335 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
6337 dw_loc_descr_ref loc1
, loc2
;
6340 if (v1
->val_class
!= v2
->val_class
)
6343 switch (v1
->val_class
)
6345 case dw_val_class_const
:
6346 return v1
->v
.val_int
== v2
->v
.val_int
;
6347 case dw_val_class_unsigned_const
:
6348 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
6349 case dw_val_class_const_double
:
6350 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
6351 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
6352 case dw_val_class_wide_int
:
6353 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
6354 case dw_val_class_vec
:
6355 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
6356 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
6358 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
6359 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
6362 case dw_val_class_flag
:
6363 return v1
->v
.val_flag
== v2
->v
.val_flag
;
6364 case dw_val_class_str
:
6365 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
6367 case dw_val_class_addr
:
6368 r1
= v1
->v
.val_addr
;
6369 r2
= v2
->v
.val_addr
;
6370 if (GET_CODE (r1
) != GET_CODE (r2
))
6372 return !rtx_equal_p (r1
, r2
);
6374 case dw_val_class_offset
:
6375 return v1
->v
.val_offset
== v2
->v
.val_offset
;
6377 case dw_val_class_loc
:
6378 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
6380 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
6381 if (!same_loc_p (loc1
, loc2
, mark
))
6383 return !loc1
&& !loc2
;
6385 case dw_val_class_die_ref
:
6386 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
6388 case dw_val_class_fde_ref
:
6389 case dw_val_class_vms_delta
:
6390 case dw_val_class_lbl_id
:
6391 case dw_val_class_lineptr
:
6392 case dw_val_class_macptr
:
6393 case dw_val_class_high_pc
:
6396 case dw_val_class_file
:
6397 return v1
->v
.val_file
== v2
->v
.val_file
;
6399 case dw_val_class_data8
:
6400 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
6407 /* Do the attributes look the same? */
6410 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
6412 if (at1
->dw_attr
!= at2
->dw_attr
)
6415 /* We don't care that this was compiled with a different compiler
6416 snapshot; if the output is the same, that's what matters. */
6417 if (at1
->dw_attr
== DW_AT_producer
)
6420 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
6423 /* Do the dies look the same? */
6426 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
6432 /* To avoid infinite recursion. */
6434 return die1
->die_mark
== die2
->die_mark
;
6435 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
6437 if (die1
->die_tag
!= die2
->die_tag
)
6440 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
6443 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
6444 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
6447 c1
= die1
->die_child
;
6448 c2
= die2
->die_child
;
6457 if (!same_die_p (c1
, c2
, mark
))
6461 if (c1
== die1
->die_child
)
6463 if (c2
== die2
->die_child
)
6473 /* Do the dies look the same? Wrapper around same_die_p. */
6476 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
6479 int ret
= same_die_p (die1
, die2
, &mark
);
6481 unmark_all_dies (die1
);
6482 unmark_all_dies (die2
);
6487 /* The prefix to attach to symbols on DIEs in the current comdat debug
6489 static const char *comdat_symbol_id
;
6491 /* The index of the current symbol within the current comdat CU. */
6492 static unsigned int comdat_symbol_number
;
6494 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6495 children, and set comdat_symbol_id accordingly. */
6498 compute_section_prefix (dw_die_ref unit_die
)
6500 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
6501 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
6502 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
6505 unsigned char checksum
[16];
6508 /* Compute the checksum of the DIE, then append part of it as hex digits to
6509 the name filename of the unit. */
6511 md5_init_ctx (&ctx
);
6513 die_checksum (unit_die
, &ctx
, &mark
);
6514 unmark_all_dies (unit_die
);
6515 md5_finish_ctx (&ctx
, checksum
);
6517 sprintf (name
, "%s.", base
);
6518 clean_symbol_name (name
);
6520 p
= name
+ strlen (name
);
6521 for (i
= 0; i
< 4; i
++)
6523 sprintf (p
, "%.2x", checksum
[i
]);
6527 comdat_symbol_id
= unit_die
->die_id
.die_symbol
= xstrdup (name
);
6528 comdat_symbol_number
= 0;
6531 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6534 is_type_die (dw_die_ref die
)
6536 switch (die
->die_tag
)
6538 case DW_TAG_array_type
:
6539 case DW_TAG_class_type
:
6540 case DW_TAG_interface_type
:
6541 case DW_TAG_enumeration_type
:
6542 case DW_TAG_pointer_type
:
6543 case DW_TAG_reference_type
:
6544 case DW_TAG_rvalue_reference_type
:
6545 case DW_TAG_string_type
:
6546 case DW_TAG_structure_type
:
6547 case DW_TAG_subroutine_type
:
6548 case DW_TAG_union_type
:
6549 case DW_TAG_ptr_to_member_type
:
6550 case DW_TAG_set_type
:
6551 case DW_TAG_subrange_type
:
6552 case DW_TAG_base_type
:
6553 case DW_TAG_const_type
:
6554 case DW_TAG_file_type
:
6555 case DW_TAG_packed_type
:
6556 case DW_TAG_volatile_type
:
6557 case DW_TAG_typedef
:
6564 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6565 Basically, we want to choose the bits that are likely to be shared between
6566 compilations (types) and leave out the bits that are specific to individual
6567 compilations (functions). */
6570 is_comdat_die (dw_die_ref c
)
6572 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6573 we do for stabs. The advantage is a greater likelihood of sharing between
6574 objects that don't include headers in the same order (and therefore would
6575 put the base types in a different comdat). jason 8/28/00 */
6577 if (c
->die_tag
== DW_TAG_base_type
)
6580 if (c
->die_tag
== DW_TAG_pointer_type
6581 || c
->die_tag
== DW_TAG_reference_type
6582 || c
->die_tag
== DW_TAG_rvalue_reference_type
6583 || c
->die_tag
== DW_TAG_const_type
6584 || c
->die_tag
== DW_TAG_volatile_type
)
6586 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
6588 return t
? is_comdat_die (t
) : 0;
6591 return is_type_die (c
);
6594 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6595 compilation unit. */
6598 is_symbol_die (dw_die_ref c
)
6600 return (is_type_die (c
)
6601 || is_declaration_die (c
)
6602 || c
->die_tag
== DW_TAG_namespace
6603 || c
->die_tag
== DW_TAG_module
);
6606 /* Returns true iff C is a compile-unit DIE. */
6609 is_cu_die (dw_die_ref c
)
6611 return c
&& c
->die_tag
== DW_TAG_compile_unit
;
6614 /* Returns true iff C is a unit DIE of some sort. */
6617 is_unit_die (dw_die_ref c
)
6619 return c
&& (c
->die_tag
== DW_TAG_compile_unit
6620 || c
->die_tag
== DW_TAG_partial_unit
6621 || c
->die_tag
== DW_TAG_type_unit
);
6624 /* Returns true iff C is a namespace DIE. */
6627 is_namespace_die (dw_die_ref c
)
6629 return c
&& c
->die_tag
== DW_TAG_namespace
;
6632 /* Returns true iff C is a class or structure DIE. */
6635 is_class_die (dw_die_ref c
)
6637 return c
&& (c
->die_tag
== DW_TAG_class_type
6638 || c
->die_tag
== DW_TAG_structure_type
);
6641 /* Return non-zero if this DIE is a template parameter. */
6644 is_template_parameter (dw_die_ref die
)
6646 switch (die
->die_tag
)
6648 case DW_TAG_template_type_param
:
6649 case DW_TAG_template_value_param
:
6650 case DW_TAG_GNU_template_template_param
:
6651 case DW_TAG_GNU_template_parameter_pack
:
6658 /* Return non-zero if this DIE represents a template instantiation. */
6661 is_template_instantiation (dw_die_ref die
)
6665 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
6667 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
6672 gen_internal_sym (const char *prefix
)
6676 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
6677 return xstrdup (buf
);
6680 /* Assign symbols to all worthy DIEs under DIE. */
6683 assign_symbol_names (dw_die_ref die
)
6687 if (is_symbol_die (die
) && !die
->comdat_type_p
)
6689 if (comdat_symbol_id
)
6691 char *p
= XALLOCAVEC (char, strlen (comdat_symbol_id
) + 64);
6693 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
6694 comdat_symbol_id
, comdat_symbol_number
++);
6695 die
->die_id
.die_symbol
= xstrdup (p
);
6698 die
->die_id
.die_symbol
= gen_internal_sym ("LDIE");
6701 FOR_EACH_CHILD (die
, c
, assign_symbol_names (c
));
6704 struct cu_hash_table_entry
6707 unsigned min_comdat_num
, max_comdat_num
;
6708 struct cu_hash_table_entry
*next
;
6711 /* Helpers to manipulate hash table of CUs. */
6713 struct cu_hash_table_entry_hasher
6715 typedef cu_hash_table_entry value_type
;
6716 typedef die_struct compare_type
;
6717 static inline hashval_t
hash (const value_type
*);
6718 static inline bool equal (const value_type
*, const compare_type
*);
6719 static inline void remove (value_type
*);
6723 cu_hash_table_entry_hasher::hash (const value_type
*entry
)
6725 return htab_hash_string (entry
->cu
->die_id
.die_symbol
);
6729 cu_hash_table_entry_hasher::equal (const value_type
*entry1
,
6730 const compare_type
*entry2
)
6732 return !strcmp (entry1
->cu
->die_id
.die_symbol
, entry2
->die_id
.die_symbol
);
6736 cu_hash_table_entry_hasher::remove (value_type
*entry
)
6738 struct cu_hash_table_entry
*next
;
6748 typedef hash_table
<cu_hash_table_entry_hasher
> cu_hash_type
;
6750 /* Check whether we have already seen this CU and set up SYM_NUM
6753 check_duplicate_cu (dw_die_ref cu
, cu_hash_type
*htable
, unsigned int *sym_num
)
6755 struct cu_hash_table_entry dummy
;
6756 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
6758 dummy
.max_comdat_num
= 0;
6760 slot
= htable
->find_slot_with_hash (cu
,
6761 htab_hash_string (cu
->die_id
.die_symbol
),
6765 for (; entry
; last
= entry
, entry
= entry
->next
)
6767 if (same_die_p_wrap (cu
, entry
->cu
))
6773 *sym_num
= entry
->min_comdat_num
;
6777 entry
= XCNEW (struct cu_hash_table_entry
);
6779 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
6780 entry
->next
= *slot
;
6786 /* Record SYM_NUM to record of CU in HTABLE. */
6788 record_comdat_symbol_number (dw_die_ref cu
, cu_hash_type
*htable
,
6789 unsigned int sym_num
)
6791 struct cu_hash_table_entry
**slot
, *entry
;
6793 slot
= htable
->find_slot_with_hash (cu
,
6794 htab_hash_string (cu
->die_id
.die_symbol
),
6798 entry
->max_comdat_num
= sym_num
;
6801 /* Traverse the DIE (which is always comp_unit_die), and set up
6802 additional compilation units for each of the include files we see
6803 bracketed by BINCL/EINCL. */
6806 break_out_includes (dw_die_ref die
)
6809 dw_die_ref unit
= NULL
;
6810 limbo_die_node
*node
, **pnode
;
6814 dw_die_ref prev
= c
;
6816 while (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
6817 || (unit
&& is_comdat_die (c
)))
6819 dw_die_ref next
= c
->die_sib
;
6821 /* This DIE is for a secondary CU; remove it from the main one. */
6822 remove_child_with_prev (c
, prev
);
6824 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
6825 unit
= push_new_compile_unit (unit
, c
);
6826 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
6827 unit
= pop_compile_unit (unit
);
6829 add_child_die (unit
, c
);
6831 if (c
== die
->die_child
)
6834 } while (c
!= die
->die_child
);
6837 /* We can only use this in debugging, since the frontend doesn't check
6838 to make sure that we leave every include file we enter. */
6842 assign_symbol_names (die
);
6843 cu_hash_type
cu_hash_table (10);
6844 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
6850 compute_section_prefix (node
->die
);
6851 is_dupl
= check_duplicate_cu (node
->die
, &cu_hash_table
,
6852 &comdat_symbol_number
);
6853 assign_symbol_names (node
->die
);
6855 *pnode
= node
->next
;
6858 pnode
= &node
->next
;
6859 record_comdat_symbol_number (node
->die
, &cu_hash_table
,
6860 comdat_symbol_number
);
6865 /* Return non-zero if this DIE is a declaration. */
6868 is_declaration_die (dw_die_ref die
)
6873 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6874 if (a
->dw_attr
== DW_AT_declaration
)
6880 /* Return non-zero if this DIE is nested inside a subprogram. */
6883 is_nested_in_subprogram (dw_die_ref die
)
6885 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
6889 return local_scope_p (decl
);
6892 /* Return non-zero if this DIE contains a defining declaration of a
6896 contains_subprogram_definition (dw_die_ref die
)
6900 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
6902 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
6906 /* Return non-zero if this is a type DIE that should be moved to a
6907 COMDAT .debug_types section. */
6910 should_move_die_to_comdat (dw_die_ref die
)
6912 switch (die
->die_tag
)
6914 case DW_TAG_class_type
:
6915 case DW_TAG_structure_type
:
6916 case DW_TAG_enumeration_type
:
6917 case DW_TAG_union_type
:
6918 /* Don't move declarations, inlined instances, types nested in a
6919 subprogram, or types that contain subprogram definitions. */
6920 if (is_declaration_die (die
)
6921 || get_AT (die
, DW_AT_abstract_origin
)
6922 || is_nested_in_subprogram (die
)
6923 || contains_subprogram_definition (die
))
6926 case DW_TAG_array_type
:
6927 case DW_TAG_interface_type
:
6928 case DW_TAG_pointer_type
:
6929 case DW_TAG_reference_type
:
6930 case DW_TAG_rvalue_reference_type
:
6931 case DW_TAG_string_type
:
6932 case DW_TAG_subroutine_type
:
6933 case DW_TAG_ptr_to_member_type
:
6934 case DW_TAG_set_type
:
6935 case DW_TAG_subrange_type
:
6936 case DW_TAG_base_type
:
6937 case DW_TAG_const_type
:
6938 case DW_TAG_file_type
:
6939 case DW_TAG_packed_type
:
6940 case DW_TAG_volatile_type
:
6941 case DW_TAG_typedef
:
6947 /* Make a clone of DIE. */
6950 clone_die (dw_die_ref die
)
6956 clone
= ggc_cleared_alloc
<die_node
> ();
6957 clone
->die_tag
= die
->die_tag
;
6959 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6960 add_dwarf_attr (clone
, a
);
6965 /* Make a clone of the tree rooted at DIE. */
6968 clone_tree (dw_die_ref die
)
6971 dw_die_ref clone
= clone_die (die
);
6973 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
6978 /* Make a clone of DIE as a declaration. */
6981 clone_as_declaration (dw_die_ref die
)
6988 /* If the DIE is already a declaration, just clone it. */
6989 if (is_declaration_die (die
))
6990 return clone_die (die
);
6992 /* If the DIE is a specification, just clone its declaration DIE. */
6993 decl
= get_AT_ref (die
, DW_AT_specification
);
6996 clone
= clone_die (decl
);
6997 if (die
->comdat_type_p
)
6998 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7002 clone
= ggc_cleared_alloc
<die_node
> ();
7003 clone
->die_tag
= die
->die_tag
;
7005 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7007 /* We don't want to copy over all attributes.
7008 For example we don't want DW_AT_byte_size because otherwise we will no
7009 longer have a declaration and GDB will treat it as a definition. */
7013 case DW_AT_abstract_origin
:
7014 case DW_AT_artificial
:
7015 case DW_AT_containing_type
:
7016 case DW_AT_external
:
7019 case DW_AT_virtuality
:
7020 case DW_AT_linkage_name
:
7021 case DW_AT_MIPS_linkage_name
:
7022 add_dwarf_attr (clone
, a
);
7024 case DW_AT_byte_size
:
7030 if (die
->comdat_type_p
)
7031 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7033 add_AT_flag (clone
, DW_AT_declaration
, 1);
7038 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7040 struct decl_table_entry
7046 /* Helpers to manipulate hash table of copied declarations. */
7048 /* Hashtable helpers. */
7050 struct decl_table_entry_hasher
: typed_free_remove
<decl_table_entry
>
7052 typedef decl_table_entry value_type
;
7053 typedef die_struct compare_type
;
7054 static inline hashval_t
hash (const value_type
*);
7055 static inline bool equal (const value_type
*, const compare_type
*);
7059 decl_table_entry_hasher::hash (const value_type
*entry
)
7061 return htab_hash_pointer (entry
->orig
);
7065 decl_table_entry_hasher::equal (const value_type
*entry1
,
7066 const compare_type
*entry2
)
7068 return entry1
->orig
== entry2
;
7071 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
7073 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7074 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7075 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7076 to check if the ancestor has already been copied into UNIT. */
7079 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
7080 decl_hash_type
*decl_table
)
7082 dw_die_ref parent
= die
->die_parent
;
7083 dw_die_ref new_parent
= unit
;
7085 decl_table_entry
**slot
= NULL
;
7086 struct decl_table_entry
*entry
= NULL
;
7090 /* Check if the entry has already been copied to UNIT. */
7091 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
7093 if (*slot
!= HTAB_EMPTY_ENTRY
)
7099 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7100 entry
= XCNEW (struct decl_table_entry
);
7108 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
7111 if (!is_unit_die (parent
))
7112 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
7115 copy
= clone_as_declaration (die
);
7116 add_child_die (new_parent
, copy
);
7120 /* Record the pointer to the copy. */
7126 /* Copy the declaration context to the new type unit DIE. This includes
7127 any surrounding namespace or type declarations. If the DIE has an
7128 AT_specification attribute, it also includes attributes and children
7129 attached to the specification, and returns a pointer to the original
7130 parent of the declaration DIE. Returns NULL otherwise. */
7133 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
7136 dw_die_ref new_decl
;
7137 dw_die_ref orig_parent
= NULL
;
7139 decl
= get_AT_ref (die
, DW_AT_specification
);
7148 /* The original DIE will be changed to a declaration, and must
7149 be moved to be a child of the original declaration DIE. */
7150 orig_parent
= decl
->die_parent
;
7152 /* Copy the type node pointer from the new DIE to the original
7153 declaration DIE so we can forward references later. */
7154 decl
->comdat_type_p
= true;
7155 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
7157 remove_AT (die
, DW_AT_specification
);
7159 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
7161 if (a
->dw_attr
!= DW_AT_name
7162 && a
->dw_attr
!= DW_AT_declaration
7163 && a
->dw_attr
!= DW_AT_external
)
7164 add_dwarf_attr (die
, a
);
7167 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
7170 if (decl
->die_parent
!= NULL
7171 && !is_unit_die (decl
->die_parent
))
7173 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
7174 if (new_decl
!= NULL
)
7176 remove_AT (new_decl
, DW_AT_signature
);
7177 add_AT_specification (die
, new_decl
);
7184 /* Generate the skeleton ancestor tree for the given NODE, then clone
7185 the DIE and add the clone into the tree. */
7188 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
7190 if (node
->new_die
!= NULL
)
7193 node
->new_die
= clone_as_declaration (node
->old_die
);
7195 if (node
->parent
!= NULL
)
7197 generate_skeleton_ancestor_tree (node
->parent
);
7198 add_child_die (node
->parent
->new_die
, node
->new_die
);
7202 /* Generate a skeleton tree of DIEs containing any declarations that are
7203 found in the original tree. We traverse the tree looking for declaration
7204 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7207 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
7209 skeleton_chain_node node
;
7212 dw_die_ref prev
= NULL
;
7213 dw_die_ref next
= NULL
;
7215 node
.parent
= parent
;
7217 first
= c
= parent
->old_die
->die_child
;
7221 if (prev
== NULL
|| prev
->die_sib
== c
)
7224 next
= (c
== first
? NULL
: c
->die_sib
);
7226 node
.new_die
= NULL
;
7227 if (is_declaration_die (c
))
7229 if (is_template_instantiation (c
))
7231 /* Instantiated templates do not need to be cloned into the
7232 type unit. Just move the DIE and its children back to
7233 the skeleton tree (in the main CU). */
7234 remove_child_with_prev (c
, prev
);
7235 add_child_die (parent
->new_die
, c
);
7240 /* Clone the existing DIE, move the original to the skeleton
7241 tree (which is in the main CU), and put the clone, with
7242 all the original's children, where the original came from
7243 (which is about to be moved to the type unit). */
7244 dw_die_ref clone
= clone_die (c
);
7245 move_all_children (c
, clone
);
7247 /* If the original has a DW_AT_object_pointer attribute,
7248 it would now point to a child DIE just moved to the
7249 cloned tree, so we need to remove that attribute from
7251 remove_AT (c
, DW_AT_object_pointer
);
7253 replace_child (c
, clone
, prev
);
7254 generate_skeleton_ancestor_tree (parent
);
7255 add_child_die (parent
->new_die
, c
);
7260 generate_skeleton_bottom_up (&node
);
7261 } while (next
!= NULL
);
7264 /* Wrapper function for generate_skeleton_bottom_up. */
7267 generate_skeleton (dw_die_ref die
)
7269 skeleton_chain_node node
;
7272 node
.new_die
= NULL
;
7275 /* If this type definition is nested inside another type,
7276 and is not an instantiation of a template, always leave
7277 at least a declaration in its place. */
7278 if (die
->die_parent
!= NULL
7279 && is_type_die (die
->die_parent
)
7280 && !is_template_instantiation (die
))
7281 node
.new_die
= clone_as_declaration (die
);
7283 generate_skeleton_bottom_up (&node
);
7284 return node
.new_die
;
7287 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7288 declaration. The original DIE is moved to a new compile unit so that
7289 existing references to it follow it to the new location. If any of the
7290 original DIE's descendants is a declaration, we need to replace the
7291 original DIE with a skeleton tree and move the declarations back into the
7295 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
7298 dw_die_ref skeleton
, orig_parent
;
7300 /* Copy the declaration context to the type unit DIE. If the returned
7301 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7303 orig_parent
= copy_declaration_context (unit
, child
);
7305 skeleton
= generate_skeleton (child
);
7306 if (skeleton
== NULL
)
7307 remove_child_with_prev (child
, prev
);
7310 skeleton
->comdat_type_p
= true;
7311 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
7313 /* If the original DIE was a specification, we need to put
7314 the skeleton under the parent DIE of the declaration.
7315 This leaves the original declaration in the tree, but
7316 it will be pruned later since there are no longer any
7317 references to it. */
7318 if (orig_parent
!= NULL
)
7320 remove_child_with_prev (child
, prev
);
7321 add_child_die (orig_parent
, skeleton
);
7324 replace_child (child
, skeleton
, prev
);
7330 /* Traverse the DIE and set up additional .debug_types sections for each
7331 type worthy of being placed in a COMDAT section. */
7334 break_out_comdat_types (dw_die_ref die
)
7338 dw_die_ref prev
= NULL
;
7339 dw_die_ref next
= NULL
;
7340 dw_die_ref unit
= NULL
;
7342 first
= c
= die
->die_child
;
7346 if (prev
== NULL
|| prev
->die_sib
== c
)
7349 next
= (c
== first
? NULL
: c
->die_sib
);
7350 if (should_move_die_to_comdat (c
))
7352 dw_die_ref replacement
;
7353 comdat_type_node_ref type_node
;
7355 /* Break out nested types into their own type units. */
7356 break_out_comdat_types (c
);
7358 /* Create a new type unit DIE as the root for the new tree, and
7359 add it to the list of comdat types. */
7360 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
7361 add_AT_unsigned (unit
, DW_AT_language
,
7362 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
7363 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
7364 type_node
->root_die
= unit
;
7365 type_node
->next
= comdat_type_list
;
7366 comdat_type_list
= type_node
;
7368 /* Generate the type signature. */
7369 generate_type_signature (c
, type_node
);
7371 /* Copy the declaration context, attributes, and children of the
7372 declaration into the new type unit DIE, then remove this DIE
7373 from the main CU (or replace it with a skeleton if necessary). */
7374 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
7375 type_node
->skeleton_die
= replacement
;
7377 /* Add the DIE to the new compunit. */
7378 add_child_die (unit
, c
);
7380 if (replacement
!= NULL
)
7383 else if (c
->die_tag
== DW_TAG_namespace
7384 || c
->die_tag
== DW_TAG_class_type
7385 || c
->die_tag
== DW_TAG_structure_type
7386 || c
->die_tag
== DW_TAG_union_type
)
7388 /* Look for nested types that can be broken out. */
7389 break_out_comdat_types (c
);
7391 } while (next
!= NULL
);
7394 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
7395 Enter all the cloned children into the hash table decl_table. */
7398 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
7402 struct decl_table_entry
*entry
;
7403 decl_table_entry
**slot
;
7405 if (die
->die_tag
== DW_TAG_subprogram
)
7406 clone
= clone_as_declaration (die
);
7408 clone
= clone_die (die
);
7410 slot
= decl_table
->find_slot_with_hash (die
,
7411 htab_hash_pointer (die
), INSERT
);
7413 /* Assert that DIE isn't in the hash table yet. If it would be there
7414 before, the ancestors would be necessarily there as well, therefore
7415 clone_tree_partial wouldn't be called. */
7416 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
7418 entry
= XCNEW (struct decl_table_entry
);
7420 entry
->copy
= clone
;
7423 if (die
->die_tag
!= DW_TAG_subprogram
)
7424 FOR_EACH_CHILD (die
, c
,
7425 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
7430 /* Walk the DIE and its children, looking for references to incomplete
7431 or trivial types that are unmarked (i.e., that are not in the current
7435 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
7441 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7443 if (AT_class (a
) == dw_val_class_die_ref
)
7445 dw_die_ref targ
= AT_ref (a
);
7446 decl_table_entry
**slot
;
7447 struct decl_table_entry
*entry
;
7449 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
7452 slot
= decl_table
->find_slot_with_hash (targ
,
7453 htab_hash_pointer (targ
),
7456 if (*slot
!= HTAB_EMPTY_ENTRY
)
7458 /* TARG has already been copied, so we just need to
7459 modify the reference to point to the copy. */
7461 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
7465 dw_die_ref parent
= unit
;
7466 dw_die_ref copy
= clone_die (targ
);
7468 /* Record in DECL_TABLE that TARG has been copied.
7469 Need to do this now, before the recursive call,
7470 because DECL_TABLE may be expanded and SLOT
7471 would no longer be a valid pointer. */
7472 entry
= XCNEW (struct decl_table_entry
);
7477 /* If TARG is not a declaration DIE, we need to copy its
7479 if (!is_declaration_die (targ
))
7483 add_child_die (copy
,
7484 clone_tree_partial (c
, decl_table
)));
7487 /* Make sure the cloned tree is marked as part of the
7491 /* If TARG has surrounding context, copy its ancestor tree
7492 into the new type unit. */
7493 if (targ
->die_parent
!= NULL
7494 && !is_unit_die (targ
->die_parent
))
7495 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
7498 add_child_die (parent
, copy
);
7499 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
7501 /* Make sure the newly-copied DIE is walked. If it was
7502 installed in a previously-added context, it won't
7503 get visited otherwise. */
7506 /* Find the highest point of the newly-added tree,
7507 mark each node along the way, and walk from there. */
7508 parent
->die_mark
= 1;
7509 while (parent
->die_parent
7510 && parent
->die_parent
->die_mark
== 0)
7512 parent
= parent
->die_parent
;
7513 parent
->die_mark
= 1;
7515 copy_decls_walk (unit
, parent
, decl_table
);
7521 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
7524 /* Copy declarations for "unworthy" types into the new comdat section.
7525 Incomplete types, modified types, and certain other types aren't broken
7526 out into comdat sections of their own, so they don't have a signature,
7527 and we need to copy the declaration into the same section so that we
7528 don't have an external reference. */
7531 copy_decls_for_unworthy_types (dw_die_ref unit
)
7534 decl_hash_type
decl_table (10);
7535 copy_decls_walk (unit
, unit
, &decl_table
);
7539 /* Traverse the DIE and add a sibling attribute if it may have the
7540 effect of speeding up access to siblings. To save some space,
7541 avoid generating sibling attributes for DIE's without children. */
7544 add_sibling_attributes (dw_die_ref die
)
7548 if (! die
->die_child
)
7551 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
7552 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
7554 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
7557 /* Output all location lists for the DIE and its children. */
7560 output_location_lists (dw_die_ref die
)
7566 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7567 if (AT_class (a
) == dw_val_class_loc_list
)
7568 output_loc_list (AT_loc_list (a
));
7570 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
7573 /* We want to limit the number of external references, because they are
7574 larger than local references: a relocation takes multiple words, and
7575 even a sig8 reference is always eight bytes, whereas a local reference
7576 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
7577 So if we encounter multiple external references to the same type DIE, we
7578 make a local typedef stub for it and redirect all references there.
7580 This is the element of the hash table for keeping track of these
7590 /* Hashtable helpers. */
7592 struct external_ref_hasher
: typed_free_remove
<external_ref
>
7594 typedef external_ref value_type
;
7595 typedef external_ref compare_type
;
7596 static inline hashval_t
hash (const value_type
*);
7597 static inline bool equal (const value_type
*, const compare_type
*);
7601 external_ref_hasher::hash (const value_type
*r
)
7603 dw_die_ref die
= r
->type
;
7606 /* We can't use the address of the DIE for hashing, because
7607 that will make the order of the stub DIEs non-deterministic. */
7608 if (! die
->comdat_type_p
)
7609 /* We have a symbol; use it to compute a hash. */
7610 h
= htab_hash_string (die
->die_id
.die_symbol
);
7613 /* We have a type signature; use a subset of the bits as the hash.
7614 The 8-byte signature is at least as large as hashval_t. */
7615 comdat_type_node_ref type_node
= die
->die_id
.die_type_node
;
7616 memcpy (&h
, type_node
->signature
, sizeof (h
));
7622 external_ref_hasher::equal (const value_type
*r1
, const compare_type
*r2
)
7624 return r1
->type
== r2
->type
;
7627 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
7629 /* Return a pointer to the external_ref for references to DIE. */
7631 static struct external_ref
*
7632 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
7634 struct external_ref ref
, *ref_p
;
7635 external_ref
**slot
;
7638 slot
= map
->find_slot (&ref
, INSERT
);
7639 if (*slot
!= HTAB_EMPTY_ENTRY
)
7642 ref_p
= XCNEW (struct external_ref
);
7648 /* Subroutine of optimize_external_refs, below.
7650 If we see a type skeleton, record it as our stub. If we see external
7651 references, remember how many we've seen. */
7654 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
7659 struct external_ref
*ref_p
;
7661 if (is_type_die (die
)
7662 && (c
= get_AT_ref (die
, DW_AT_signature
)))
7664 /* This is a local skeleton; use it for local references. */
7665 ref_p
= lookup_external_ref (map
, c
);
7669 /* Scan the DIE references, and remember any that refer to DIEs from
7670 other CUs (i.e. those which are not marked). */
7671 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7672 if (AT_class (a
) == dw_val_class_die_ref
7673 && (c
= AT_ref (a
))->die_mark
== 0
7676 ref_p
= lookup_external_ref (map
, c
);
7680 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
7683 /* htab_traverse callback function for optimize_external_refs, below. SLOT
7684 points to an external_ref, DATA is the CU we're processing. If we don't
7685 already have a local stub, and we have multiple refs, build a stub. */
7688 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
7690 struct external_ref
*ref_p
= *slot
;
7692 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
7694 /* We have multiple references to this type, so build a small stub.
7695 Both of these forms are a bit dodgy from the perspective of the
7696 DWARF standard, since technically they should have names. */
7697 dw_die_ref cu
= data
;
7698 dw_die_ref type
= ref_p
->type
;
7699 dw_die_ref stub
= NULL
;
7701 if (type
->comdat_type_p
)
7703 /* If we refer to this type via sig8, use AT_signature. */
7704 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
7705 add_AT_die_ref (stub
, DW_AT_signature
, type
);
7709 /* Otherwise, use a typedef with no name. */
7710 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
7711 add_AT_die_ref (stub
, DW_AT_type
, type
);
7720 /* DIE is a unit; look through all the DIE references to see if there are
7721 any external references to types, and if so, create local stubs for
7722 them which will be applied in build_abbrev_table. This is useful because
7723 references to local DIEs are smaller. */
7725 static external_ref_hash_type
*
7726 optimize_external_refs (dw_die_ref die
)
7728 external_ref_hash_type
*map
= new external_ref_hash_type (10);
7729 optimize_external_refs_1 (die
, map
);
7730 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
7734 /* The format of each DIE (and its attribute value pairs) is encoded in an
7735 abbreviation table. This routine builds the abbreviation table and assigns
7736 a unique abbreviation id for each abbreviation entry. The children of each
7737 die are visited recursively. */
7740 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
7742 unsigned long abbrev_id
;
7743 unsigned int n_alloc
;
7748 /* Scan the DIE references, and replace any that refer to
7749 DIEs from other CUs (i.e. those which are not marked) with
7750 the local stubs we built in optimize_external_refs. */
7751 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7752 if (AT_class (a
) == dw_val_class_die_ref
7753 && (c
= AT_ref (a
))->die_mark
== 0)
7755 struct external_ref
*ref_p
;
7756 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
7758 ref_p
= lookup_external_ref (extern_map
, c
);
7759 if (ref_p
->stub
&& ref_p
->stub
!= die
)
7760 change_AT_die_ref (a
, ref_p
->stub
);
7762 /* We aren't changing this reference, so mark it external. */
7763 set_AT_ref_external (a
, 1);
7766 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
7768 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
7769 dw_attr_ref die_a
, abbrev_a
;
7773 if (abbrev
->die_tag
!= die
->die_tag
)
7775 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
7778 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
7781 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
7783 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
7784 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
7785 || (value_format (abbrev_a
) != value_format (die_a
)))
7795 if (abbrev_id
>= abbrev_die_table_in_use
)
7797 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
7799 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
7800 abbrev_die_table
= GGC_RESIZEVEC (dw_die_ref
, abbrev_die_table
,
7803 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
7804 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
7805 abbrev_die_table_allocated
= n_alloc
;
7808 ++abbrev_die_table_in_use
;
7809 abbrev_die_table
[abbrev_id
] = die
;
7812 die
->die_abbrev
= abbrev_id
;
7813 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
7816 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7819 constant_size (unsigned HOST_WIDE_INT value
)
7826 log
= floor_log2 (value
);
7829 log
= 1 << (floor_log2 (log
) + 1);
7834 /* Return the size of a DIE as it is represented in the
7835 .debug_info section. */
7837 static unsigned long
7838 size_of_die (dw_die_ref die
)
7840 unsigned long size
= 0;
7843 enum dwarf_form form
;
7845 size
+= size_of_uleb128 (die
->die_abbrev
);
7846 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7848 switch (AT_class (a
))
7850 case dw_val_class_addr
:
7851 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7853 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7854 size
+= size_of_uleb128 (AT_index (a
));
7857 size
+= DWARF2_ADDR_SIZE
;
7859 case dw_val_class_offset
:
7860 size
+= DWARF_OFFSET_SIZE
;
7862 case dw_val_class_loc
:
7864 unsigned long lsize
= size_of_locs (AT_loc (a
));
7867 if (dwarf_version
>= 4)
7868 size
+= size_of_uleb128 (lsize
);
7870 size
+= constant_size (lsize
);
7874 case dw_val_class_loc_list
:
7875 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7877 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7878 size
+= size_of_uleb128 (AT_index (a
));
7881 size
+= DWARF_OFFSET_SIZE
;
7883 case dw_val_class_range_list
:
7884 size
+= DWARF_OFFSET_SIZE
;
7886 case dw_val_class_const
:
7887 size
+= size_of_sleb128 (AT_int (a
));
7889 case dw_val_class_unsigned_const
:
7891 int csize
= constant_size (AT_unsigned (a
));
7892 if (dwarf_version
== 3
7893 && a
->dw_attr
== DW_AT_data_member_location
7895 size
+= size_of_uleb128 (AT_unsigned (a
));
7900 case dw_val_class_const_double
:
7901 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
7902 if (HOST_BITS_PER_WIDE_INT
>= 64)
7905 case dw_val_class_wide_int
:
7906 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
7907 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7908 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
7912 case dw_val_class_vec
:
7913 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
7914 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
7915 + a
->dw_attr_val
.v
.val_vec
.length
7916 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
7918 case dw_val_class_flag
:
7919 if (dwarf_version
>= 4)
7920 /* Currently all add_AT_flag calls pass in 1 as last argument,
7921 so DW_FORM_flag_present can be used. If that ever changes,
7922 we'll need to use DW_FORM_flag and have some optimization
7923 in build_abbrev_table that will change those to
7924 DW_FORM_flag_present if it is set to 1 in all DIEs using
7925 the same abbrev entry. */
7926 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
7930 case dw_val_class_die_ref
:
7931 if (AT_ref_external (a
))
7933 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
7934 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
7935 is sized by target address length, whereas in DWARF3
7936 it's always sized as an offset. */
7937 if (use_debug_types
)
7938 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
7939 else if (dwarf_version
== 2)
7940 size
+= DWARF2_ADDR_SIZE
;
7942 size
+= DWARF_OFFSET_SIZE
;
7945 size
+= DWARF_OFFSET_SIZE
;
7947 case dw_val_class_fde_ref
:
7948 size
+= DWARF_OFFSET_SIZE
;
7950 case dw_val_class_lbl_id
:
7951 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7953 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7954 size
+= size_of_uleb128 (AT_index (a
));
7957 size
+= DWARF2_ADDR_SIZE
;
7959 case dw_val_class_lineptr
:
7960 case dw_val_class_macptr
:
7961 size
+= DWARF_OFFSET_SIZE
;
7963 case dw_val_class_str
:
7964 form
= AT_string_form (a
);
7965 if (form
== DW_FORM_strp
)
7966 size
+= DWARF_OFFSET_SIZE
;
7967 else if (form
== DW_FORM_GNU_str_index
)
7968 size
+= size_of_uleb128 (AT_index (a
));
7970 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
7972 case dw_val_class_file
:
7973 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
7975 case dw_val_class_data8
:
7978 case dw_val_class_vms_delta
:
7979 size
+= DWARF_OFFSET_SIZE
;
7981 case dw_val_class_high_pc
:
7982 size
+= DWARF2_ADDR_SIZE
;
7992 /* Size the debugging information associated with a given DIE. Visits the
7993 DIE's children recursively. Updates the global variable next_die_offset, on
7994 each time through. Uses the current value of next_die_offset to update the
7995 die_offset field in each DIE. */
7998 calc_die_sizes (dw_die_ref die
)
8002 gcc_assert (die
->die_offset
== 0
8003 || (unsigned long int) die
->die_offset
== next_die_offset
);
8004 die
->die_offset
= next_die_offset
;
8005 next_die_offset
+= size_of_die (die
);
8007 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
8009 if (die
->die_child
!= NULL
)
8010 /* Count the null byte used to terminate sibling lists. */
8011 next_die_offset
+= 1;
8014 /* Size just the base type children at the start of the CU.
8015 This is needed because build_abbrev needs to size locs
8016 and sizing of type based stack ops needs to know die_offset
8017 values for the base types. */
8020 calc_base_type_die_sizes (void)
8022 unsigned long die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8024 dw_die_ref base_type
;
8025 #if ENABLE_ASSERT_CHECKING
8026 dw_die_ref prev
= comp_unit_die ()->die_child
;
8029 die_offset
+= size_of_die (comp_unit_die ());
8030 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
8032 #if ENABLE_ASSERT_CHECKING
8033 gcc_assert (base_type
->die_offset
== 0
8034 && prev
->die_sib
== base_type
8035 && base_type
->die_child
== NULL
8036 && base_type
->die_abbrev
);
8039 base_type
->die_offset
= die_offset
;
8040 die_offset
+= size_of_die (base_type
);
8044 /* Set the marks for a die and its children. We do this so
8045 that we know whether or not a reference needs to use FORM_ref_addr; only
8046 DIEs in the same CU will be marked. We used to clear out the offset
8047 and use that as the flag, but ran into ordering problems. */
8050 mark_dies (dw_die_ref die
)
8054 gcc_assert (!die
->die_mark
);
8057 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
8060 /* Clear the marks for a die and its children. */
8063 unmark_dies (dw_die_ref die
)
8067 if (! use_debug_types
)
8068 gcc_assert (die
->die_mark
);
8071 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
8074 /* Clear the marks for a die, its children and referred dies. */
8077 unmark_all_dies (dw_die_ref die
)
8087 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
8089 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8090 if (AT_class (a
) == dw_val_class_die_ref
)
8091 unmark_all_dies (AT_ref (a
));
8094 /* Calculate if the entry should appear in the final output file. It may be
8095 from a pruned a type. */
8098 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
8100 /* By limiting gnu pubnames to definitions only, gold can generate a
8101 gdb index without entries for declarations, which don't include
8102 enough information to be useful. */
8103 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
8106 if (table
== pubname_table
)
8108 /* Enumerator names are part of the pubname table, but the
8109 parent DW_TAG_enumeration_type die may have been pruned.
8110 Don't output them if that is the case. */
8111 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
8112 (p
->die
->die_parent
== NULL
8113 || !p
->die
->die_parent
->die_perennial_p
))
8116 /* Everything else in the pubname table is included. */
8120 /* The pubtypes table shouldn't include types that have been
8122 return (p
->die
->die_offset
!= 0
8123 || !flag_eliminate_unused_debug_types
);
8126 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8127 generated for the compilation unit. */
8129 static unsigned long
8130 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
8135 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
8137 size
= DWARF_PUBNAMES_HEADER_SIZE
;
8138 FOR_EACH_VEC_ELT (*names
, i
, p
)
8139 if (include_pubname_in_output (names
, p
))
8140 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
8142 size
+= DWARF_OFFSET_SIZE
;
8146 /* Return the size of the information in the .debug_aranges section. */
8148 static unsigned long
8149 size_of_aranges (void)
8153 size
= DWARF_ARANGES_HEADER_SIZE
;
8155 /* Count the address/length pair for this compilation unit. */
8156 if (text_section_used
)
8157 size
+= 2 * DWARF2_ADDR_SIZE
;
8158 if (cold_text_section_used
)
8159 size
+= 2 * DWARF2_ADDR_SIZE
;
8160 if (have_multiple_function_sections
)
8165 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
8167 if (DECL_IGNORED_P (fde
->decl
))
8169 if (!fde
->in_std_section
)
8170 size
+= 2 * DWARF2_ADDR_SIZE
;
8171 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
8172 size
+= 2 * DWARF2_ADDR_SIZE
;
8176 /* Count the two zero words used to terminated the address range table. */
8177 size
+= 2 * DWARF2_ADDR_SIZE
;
8181 /* Select the encoding of an attribute value. */
8183 static enum dwarf_form
8184 value_format (dw_attr_ref a
)
8186 switch (AT_class (a
))
8188 case dw_val_class_addr
:
8189 /* Only very few attributes allow DW_FORM_addr. */
8194 case DW_AT_entry_pc
:
8195 case DW_AT_trampoline
:
8196 return (AT_index (a
) == NOT_INDEXED
8197 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8201 switch (DWARF2_ADDR_SIZE
)
8204 return DW_FORM_data1
;
8206 return DW_FORM_data2
;
8208 return DW_FORM_data4
;
8210 return DW_FORM_data8
;
8214 case dw_val_class_range_list
:
8215 case dw_val_class_loc_list
:
8216 if (dwarf_version
>= 4)
8217 return DW_FORM_sec_offset
;
8219 case dw_val_class_vms_delta
:
8220 case dw_val_class_offset
:
8221 switch (DWARF_OFFSET_SIZE
)
8224 return DW_FORM_data4
;
8226 return DW_FORM_data8
;
8230 case dw_val_class_loc
:
8231 if (dwarf_version
>= 4)
8232 return DW_FORM_exprloc
;
8233 switch (constant_size (size_of_locs (AT_loc (a
))))
8236 return DW_FORM_block1
;
8238 return DW_FORM_block2
;
8240 return DW_FORM_block4
;
8244 case dw_val_class_const
:
8245 return DW_FORM_sdata
;
8246 case dw_val_class_unsigned_const
:
8247 switch (constant_size (AT_unsigned (a
)))
8250 return DW_FORM_data1
;
8252 return DW_FORM_data2
;
8254 /* In DWARF3 DW_AT_data_member_location with
8255 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8256 constant, so we need to use DW_FORM_udata if we need
8257 a large constant. */
8258 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8259 return DW_FORM_udata
;
8260 return DW_FORM_data4
;
8262 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8263 return DW_FORM_udata
;
8264 return DW_FORM_data8
;
8268 case dw_val_class_const_double
:
8269 switch (HOST_BITS_PER_WIDE_INT
)
8272 return DW_FORM_data2
;
8274 return DW_FORM_data4
;
8276 return DW_FORM_data8
;
8279 return DW_FORM_block1
;
8281 case dw_val_class_wide_int
:
8282 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
8285 return DW_FORM_data1
;
8287 return DW_FORM_data2
;
8289 return DW_FORM_data4
;
8291 return DW_FORM_data8
;
8293 return DW_FORM_block1
;
8295 case dw_val_class_vec
:
8296 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
8297 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
8300 return DW_FORM_block1
;
8302 return DW_FORM_block2
;
8304 return DW_FORM_block4
;
8308 case dw_val_class_flag
:
8309 if (dwarf_version
>= 4)
8311 /* Currently all add_AT_flag calls pass in 1 as last argument,
8312 so DW_FORM_flag_present can be used. If that ever changes,
8313 we'll need to use DW_FORM_flag and have some optimization
8314 in build_abbrev_table that will change those to
8315 DW_FORM_flag_present if it is set to 1 in all DIEs using
8316 the same abbrev entry. */
8317 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
8318 return DW_FORM_flag_present
;
8320 return DW_FORM_flag
;
8321 case dw_val_class_die_ref
:
8322 if (AT_ref_external (a
))
8323 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
8326 case dw_val_class_fde_ref
:
8327 return DW_FORM_data
;
8328 case dw_val_class_lbl_id
:
8329 return (AT_index (a
) == NOT_INDEXED
8330 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8331 case dw_val_class_lineptr
:
8332 case dw_val_class_macptr
:
8333 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
8334 case dw_val_class_str
:
8335 return AT_string_form (a
);
8336 case dw_val_class_file
:
8337 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
8340 return DW_FORM_data1
;
8342 return DW_FORM_data2
;
8344 return DW_FORM_data4
;
8349 case dw_val_class_data8
:
8350 return DW_FORM_data8
;
8352 case dw_val_class_high_pc
:
8353 switch (DWARF2_ADDR_SIZE
)
8356 return DW_FORM_data1
;
8358 return DW_FORM_data2
;
8360 return DW_FORM_data4
;
8362 return DW_FORM_data8
;
8372 /* Output the encoding of an attribute value. */
8375 output_value_format (dw_attr_ref a
)
8377 enum dwarf_form form
= value_format (a
);
8379 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
8382 /* Given a die and id, produce the appropriate abbreviations. */
8385 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
8390 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
8391 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
8392 dwarf_tag_name (abbrev
->die_tag
));
8394 if (abbrev
->die_child
!= NULL
)
8395 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
8397 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
8399 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
8401 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
8402 dwarf_attr_name (a_attr
->dw_attr
));
8403 output_value_format (a_attr
);
8406 dw2_asm_output_data (1, 0, NULL
);
8407 dw2_asm_output_data (1, 0, NULL
);
8411 /* Output the .debug_abbrev section which defines the DIE abbreviation
8415 output_abbrev_section (void)
8417 unsigned long abbrev_id
;
8419 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
8420 output_die_abbrevs (abbrev_id
, abbrev_die_table
[abbrev_id
]);
8422 /* Terminate the table. */
8423 dw2_asm_output_data (1, 0, NULL
);
8426 /* Output a symbol we can use to refer to this DIE from another CU. */
8429 output_die_symbol (dw_die_ref die
)
8431 const char *sym
= die
->die_id
.die_symbol
;
8433 gcc_assert (!die
->comdat_type_p
);
8438 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
8439 /* We make these global, not weak; if the target doesn't support
8440 .linkonce, it doesn't support combining the sections, so debugging
8442 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
8444 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
8447 /* Return a new location list, given the begin and end range, and the
8450 static inline dw_loc_list_ref
8451 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
8452 const char *section
)
8454 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
8456 retlist
->begin
= begin
;
8457 retlist
->begin_entry
= NULL
;
8459 retlist
->expr
= expr
;
8460 retlist
->section
= section
;
8465 /* Generate a new internal symbol for this location list node, if it
8466 hasn't got one yet. */
8469 gen_llsym (dw_loc_list_ref list
)
8471 gcc_assert (!list
->ll_symbol
);
8472 list
->ll_symbol
= gen_internal_sym ("LLST");
8475 /* Output the location list given to us. */
8478 output_loc_list (dw_loc_list_ref list_head
)
8480 dw_loc_list_ref curr
= list_head
;
8482 if (list_head
->emitted
)
8484 list_head
->emitted
= true;
8486 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
8488 /* Walk the location list, and output each range + expression. */
8489 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
8492 /* Don't output an entry that starts and ends at the same address. */
8493 if (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
)
8495 size
= size_of_locs (curr
->expr
);
8496 /* If the expression is too large, drop it on the floor. We could
8497 perhaps put it into DW_TAG_dwarf_procedure and refer to that
8498 in the expression, but >= 64KB expressions for a single value
8499 in a single range are unlikely very useful. */
8502 if (dwarf_split_debug_info
)
8504 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
8505 "Location list start/length entry (%s)",
8506 list_head
->ll_symbol
);
8507 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
8508 "Location list range start index (%s)",
8510 /* The length field is 4 bytes. If we ever need to support
8511 an 8-byte length, we can add a new DW_LLE code or fall back
8512 to DW_LLE_GNU_start_end_entry. */
8513 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
8514 "Location list range length (%s)",
8515 list_head
->ll_symbol
);
8517 else if (!have_multiple_function_sections
)
8519 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
8520 "Location list begin address (%s)",
8521 list_head
->ll_symbol
);
8522 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
8523 "Location list end address (%s)",
8524 list_head
->ll_symbol
);
8528 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
8529 "Location list begin address (%s)",
8530 list_head
->ll_symbol
);
8531 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
8532 "Location list end address (%s)",
8533 list_head
->ll_symbol
);
8536 /* Output the block length for this list of location operations. */
8537 gcc_assert (size
<= 0xffff);
8538 dw2_asm_output_data (2, size
, "%s", "Location expression size");
8540 output_loc_sequence (curr
->expr
, -1);
8543 if (dwarf_split_debug_info
)
8544 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
8545 "Location list terminator (%s)",
8546 list_head
->ll_symbol
);
8549 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8550 "Location list terminator begin (%s)",
8551 list_head
->ll_symbol
);
8552 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8553 "Location list terminator end (%s)",
8554 list_head
->ll_symbol
);
8558 /* Output a range_list offset into the debug_range section. Emit a
8559 relocated reference if val_entry is NULL, otherwise, emit an
8560 indirect reference. */
8563 output_range_list_offset (dw_attr_ref a
)
8565 const char *name
= dwarf_attr_name (a
->dw_attr
);
8567 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
8569 char *p
= strchr (ranges_section_label
, '\0');
8570 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
, a
->dw_attr_val
.v
.val_offset
);
8571 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
8572 debug_ranges_section
, "%s", name
);
8576 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8577 "%s (offset from %s)", name
, ranges_section_label
);
8580 /* Output the offset into the debug_loc section. */
8583 output_loc_list_offset (dw_attr_ref a
)
8585 char *sym
= AT_loc_list (a
)->ll_symbol
;
8588 if (dwarf_split_debug_info
)
8589 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
8590 "%s", dwarf_attr_name (a
->dw_attr
));
8592 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
8593 "%s", dwarf_attr_name (a
->dw_attr
));
8596 /* Output an attribute's index or value appropriately. */
8599 output_attr_index_or_value (dw_attr_ref a
)
8601 const char *name
= dwarf_attr_name (a
->dw_attr
);
8603 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8605 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
8608 switch (AT_class (a
))
8610 case dw_val_class_addr
:
8611 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
8613 case dw_val_class_high_pc
:
8614 case dw_val_class_lbl_id
:
8615 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
8617 case dw_val_class_loc_list
:
8618 output_loc_list_offset (a
);
8625 /* Output a type signature. */
8628 output_signature (const char *sig
, const char *name
)
8632 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
8633 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
8636 /* Output the DIE and its attributes. Called recursively to generate
8637 the definitions of each child DIE. */
8640 output_die (dw_die_ref die
)
8647 /* If someone in another CU might refer to us, set up a symbol for
8648 them to point to. */
8649 if (! die
->comdat_type_p
&& die
->die_id
.die_symbol
)
8650 output_die_symbol (die
);
8652 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
8653 (unsigned long)die
->die_offset
,
8654 dwarf_tag_name (die
->die_tag
));
8656 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8658 const char *name
= dwarf_attr_name (a
->dw_attr
);
8660 switch (AT_class (a
))
8662 case dw_val_class_addr
:
8663 output_attr_index_or_value (a
);
8666 case dw_val_class_offset
:
8667 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8671 case dw_val_class_range_list
:
8672 output_range_list_offset (a
);
8675 case dw_val_class_loc
:
8676 size
= size_of_locs (AT_loc (a
));
8678 /* Output the block length for this list of location operations. */
8679 if (dwarf_version
>= 4)
8680 dw2_asm_output_data_uleb128 (size
, "%s", name
);
8682 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
8684 output_loc_sequence (AT_loc (a
), -1);
8687 case dw_val_class_const
:
8688 /* ??? It would be slightly more efficient to use a scheme like is
8689 used for unsigned constants below, but gdb 4.x does not sign
8690 extend. Gdb 5.x does sign extend. */
8691 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
8694 case dw_val_class_unsigned_const
:
8696 int csize
= constant_size (AT_unsigned (a
));
8697 if (dwarf_version
== 3
8698 && a
->dw_attr
== DW_AT_data_member_location
8700 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
8702 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
8706 case dw_val_class_const_double
:
8708 unsigned HOST_WIDE_INT first
, second
;
8710 if (HOST_BITS_PER_WIDE_INT
>= 64)
8711 dw2_asm_output_data (1,
8712 HOST_BITS_PER_DOUBLE_INT
8713 / HOST_BITS_PER_CHAR
,
8716 if (WORDS_BIG_ENDIAN
)
8718 first
= a
->dw_attr_val
.v
.val_double
.high
;
8719 second
= a
->dw_attr_val
.v
.val_double
.low
;
8723 first
= a
->dw_attr_val
.v
.val_double
.low
;
8724 second
= a
->dw_attr_val
.v
.val_double
.high
;
8727 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8729 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8734 case dw_val_class_wide_int
:
8737 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
8738 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
8739 if (len
* HOST_BITS_PER_WIDE_INT
> 64)
8740 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
) * l
,
8743 if (WORDS_BIG_ENDIAN
)
8744 for (i
= len
- 1; i
>= 0; --i
)
8746 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
8751 for (i
= 0; i
< len
; ++i
)
8753 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
8760 case dw_val_class_vec
:
8762 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
8763 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
8767 dw2_asm_output_data (constant_size (len
* elt_size
),
8768 len
* elt_size
, "%s", name
);
8769 if (elt_size
> sizeof (HOST_WIDE_INT
))
8774 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
8777 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
8778 "fp or vector constant word %u", i
);
8782 case dw_val_class_flag
:
8783 if (dwarf_version
>= 4)
8785 /* Currently all add_AT_flag calls pass in 1 as last argument,
8786 so DW_FORM_flag_present can be used. If that ever changes,
8787 we'll need to use DW_FORM_flag and have some optimization
8788 in build_abbrev_table that will change those to
8789 DW_FORM_flag_present if it is set to 1 in all DIEs using
8790 the same abbrev entry. */
8791 gcc_assert (AT_flag (a
) == 1);
8793 fprintf (asm_out_file
, "\t\t\t%s %s\n",
8794 ASM_COMMENT_START
, name
);
8797 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
8800 case dw_val_class_loc_list
:
8801 output_attr_index_or_value (a
);
8804 case dw_val_class_die_ref
:
8805 if (AT_ref_external (a
))
8807 if (AT_ref (a
)->comdat_type_p
)
8809 comdat_type_node_ref type_node
=
8810 AT_ref (a
)->die_id
.die_type_node
;
8812 gcc_assert (type_node
);
8813 output_signature (type_node
->signature
, name
);
8817 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
8821 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8822 length, whereas in DWARF3 it's always sized as an
8824 if (dwarf_version
== 2)
8825 size
= DWARF2_ADDR_SIZE
;
8827 size
= DWARF_OFFSET_SIZE
;
8828 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
8834 gcc_assert (AT_ref (a
)->die_offset
);
8835 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
8840 case dw_val_class_fde_ref
:
8844 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
8845 a
->dw_attr_val
.v
.val_fde_index
* 2);
8846 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
8851 case dw_val_class_vms_delta
:
8852 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
8853 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
8857 case dw_val_class_lbl_id
:
8858 output_attr_index_or_value (a
);
8861 case dw_val_class_lineptr
:
8862 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8863 debug_line_section
, "%s", name
);
8866 case dw_val_class_macptr
:
8867 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8868 debug_macinfo_section
, "%s", name
);
8871 case dw_val_class_str
:
8872 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
8873 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
8874 a
->dw_attr_val
.v
.val_str
->label
,
8876 "%s: \"%s\"", name
, AT_string (a
));
8877 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_GNU_str_index
)
8878 dw2_asm_output_data_uleb128 (AT_index (a
),
8879 "%s: \"%s\"", name
, AT_string (a
));
8881 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
8884 case dw_val_class_file
:
8886 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
8888 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
8889 a
->dw_attr_val
.v
.val_file
->filename
);
8893 case dw_val_class_data8
:
8897 for (i
= 0; i
< 8; i
++)
8898 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
8899 i
== 0 ? "%s" : NULL
, name
);
8903 case dw_val_class_high_pc
:
8904 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
8905 get_AT_low_pc (die
), "DW_AT_high_pc");
8913 FOR_EACH_CHILD (die
, c
, output_die (c
));
8915 /* Add null byte to terminate sibling list. */
8916 if (die
->die_child
!= NULL
)
8917 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
8918 (unsigned long) die
->die_offset
);
8921 /* Output the compilation unit that appears at the beginning of the
8922 .debug_info section, and precedes the DIE descriptions. */
8925 output_compilation_unit_header (void)
8927 int ver
= dwarf_version
;
8929 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8930 dw2_asm_output_data (4, 0xffffffff,
8931 "Initial length escape value indicating 64-bit DWARF extension");
8932 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
8933 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
8934 "Length of Compilation Unit Info");
8935 dw2_asm_output_data (2, ver
, "DWARF version number");
8936 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
8937 debug_abbrev_section
,
8938 "Offset Into Abbrev. Section");
8939 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
8942 /* Output the compilation unit DIE and its children. */
8945 output_comp_unit (dw_die_ref die
, int output_if_empty
)
8947 const char *secname
, *oldsym
;
8950 /* Unless we are outputting main CU, we may throw away empty ones. */
8951 if (!output_if_empty
&& die
->die_child
== NULL
)
8954 /* Even if there are no children of this DIE, we must output the information
8955 about the compilation unit. Otherwise, on an empty translation unit, we
8956 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8957 will then complain when examining the file. First mark all the DIEs in
8958 this CU so we know which get local refs. */
8961 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
8963 build_abbrev_table (die
, extern_map
);
8967 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8968 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8969 calc_die_sizes (die
);
8971 oldsym
= die
->die_id
.die_symbol
;
8974 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
8976 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
8978 die
->die_id
.die_symbol
= NULL
;
8979 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
8983 switch_to_section (debug_info_section
);
8984 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
8985 info_section_emitted
= true;
8988 /* Output debugging information. */
8989 output_compilation_unit_header ();
8992 /* Leave the marks on the main CU, so we can check them in
8997 die
->die_id
.die_symbol
= oldsym
;
9001 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
9002 and .debug_pubtypes. This is configured per-target, but can be
9003 overridden by the -gpubnames or -gno-pubnames options. */
9006 want_pubnames (void)
9008 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9010 if (debug_generate_pub_sections
!= -1)
9011 return debug_generate_pub_sections
;
9012 return targetm
.want_debug_pub_sections
;
9015 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
9018 add_AT_pubnames (dw_die_ref die
)
9020 if (want_pubnames ())
9021 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
9024 /* Add a string attribute value to a skeleton DIE. */
9027 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
9031 struct indirect_string_node
*node
;
9033 if (! skeleton_debug_str_hash
)
9034 skeleton_debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
9035 debug_str_eq
, NULL
);
9037 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
9038 find_string_form (node
);
9039 if (node
->form
== DW_FORM_GNU_str_index
)
9040 node
->form
= DW_FORM_strp
;
9042 attr
.dw_attr
= attr_kind
;
9043 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
9044 attr
.dw_attr_val
.val_entry
= NULL
;
9045 attr
.dw_attr_val
.v
.val_str
= node
;
9046 add_dwarf_attr (die
, &attr
);
9049 /* Helper function to generate top-level dies for skeleton debug_info and
9053 add_top_level_skeleton_die_attrs (dw_die_ref die
)
9055 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
9056 const char *comp_dir
= comp_dir_string ();
9058 add_skeleton_AT_string (die
, DW_AT_GNU_dwo_name
, dwo_file_name
);
9059 if (comp_dir
!= NULL
)
9060 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
9061 add_AT_pubnames (die
);
9062 add_AT_lineptr (die
, DW_AT_GNU_addr_base
, debug_addr_section_label
);
9065 /* Return the single type-unit die for skeleton type units. */
9068 get_skeleton_type_unit (void)
9070 /* For dwarf_split_debug_sections with use_type info, all type units in the
9071 skeleton sections have identical dies (but different headers). This
9072 single die will be output many times. */
9074 static dw_die_ref skeleton_type_unit
= NULL
;
9076 if (skeleton_type_unit
== NULL
)
9078 skeleton_type_unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
9079 add_top_level_skeleton_die_attrs (skeleton_type_unit
);
9080 skeleton_type_unit
->die_abbrev
= SKELETON_TYPE_DIE_ABBREV
;
9082 return skeleton_type_unit
;
9085 /* Output skeleton debug sections that point to the dwo file. */
9088 output_skeleton_debug_sections (dw_die_ref comp_unit
)
9090 /* These attributes will be found in the full debug_info section. */
9091 remove_AT (comp_unit
, DW_AT_producer
);
9092 remove_AT (comp_unit
, DW_AT_language
);
9094 switch_to_section (debug_skeleton_info_section
);
9095 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
9097 /* Produce the skeleton compilation-unit header. This one differs enough from
9098 a normal CU header that it's better not to call output_compilation_unit
9100 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9101 dw2_asm_output_data (4, 0xffffffff,
9102 "Initial length escape value indicating 64-bit DWARF extension");
9104 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9105 DWARF_COMPILE_UNIT_HEADER_SIZE
9106 - DWARF_INITIAL_LENGTH_SIZE
9107 + size_of_die (comp_unit
),
9108 "Length of Compilation Unit Info");
9109 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
9110 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
9111 debug_abbrev_section
,
9112 "Offset Into Abbrev. Section");
9113 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
9115 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
9116 output_die (comp_unit
);
9118 /* Build the skeleton debug_abbrev section. */
9119 switch_to_section (debug_skeleton_abbrev_section
);
9120 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
9122 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
9123 if (use_debug_types
)
9124 output_die_abbrevs (SKELETON_TYPE_DIE_ABBREV
, get_skeleton_type_unit ());
9126 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
9129 /* Output a comdat type unit DIE and its children. */
9132 output_comdat_type_unit (comdat_type_node
*node
)
9134 const char *secname
;
9137 #if defined (OBJECT_FORMAT_ELF)
9141 /* First mark all the DIEs in this CU so we know which get local refs. */
9142 mark_dies (node
->root_die
);
9144 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
9146 build_abbrev_table (node
->root_die
, extern_map
);
9151 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9152 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
9153 calc_die_sizes (node
->root_die
);
9155 #if defined (OBJECT_FORMAT_ELF)
9156 if (!dwarf_split_debug_info
)
9157 secname
= ".debug_types";
9159 secname
= ".debug_types.dwo";
9161 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9162 sprintf (tmp
, "wt.");
9163 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9164 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9165 comdat_key
= get_identifier (tmp
);
9166 targetm
.asm_out
.named_section (secname
,
9167 SECTION_DEBUG
| SECTION_LINKONCE
,
9170 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9171 sprintf (tmp
, ".gnu.linkonce.wt.");
9172 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9173 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9175 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
9178 /* Output debugging information. */
9179 output_compilation_unit_header ();
9180 output_signature (node
->signature
, "Type Signature");
9181 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
9182 "Offset to Type DIE");
9183 output_die (node
->root_die
);
9185 unmark_dies (node
->root_die
);
9187 #if defined (OBJECT_FORMAT_ELF)
9188 if (dwarf_split_debug_info
)
9190 /* Produce the skeleton type-unit header. */
9191 const char *secname
= ".debug_types";
9193 targetm
.asm_out
.named_section (secname
,
9194 SECTION_DEBUG
| SECTION_LINKONCE
,
9196 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9197 dw2_asm_output_data (4, 0xffffffff,
9198 "Initial length escape value indicating 64-bit DWARF extension");
9200 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9201 DWARF_COMPILE_UNIT_HEADER_SIZE
9202 - DWARF_INITIAL_LENGTH_SIZE
9203 + size_of_die (get_skeleton_type_unit ())
9204 + DWARF_TYPE_SIGNATURE_SIZE
+ DWARF_OFFSET_SIZE
,
9205 "Length of Type Unit Info");
9206 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
9207 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
9208 debug_skeleton_abbrev_section_label
,
9209 debug_abbrev_section
,
9210 "Offset Into Abbrev. Section");
9211 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
9212 output_signature (node
->signature
, "Type Signature");
9213 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, "Offset to Type DIE");
9215 output_die (get_skeleton_type_unit ());
9220 /* Return the DWARF2/3 pubname associated with a decl. */
9223 dwarf2_name (tree decl
, int scope
)
9225 if (DECL_NAMELESS (decl
))
9227 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
9230 /* Add a new entry to .debug_pubnames if appropriate. */
9233 add_pubname_string (const char *str
, dw_die_ref die
)
9238 e
.name
= xstrdup (str
);
9239 vec_safe_push (pubname_table
, e
);
9243 add_pubname (tree decl
, dw_die_ref die
)
9245 if (!want_pubnames ())
9248 /* Don't add items to the table when we expect that the consumer will have
9249 just read the enclosing die. For example, if the consumer is looking at a
9250 class_member, it will either be inside the class already, or will have just
9251 looked up the class to find the member. Either way, searching the class is
9252 faster than searching the index. */
9253 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
9254 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9256 const char *name
= dwarf2_name (decl
, 1);
9259 add_pubname_string (name
, die
);
9263 /* Add an enumerator to the pubnames section. */
9266 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
9270 gcc_assert (scope_name
);
9271 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
9273 vec_safe_push (pubname_table
, e
);
9276 /* Add a new entry to .debug_pubtypes if appropriate. */
9279 add_pubtype (tree decl
, dw_die_ref die
)
9283 if (!want_pubnames ())
9286 if ((TREE_PUBLIC (decl
)
9287 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9288 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
9291 const char *scope_name
= "";
9292 const char *sep
= is_cxx () ? "::" : ".";
9295 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
9296 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
9298 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
9299 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
9300 scope_name
= concat (scope_name
, sep
, NULL
);
9306 name
= type_tag (decl
);
9308 name
= lang_hooks
.dwarf_name (decl
, 1);
9310 /* If we don't have a name for the type, there's no point in adding
9312 if (name
!= NULL
&& name
[0] != '\0')
9315 e
.name
= concat (scope_name
, name
, NULL
);
9316 vec_safe_push (pubtype_table
, e
);
9319 /* Although it might be more consistent to add the pubinfo for the
9320 enumerators as their dies are created, they should only be added if the
9321 enum type meets the criteria above. So rather than re-check the parent
9322 enum type whenever an enumerator die is created, just output them all
9323 here. This isn't protected by the name conditional because anonymous
9324 enums don't have names. */
9325 if (die
->die_tag
== DW_TAG_enumeration_type
)
9329 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
9334 /* Output a single entry in the pubnames table. */
9337 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
9339 dw_die_ref die
= entry
->die
;
9340 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
9342 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
9344 if (debug_generate_pub_sections
== 2)
9346 /* This logic follows gdb's method for determining the value of the flag
9348 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
9349 switch (die
->die_tag
)
9351 case DW_TAG_typedef
:
9352 case DW_TAG_base_type
:
9353 case DW_TAG_subrange_type
:
9354 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9355 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9357 case DW_TAG_enumerator
:
9358 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9359 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9360 if (!is_cxx () && !is_java ())
9361 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9363 case DW_TAG_subprogram
:
9364 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9365 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
9367 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9369 case DW_TAG_constant
:
9370 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9371 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9372 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9374 case DW_TAG_variable
:
9375 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9376 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9377 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9379 case DW_TAG_namespace
:
9380 case DW_TAG_imported_declaration
:
9381 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9383 case DW_TAG_class_type
:
9384 case DW_TAG_interface_type
:
9385 case DW_TAG_structure_type
:
9386 case DW_TAG_union_type
:
9387 case DW_TAG_enumeration_type
:
9388 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9389 if (!is_cxx () && !is_java ())
9390 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9393 /* An unusual tag. Leave the flag-byte empty. */
9396 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
9400 dw2_asm_output_nstring (entry
->name
, -1, "external name");
9404 /* Output the public names table used to speed up access to externally
9405 visible names; or the public types table used to find type definitions. */
9408 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9411 unsigned long pubnames_length
= size_of_pubnames (names
);
9414 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9415 dw2_asm_output_data (4, 0xffffffff,
9416 "Initial length escape value indicating 64-bit DWARF extension");
9417 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
, "Pub Info Length");
9419 /* Version number for pubnames/pubtypes is independent of dwarf version. */
9420 dw2_asm_output_data (2, 2, "DWARF Version");
9422 if (dwarf_split_debug_info
)
9423 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9424 debug_skeleton_info_section
,
9425 "Offset of Compilation Unit Info");
9427 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9429 "Offset of Compilation Unit Info");
9430 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
9431 "Compilation Unit Length");
9433 FOR_EACH_VEC_ELT (*names
, i
, pub
)
9435 if (include_pubname_in_output (names
, pub
))
9437 dw_offset die_offset
= pub
->die
->die_offset
;
9439 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9440 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
9441 gcc_assert (pub
->die
->die_mark
);
9443 /* If we're putting types in their own .debug_types sections,
9444 the .debug_pubtypes table will still point to the compile
9445 unit (not the type unit), so we want to use the offset of
9446 the skeleton DIE (if there is one). */
9447 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
9449 comdat_type_node_ref type_node
= pub
->die
->die_id
.die_type_node
;
9451 if (type_node
!= NULL
)
9452 die_offset
= (type_node
->skeleton_die
!= NULL
9453 ? type_node
->skeleton_die
->die_offset
9454 : comp_unit_die ()->die_offset
);
9457 output_pubname (die_offset
, pub
);
9461 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
9464 /* Output public names and types tables if necessary. */
9467 output_pubtables (void)
9469 if (!want_pubnames () || !info_section_emitted
)
9472 switch_to_section (debug_pubnames_section
);
9473 output_pubnames (pubname_table
);
9474 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
9475 It shouldn't hurt to emit it always, since pure DWARF2 consumers
9476 simply won't look for the section. */
9477 switch_to_section (debug_pubtypes_section
);
9478 output_pubnames (pubtype_table
);
9482 /* Output the information that goes into the .debug_aranges table.
9483 Namely, define the beginning and ending address range of the
9484 text section generated for this compilation unit. */
9487 output_aranges (unsigned long aranges_length
)
9491 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9492 dw2_asm_output_data (4, 0xffffffff,
9493 "Initial length escape value indicating 64-bit DWARF extension");
9494 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
9495 "Length of Address Ranges Info");
9496 /* Version number for aranges is still 2, even in DWARF3. */
9497 dw2_asm_output_data (2, 2, "DWARF Version");
9498 if (dwarf_split_debug_info
)
9499 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9500 debug_skeleton_info_section
,
9501 "Offset of Compilation Unit Info");
9503 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9505 "Offset of Compilation Unit Info");
9506 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
9507 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9509 /* We need to align to twice the pointer size here. */
9510 if (DWARF_ARANGES_PAD_SIZE
)
9512 /* Pad using a 2 byte words so that padding is correct for any
9514 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9515 2 * DWARF2_ADDR_SIZE
);
9516 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
9517 dw2_asm_output_data (2, 0, NULL
);
9520 /* It is necessary not to output these entries if the sections were
9521 not used; if the sections were not used, the length will be 0 and
9522 the address may end up as 0 if the section is discarded by ld
9523 --gc-sections, leaving an invalid (0, 0) entry that can be
9524 confused with the terminator. */
9525 if (text_section_used
)
9527 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
9528 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
9529 text_section_label
, "Length");
9531 if (cold_text_section_used
)
9533 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
9535 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
9536 cold_text_section_label
, "Length");
9539 if (have_multiple_function_sections
)
9544 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9546 if (DECL_IGNORED_P (fde
->decl
))
9548 if (!fde
->in_std_section
)
9550 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
9552 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
9553 fde
->dw_fde_begin
, "Length");
9555 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9557 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
9559 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
9560 fde
->dw_fde_second_begin
, "Length");
9565 /* Output the terminator words. */
9566 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9567 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9570 /* Add a new entry to .debug_ranges. Return the offset at which it
9574 add_ranges_num (int num
)
9576 unsigned int in_use
= ranges_table_in_use
;
9578 if (in_use
== ranges_table_allocated
)
9580 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
9581 ranges_table
= GGC_RESIZEVEC (struct dw_ranges_struct
, ranges_table
,
9582 ranges_table_allocated
);
9583 memset (ranges_table
+ ranges_table_in_use
, 0,
9584 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
9587 ranges_table
[in_use
].num
= num
;
9588 ranges_table_in_use
= in_use
+ 1;
9590 return in_use
* 2 * DWARF2_ADDR_SIZE
;
9593 /* Add a new entry to .debug_ranges corresponding to a block, or a
9594 range terminator if BLOCK is NULL. */
9597 add_ranges (const_tree block
)
9599 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0);
9602 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
9603 When using dwarf_split_debug_info, address attributes in dies destined
9604 for the final executable should be direct references--setting the
9605 parameter force_direct ensures this behavior. */
9608 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
9609 bool *added
, bool force_direct
)
9611 unsigned int in_use
= ranges_by_label_in_use
;
9612 unsigned int offset
;
9614 if (in_use
== ranges_by_label_allocated
)
9616 ranges_by_label_allocated
+= RANGES_TABLE_INCREMENT
;
9617 ranges_by_label
= GGC_RESIZEVEC (struct dw_ranges_by_label_struct
,
9619 ranges_by_label_allocated
);
9620 memset (ranges_by_label
+ ranges_by_label_in_use
, 0,
9621 RANGES_TABLE_INCREMENT
9622 * sizeof (struct dw_ranges_by_label_struct
));
9625 ranges_by_label
[in_use
].begin
= begin
;
9626 ranges_by_label
[in_use
].end
= end
;
9627 ranges_by_label_in_use
= in_use
+ 1;
9629 offset
= add_ranges_num (-(int)in_use
- 1);
9632 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
9638 output_ranges (void)
9641 static const char *const start_fmt
= "Offset %#x";
9642 const char *fmt
= start_fmt
;
9644 for (i
= 0; i
< ranges_table_in_use
; i
++)
9646 int block_num
= ranges_table
[i
].num
;
9650 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
9651 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
9653 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
9654 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
9656 /* If all code is in the text section, then the compilation
9657 unit base address defaults to DW_AT_low_pc, which is the
9658 base of the text section. */
9659 if (!have_multiple_function_sections
)
9661 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
9663 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9664 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
9665 text_section_label
, NULL
);
9668 /* Otherwise, the compilation unit base address is zero,
9669 which allows us to use absolute addresses, and not worry
9670 about whether the target supports cross-section
9674 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
9675 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9676 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
9682 /* Negative block_num stands for an index into ranges_by_label. */
9683 else if (block_num
< 0)
9685 int lab_idx
= - block_num
- 1;
9687 if (!have_multiple_function_sections
)
9691 /* If we ever use add_ranges_by_labels () for a single
9692 function section, all we have to do is to take out
9694 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9695 ranges_by_label
[lab_idx
].begin
,
9697 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9698 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9699 ranges_by_label
[lab_idx
].end
,
9700 text_section_label
, NULL
);
9705 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9706 ranges_by_label
[lab_idx
].begin
,
9707 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9708 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9709 ranges_by_label
[lab_idx
].end
,
9715 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9716 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9722 /* Data structure containing information about input files. */
9725 const char *path
; /* Complete file name. */
9726 const char *fname
; /* File name part. */
9727 int length
; /* Length of entire string. */
9728 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
9729 int dir_idx
; /* Index in directory table. */
9732 /* Data structure containing information about directories with source
9736 const char *path
; /* Path including directory name. */
9737 int length
; /* Path length. */
9738 int prefix
; /* Index of directory entry which is a prefix. */
9739 int count
; /* Number of files in this directory. */
9740 int dir_idx
; /* Index of directory used as base. */
9743 /* Callback function for file_info comparison. We sort by looking at
9744 the directories in the path. */
9747 file_info_cmp (const void *p1
, const void *p2
)
9749 const struct file_info
*const s1
= (const struct file_info
*) p1
;
9750 const struct file_info
*const s2
= (const struct file_info
*) p2
;
9751 const unsigned char *cp1
;
9752 const unsigned char *cp2
;
9754 /* Take care of file names without directories. We need to make sure that
9755 we return consistent values to qsort since some will get confused if
9756 we return the same value when identical operands are passed in opposite
9757 orders. So if neither has a directory, return 0 and otherwise return
9758 1 or -1 depending on which one has the directory. */
9759 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
9760 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
9762 cp1
= (const unsigned char *) s1
->path
;
9763 cp2
= (const unsigned char *) s2
->path
;
9769 /* Reached the end of the first path? If so, handle like above. */
9770 if ((cp1
== (const unsigned char *) s1
->fname
)
9771 || (cp2
== (const unsigned char *) s2
->fname
))
9772 return ((cp2
== (const unsigned char *) s2
->fname
)
9773 - (cp1
== (const unsigned char *) s1
->fname
));
9775 /* Character of current path component the same? */
9776 else if (*cp1
!= *cp2
)
9781 struct file_name_acquire_data
9783 struct file_info
*files
;
9788 /* Traversal function for the hash table. */
9791 file_name_acquire (void ** slot
, void *data
)
9793 struct file_name_acquire_data
*fnad
= (struct file_name_acquire_data
*) data
;
9794 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
9795 struct file_info
*fi
;
9798 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
9800 if (! d
->emitted_number
)
9803 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
9805 fi
= fnad
->files
+ fnad
->used_files
++;
9807 /* Skip all leading "./". */
9809 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
9812 /* Create a new array entry. */
9814 fi
->length
= strlen (f
);
9817 /* Search for the file name part. */
9818 f
= strrchr (f
, DIR_SEPARATOR
);
9819 #if defined (DIR_SEPARATOR_2)
9821 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
9825 if (f
== NULL
|| f
< g
)
9831 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
9835 /* Output the directory table and the file name table. We try to minimize
9836 the total amount of memory needed. A heuristic is used to avoid large
9837 slowdowns with many input files. */
9840 output_file_names (void)
9842 struct file_name_acquire_data fnad
;
9844 struct file_info
*files
;
9845 struct dir_info
*dirs
;
9853 if (!last_emitted_file
)
9855 dw2_asm_output_data (1, 0, "End directory table");
9856 dw2_asm_output_data (1, 0, "End file name table");
9860 numfiles
= last_emitted_file
->emitted_number
;
9862 /* Allocate the various arrays we need. */
9863 files
= XALLOCAVEC (struct file_info
, numfiles
);
9864 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
9867 fnad
.used_files
= 0;
9868 fnad
.max_files
= numfiles
;
9869 htab_traverse (file_table
, file_name_acquire
, &fnad
);
9870 gcc_assert (fnad
.used_files
== fnad
.max_files
);
9872 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
9874 /* Find all the different directories used. */
9875 dirs
[0].path
= files
[0].path
;
9876 dirs
[0].length
= files
[0].fname
- files
[0].path
;
9877 dirs
[0].prefix
= -1;
9879 dirs
[0].dir_idx
= 0;
9880 files
[0].dir_idx
= 0;
9883 for (i
= 1; i
< numfiles
; i
++)
9884 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
9885 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
9886 dirs
[ndirs
- 1].length
) == 0)
9888 /* Same directory as last entry. */
9889 files
[i
].dir_idx
= ndirs
- 1;
9890 ++dirs
[ndirs
- 1].count
;
9896 /* This is a new directory. */
9897 dirs
[ndirs
].path
= files
[i
].path
;
9898 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
9899 dirs
[ndirs
].count
= 1;
9900 dirs
[ndirs
].dir_idx
= ndirs
;
9901 files
[i
].dir_idx
= ndirs
;
9903 /* Search for a prefix. */
9904 dirs
[ndirs
].prefix
= -1;
9905 for (j
= 0; j
< ndirs
; j
++)
9906 if (dirs
[j
].length
< dirs
[ndirs
].length
9907 && dirs
[j
].length
> 1
9908 && (dirs
[ndirs
].prefix
== -1
9909 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
9910 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
9911 dirs
[ndirs
].prefix
= j
;
9916 /* Now to the actual work. We have to find a subset of the directories which
9917 allow expressing the file name using references to the directory table
9918 with the least amount of characters. We do not do an exhaustive search
9919 where we would have to check out every combination of every single
9920 possible prefix. Instead we use a heuristic which provides nearly optimal
9921 results in most cases and never is much off. */
9922 saved
= XALLOCAVEC (int, ndirs
);
9923 savehere
= XALLOCAVEC (int, ndirs
);
9925 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
9926 for (i
= 0; i
< ndirs
; i
++)
9931 /* We can always save some space for the current directory. But this
9932 does not mean it will be enough to justify adding the directory. */
9933 savehere
[i
] = dirs
[i
].length
;
9934 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
9936 for (j
= i
+ 1; j
< ndirs
; j
++)
9939 if (saved
[j
] < dirs
[i
].length
)
9941 /* Determine whether the dirs[i] path is a prefix of the
9946 while (k
!= -1 && k
!= (int) i
)
9951 /* Yes it is. We can possibly save some memory by
9952 writing the filenames in dirs[j] relative to
9954 savehere
[j
] = dirs
[i
].length
;
9955 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
9960 /* Check whether we can save enough to justify adding the dirs[i]
9962 if (total
> dirs
[i
].length
+ 1)
9964 /* It's worthwhile adding. */
9965 for (j
= i
; j
< ndirs
; j
++)
9966 if (savehere
[j
] > 0)
9968 /* Remember how much we saved for this directory so far. */
9969 saved
[j
] = savehere
[j
];
9971 /* Remember the prefix directory. */
9972 dirs
[j
].dir_idx
= i
;
9977 /* Emit the directory name table. */
9978 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
9979 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
9980 dw2_asm_output_nstring (dirs
[i
].path
,
9982 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
9983 "Directory Entry: %#x", i
+ idx_offset
);
9985 dw2_asm_output_data (1, 0, "End directory table");
9987 /* We have to emit them in the order of emitted_number since that's
9988 used in the debug info generation. To do this efficiently we
9989 generate a back-mapping of the indices first. */
9990 backmap
= XALLOCAVEC (int, numfiles
);
9991 for (i
= 0; i
< numfiles
; i
++)
9992 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
9994 /* Now write all the file names. */
9995 for (i
= 0; i
< numfiles
; i
++)
9997 int file_idx
= backmap
[i
];
9998 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
10000 #ifdef VMS_DEBUGGING_INFO
10001 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
10003 /* Setting these fields can lead to debugger miscomparisons,
10004 but VMS Debug requires them to be set correctly. */
10009 int maxfilelen
= strlen (files
[file_idx
].path
)
10010 + dirs
[dir_idx
].length
10011 + MAX_VMS_VERSION_LEN
+ 1;
10012 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
10014 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
10015 snprintf (filebuf
, maxfilelen
, "%s;%d",
10016 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
10018 dw2_asm_output_nstring
10019 (filebuf
, -1, "File Entry: %#x", (unsigned) i
+ 1);
10021 /* Include directory index. */
10022 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
10024 /* Modification time. */
10025 dw2_asm_output_data_uleb128
10026 ((vms_file_stats_name (files
[file_idx
].path
, &cdt
, 0, 0, 0) == 0)
10030 /* File length in bytes. */
10031 dw2_asm_output_data_uleb128
10032 ((vms_file_stats_name (files
[file_idx
].path
, 0, &siz
, 0, 0) == 0)
10036 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
10037 "File Entry: %#x", (unsigned) i
+ 1);
10039 /* Include directory index. */
10040 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
10042 /* Modification time. */
10043 dw2_asm_output_data_uleb128 (0, NULL
);
10045 /* File length in bytes. */
10046 dw2_asm_output_data_uleb128 (0, NULL
);
10047 #endif /* VMS_DEBUGGING_INFO */
10050 dw2_asm_output_data (1, 0, "End file name table");
10054 /* Output one line number table into the .debug_line section. */
10057 output_one_line_info_table (dw_line_info_table
*table
)
10059 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10060 unsigned int current_line
= 1;
10061 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
10062 dw_line_info_entry
*ent
;
10065 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
10067 switch (ent
->opcode
)
10069 case LI_set_address
:
10070 /* ??? Unfortunately, we have little choice here currently, and
10071 must always use the most general form. GCC does not know the
10072 address delta itself, so we can't use DW_LNS_advance_pc. Many
10073 ports do have length attributes which will give an upper bound
10074 on the address range. We could perhaps use length attributes
10075 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
10076 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
10078 /* This can handle any delta. This takes
10079 4+DWARF2_ADDR_SIZE bytes. */
10080 dw2_asm_output_data (1, 0, "set address %s", line_label
);
10081 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10082 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10083 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
10087 if (ent
->val
== current_line
)
10089 /* We still need to start a new row, so output a copy insn. */
10090 dw2_asm_output_data (1, DW_LNS_copy
,
10091 "copy line %u", current_line
);
10095 int line_offset
= ent
->val
- current_line
;
10096 int line_delta
= line_offset
- DWARF_LINE_BASE
;
10098 current_line
= ent
->val
;
10099 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
10101 /* This can handle deltas from -10 to 234, using the current
10102 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
10103 This takes 1 byte. */
10104 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
10105 "line %u", current_line
);
10109 /* This can handle any delta. This takes at least 4 bytes,
10110 depending on the value being encoded. */
10111 dw2_asm_output_data (1, DW_LNS_advance_line
,
10112 "advance to line %u", current_line
);
10113 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
10114 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
10120 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
10121 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
10124 case LI_set_column
:
10125 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
10126 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
10129 case LI_negate_stmt
:
10130 current_is_stmt
= !current_is_stmt
;
10131 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
10132 "is_stmt %d", current_is_stmt
);
10135 case LI_set_prologue_end
:
10136 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
10137 "set prologue end");
10140 case LI_set_epilogue_begin
:
10141 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
10142 "set epilogue begin");
10145 case LI_set_discriminator
:
10146 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
10147 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
10148 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
10149 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
10154 /* Emit debug info for the address of the end of the table. */
10155 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
10156 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10157 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10158 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
10160 dw2_asm_output_data (1, 0, "end sequence");
10161 dw2_asm_output_data_uleb128 (1, NULL
);
10162 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
10165 /* Output the source line number correspondence information. This
10166 information goes into the .debug_line section. */
10169 output_line_info (bool prologue_only
)
10171 char l1
[20], l2
[20], p1
[20], p2
[20];
10172 int ver
= dwarf_version
;
10173 bool saw_one
= false;
10176 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
10177 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
10178 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
10179 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
10181 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10182 dw2_asm_output_data (4, 0xffffffff,
10183 "Initial length escape value indicating 64-bit DWARF extension");
10184 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
10185 "Length of Source Line Info");
10186 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
10188 dw2_asm_output_data (2, ver
, "DWARF Version");
10189 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
10190 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
10192 /* Define the architecture-dependent minimum instruction length (in bytes).
10193 In this implementation of DWARF, this field is used for information
10194 purposes only. Since GCC generates assembly language, we have no
10195 a priori knowledge of how many instruction bytes are generated for each
10196 source line, and therefore can use only the DW_LNE_set_address and
10197 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
10198 this as '1', which is "correct enough" for all architectures,
10199 and don't let the target override. */
10200 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
10203 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
10204 "Maximum Operations Per Instruction");
10205 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
10206 "Default is_stmt_start flag");
10207 dw2_asm_output_data (1, DWARF_LINE_BASE
,
10208 "Line Base Value (Special Opcodes)");
10209 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
10210 "Line Range Value (Special Opcodes)");
10211 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
10212 "Special Opcode Base");
10214 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
10219 case DW_LNS_advance_pc
:
10220 case DW_LNS_advance_line
:
10221 case DW_LNS_set_file
:
10222 case DW_LNS_set_column
:
10223 case DW_LNS_fixed_advance_pc
:
10224 case DW_LNS_set_isa
:
10232 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
10236 /* Write out the information about the files we use. */
10237 output_file_names ();
10238 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
10241 /* Output the marker for the end of the line number info. */
10242 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10246 if (separate_line_info
)
10248 dw_line_info_table
*table
;
10251 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
10254 output_one_line_info_table (table
);
10258 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
10260 output_one_line_info_table (cold_text_section_line_info
);
10264 /* ??? Some Darwin linkers crash on a .debug_line section with no
10265 sequences. Further, merely a DW_LNE_end_sequence entry is not
10266 sufficient -- the address column must also be initialized.
10267 Make sure to output at least one set_address/end_sequence pair,
10268 choosing .text since that section is always present. */
10269 if (text_section_line_info
->in_use
|| !saw_one
)
10270 output_one_line_info_table (text_section_line_info
);
10272 /* Output the marker for the end of the line number info. */
10273 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10276 /* Given a pointer to a tree node for some base type, return a pointer to
10277 a DIE that describes the given type.
10279 This routine must only be called for GCC type nodes that correspond to
10280 Dwarf base (fundamental) types. */
10283 base_type_die (tree type
)
10285 dw_die_ref base_type_result
;
10286 enum dwarf_type encoding
;
10288 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
10291 /* If this is a subtype that should not be emitted as a subrange type,
10292 use the base type. See subrange_type_for_debug_p. */
10293 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
10294 type
= TREE_TYPE (type
);
10296 switch (TREE_CODE (type
))
10299 if ((dwarf_version
>= 4 || !dwarf_strict
)
10300 && TYPE_NAME (type
)
10301 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10302 && DECL_IS_BUILTIN (TYPE_NAME (type
))
10303 && DECL_NAME (TYPE_NAME (type
)))
10305 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
10306 if (strcmp (name
, "char16_t") == 0
10307 || strcmp (name
, "char32_t") == 0)
10309 encoding
= DW_ATE_UTF
;
10313 if (TYPE_STRING_FLAG (type
))
10315 if (TYPE_UNSIGNED (type
))
10316 encoding
= DW_ATE_unsigned_char
;
10318 encoding
= DW_ATE_signed_char
;
10320 else if (TYPE_UNSIGNED (type
))
10321 encoding
= DW_ATE_unsigned
;
10323 encoding
= DW_ATE_signed
;
10327 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
10329 if (dwarf_version
>= 3 || !dwarf_strict
)
10330 encoding
= DW_ATE_decimal_float
;
10332 encoding
= DW_ATE_lo_user
;
10335 encoding
= DW_ATE_float
;
10338 case FIXED_POINT_TYPE
:
10339 if (!(dwarf_version
>= 3 || !dwarf_strict
))
10340 encoding
= DW_ATE_lo_user
;
10341 else if (TYPE_UNSIGNED (type
))
10342 encoding
= DW_ATE_unsigned_fixed
;
10344 encoding
= DW_ATE_signed_fixed
;
10347 /* Dwarf2 doesn't know anything about complex ints, so use
10348 a user defined type for it. */
10350 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
10351 encoding
= DW_ATE_complex_float
;
10353 encoding
= DW_ATE_lo_user
;
10357 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10358 encoding
= DW_ATE_boolean
;
10362 /* No other TREE_CODEs are Dwarf fundamental types. */
10363 gcc_unreachable ();
10366 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die (), type
);
10368 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
10369 int_size_in_bytes (type
));
10370 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
10371 add_pubtype (type
, base_type_result
);
10373 return base_type_result
;
10376 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
10377 named 'auto' in its type: return true for it, false otherwise. */
10380 is_cxx_auto (tree type
)
10384 tree name
= TYPE_IDENTIFIER (type
);
10385 if (name
== get_identifier ("auto")
10386 || name
== get_identifier ("decltype(auto)"))
10392 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10393 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10396 is_base_type (tree type
)
10398 switch (TREE_CODE (type
))
10404 case FIXED_POINT_TYPE
:
10412 case QUAL_UNION_TYPE
:
10413 case ENUMERAL_TYPE
:
10414 case FUNCTION_TYPE
:
10417 case REFERENCE_TYPE
:
10425 if (is_cxx_auto (type
))
10427 gcc_unreachable ();
10433 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10434 node, return the size in bits for the type if it is a constant, or else
10435 return the alignment for the type if the type's size is not constant, or
10436 else return BITS_PER_WORD if the type actually turns out to be an
10437 ERROR_MARK node. */
10439 static inline unsigned HOST_WIDE_INT
10440 simple_type_size_in_bits (const_tree type
)
10442 if (TREE_CODE (type
) == ERROR_MARK
)
10443 return BITS_PER_WORD
;
10444 else if (TYPE_SIZE (type
) == NULL_TREE
)
10446 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
10447 return tree_to_uhwi (TYPE_SIZE (type
));
10449 return TYPE_ALIGN (type
);
10452 /* Similarly, but return an offset_int instead of UHWI. */
10454 static inline offset_int
10455 offset_int_type_size_in_bits (const_tree type
)
10457 if (TREE_CODE (type
) == ERROR_MARK
)
10458 return BITS_PER_WORD
;
10459 else if (TYPE_SIZE (type
) == NULL_TREE
)
10461 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
10462 return wi::to_offset (TYPE_SIZE (type
));
10464 return TYPE_ALIGN (type
);
10467 /* Given a pointer to a tree node for a subrange type, return a pointer
10468 to a DIE that describes the given type. */
10471 subrange_type_die (tree type
, tree low
, tree high
, dw_die_ref context_die
)
10473 dw_die_ref subrange_die
;
10474 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
10476 if (context_die
== NULL
)
10477 context_die
= comp_unit_die ();
10479 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
10481 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
10483 /* The size of the subrange type and its base type do not match,
10484 so we need to generate a size attribute for the subrange type. */
10485 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
10489 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
);
10491 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
);
10493 return subrange_die
;
10496 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10497 entry that chains various modifiers in front of the given type. */
10500 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
10501 dw_die_ref context_die
)
10503 enum tree_code code
= TREE_CODE (type
);
10504 dw_die_ref mod_type_die
;
10505 dw_die_ref sub_die
= NULL
;
10506 tree item_type
= NULL
;
10507 tree qualified_type
;
10508 tree name
, low
, high
;
10509 dw_die_ref mod_scope
;
10511 if (code
== ERROR_MARK
)
10514 /* See if we already have the appropriately qualified variant of
10517 = get_qualified_type (type
,
10518 ((is_const_type
? TYPE_QUAL_CONST
: 0)
10519 | (is_volatile_type
? TYPE_QUAL_VOLATILE
: 0)));
10521 if (qualified_type
== sizetype
10522 && TYPE_NAME (qualified_type
)
10523 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
10525 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
10527 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
10528 && TYPE_PRECISION (t
)
10529 == TYPE_PRECISION (qualified_type
)
10530 && TYPE_UNSIGNED (t
)
10531 == TYPE_UNSIGNED (qualified_type
));
10532 qualified_type
= t
;
10535 /* If we do, then we can just use its DIE, if it exists. */
10536 if (qualified_type
)
10538 mod_type_die
= lookup_type_die (qualified_type
);
10540 return mod_type_die
;
10543 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
10545 /* Handle C typedef types. */
10546 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
10547 && !DECL_ARTIFICIAL (name
))
10549 tree dtype
= TREE_TYPE (name
);
10551 if (qualified_type
== dtype
)
10553 /* For a named type, use the typedef. */
10554 gen_type_die (qualified_type
, context_die
);
10555 return lookup_type_die (qualified_type
);
10557 else if (is_const_type
< TYPE_READONLY (dtype
)
10558 || is_volatile_type
< TYPE_VOLATILE (dtype
)
10559 || (is_const_type
<= TYPE_READONLY (dtype
)
10560 && is_volatile_type
<= TYPE_VOLATILE (dtype
)
10561 && DECL_ORIGINAL_TYPE (name
) != type
))
10562 /* cv-unqualified version of named type. Just use the unnamed
10563 type to which it refers. */
10564 return modified_type_die (DECL_ORIGINAL_TYPE (name
),
10565 is_const_type
, is_volatile_type
,
10567 /* Else cv-qualified version of named type; fall through. */
10570 mod_scope
= scope_die_for (type
, context_die
);
10573 /* If both is_const_type and is_volatile_type, prefer the path
10574 which leads to a qualified type. */
10575 && (!is_volatile_type
10576 || get_qualified_type (type
, TYPE_QUAL_CONST
) == NULL_TREE
10577 || get_qualified_type (type
, TYPE_QUAL_VOLATILE
) != NULL_TREE
))
10579 mod_type_die
= new_die (DW_TAG_const_type
, mod_scope
, type
);
10580 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
10582 else if (is_volatile_type
)
10584 mod_type_die
= new_die (DW_TAG_volatile_type
, mod_scope
, type
);
10585 sub_die
= modified_type_die (type
, is_const_type
, 0, context_die
);
10587 else if (code
== POINTER_TYPE
)
10589 mod_type_die
= new_die (DW_TAG_pointer_type
, mod_scope
, type
);
10590 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10591 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10592 item_type
= TREE_TYPE (type
);
10593 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10594 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10595 TYPE_ADDR_SPACE (item_type
));
10597 else if (code
== REFERENCE_TYPE
)
10599 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
10600 mod_type_die
= new_die (DW_TAG_rvalue_reference_type
, mod_scope
,
10603 mod_type_die
= new_die (DW_TAG_reference_type
, mod_scope
, type
);
10604 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10605 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10606 item_type
= TREE_TYPE (type
);
10607 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10608 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10609 TYPE_ADDR_SPACE (item_type
));
10611 else if (code
== INTEGER_TYPE
10612 && TREE_TYPE (type
) != NULL_TREE
10613 && subrange_type_for_debug_p (type
, &low
, &high
))
10615 mod_type_die
= subrange_type_die (type
, low
, high
, context_die
);
10616 item_type
= TREE_TYPE (type
);
10618 else if (is_base_type (type
))
10619 mod_type_die
= base_type_die (type
);
10622 gen_type_die (type
, context_die
);
10624 /* We have to get the type_main_variant here (and pass that to the
10625 `lookup_type_die' routine) because the ..._TYPE node we have
10626 might simply be a *copy* of some original type node (where the
10627 copy was created to help us keep track of typedef names) and
10628 that copy might have a different TYPE_UID from the original
10630 if (TREE_CODE (type
) != VECTOR_TYPE
)
10631 return lookup_type_die (type_main_variant (type
));
10633 /* Vectors have the debugging information in the type,
10634 not the main variant. */
10635 return lookup_type_die (type
);
10638 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10639 don't output a DW_TAG_typedef, since there isn't one in the
10640 user's program; just attach a DW_AT_name to the type.
10641 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
10642 if the base type already has the same name. */
10644 && ((TREE_CODE (name
) != TYPE_DECL
10645 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
10646 || (!is_const_type
&& !is_volatile_type
)))
10647 || (TREE_CODE (name
) == TYPE_DECL
10648 && TREE_TYPE (name
) == qualified_type
10649 && DECL_NAME (name
))))
10651 if (TREE_CODE (name
) == TYPE_DECL
)
10652 /* Could just call add_name_and_src_coords_attributes here,
10653 but since this is a builtin type it doesn't have any
10654 useful source coordinates anyway. */
10655 name
= DECL_NAME (name
);
10656 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
10658 /* This probably indicates a bug. */
10659 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
10661 name
= TYPE_IDENTIFIER (type
);
10662 add_name_attribute (mod_type_die
,
10663 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
10666 if (qualified_type
)
10667 equate_type_number_to_die (qualified_type
, mod_type_die
);
10670 /* We must do this after the equate_type_number_to_die call, in case
10671 this is a recursive type. This ensures that the modified_type_die
10672 recursion will terminate even if the type is recursive. Recursive
10673 types are possible in Ada. */
10674 sub_die
= modified_type_die (item_type
,
10675 TYPE_READONLY (item_type
),
10676 TYPE_VOLATILE (item_type
),
10679 if (sub_die
!= NULL
)
10680 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
10682 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
10683 if (TYPE_ARTIFICIAL (type
))
10684 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
10686 return mod_type_die
;
10689 /* Generate DIEs for the generic parameters of T.
10690 T must be either a generic type or a generic function.
10691 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10694 gen_generic_params_dies (tree t
)
10698 dw_die_ref die
= NULL
;
10701 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
10705 die
= lookup_type_die (t
);
10706 else if (DECL_P (t
))
10707 die
= lookup_decl_die (t
);
10711 parms
= lang_hooks
.get_innermost_generic_parms (t
);
10713 /* T has no generic parameter. It means T is neither a generic type
10714 or function. End of story. */
10717 parms_num
= TREE_VEC_LENGTH (parms
);
10718 args
= lang_hooks
.get_innermost_generic_args (t
);
10719 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
10720 non_default
= int_cst_value (TREE_CHAIN (args
));
10722 non_default
= TREE_VEC_LENGTH (args
);
10723 for (i
= 0; i
< parms_num
; i
++)
10725 tree parm
, arg
, arg_pack_elems
;
10726 dw_die_ref parm_die
;
10728 parm
= TREE_VEC_ELT (parms
, i
);
10729 arg
= TREE_VEC_ELT (args
, i
);
10730 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
10731 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
10733 if (parm
&& TREE_VALUE (parm
) && arg
)
10735 /* If PARM represents a template parameter pack,
10736 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10737 by DW_TAG_template_*_parameter DIEs for the argument
10738 pack elements of ARG. Note that ARG would then be
10739 an argument pack. */
10740 if (arg_pack_elems
)
10741 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
10745 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
10746 true /* emit name */, die
);
10747 if (i
>= non_default
)
10748 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
10753 /* Create and return a DIE for PARM which should be
10754 the representation of a generic type parameter.
10755 For instance, in the C++ front end, PARM would be a template parameter.
10756 ARG is the argument to PARM.
10757 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10759 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10760 as a child node. */
10763 generic_parameter_die (tree parm
, tree arg
,
10765 dw_die_ref parent_die
)
10767 dw_die_ref tmpl_die
= NULL
;
10768 const char *name
= NULL
;
10770 if (!parm
|| !DECL_NAME (parm
) || !arg
)
10773 /* We support non-type generic parameters and arguments,
10774 type generic parameters and arguments, as well as
10775 generic generic parameters (a.k.a. template template parameters in C++)
10777 if (TREE_CODE (parm
) == PARM_DECL
)
10778 /* PARM is a nontype generic parameter */
10779 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
10780 else if (TREE_CODE (parm
) == TYPE_DECL
)
10781 /* PARM is a type generic parameter. */
10782 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
10783 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10784 /* PARM is a generic generic parameter.
10785 Its DIE is a GNU extension. It shall have a
10786 DW_AT_name attribute to represent the name of the template template
10787 parameter, and a DW_AT_GNU_template_name attribute to represent the
10788 name of the template template argument. */
10789 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
10792 gcc_unreachable ();
10798 /* If PARM is a generic parameter pack, it means we are
10799 emitting debug info for a template argument pack element.
10800 In other terms, ARG is a template argument pack element.
10801 In that case, we don't emit any DW_AT_name attribute for
10805 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
10807 add_AT_string (tmpl_die
, DW_AT_name
, name
);
10810 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10812 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10813 TMPL_DIE should have a child DW_AT_type attribute that is set
10814 to the type of the argument to PARM, which is ARG.
10815 If PARM is a type generic parameter, TMPL_DIE should have a
10816 child DW_AT_type that is set to ARG. */
10817 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
10818 add_type_attribute (tmpl_die
, tmpl_type
, 0,
10819 TREE_THIS_VOLATILE (tmpl_type
),
10824 /* So TMPL_DIE is a DIE representing a
10825 a generic generic template parameter, a.k.a template template
10826 parameter in C++ and arg is a template. */
10828 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10829 to the name of the argument. */
10830 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
10832 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
10835 if (TREE_CODE (parm
) == PARM_DECL
)
10836 /* So PARM is a non-type generic parameter.
10837 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10838 attribute of TMPL_DIE which value represents the value
10840 We must be careful here:
10841 The value of ARG might reference some function decls.
10842 We might currently be emitting debug info for a generic
10843 type and types are emitted before function decls, we don't
10844 know if the function decls referenced by ARG will actually be
10845 emitted after cgraph computations.
10846 So must defer the generation of the DW_AT_const_value to
10847 after cgraph is ready. */
10848 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
10854 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
10855 PARM_PACK must be a template parameter pack. The returned DIE
10856 will be child DIE of PARENT_DIE. */
10859 template_parameter_pack_die (tree parm_pack
,
10860 tree parm_pack_args
,
10861 dw_die_ref parent_die
)
10866 gcc_assert (parent_die
&& parm_pack
);
10868 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
10869 add_name_and_src_coords_attributes (die
, parm_pack
);
10870 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
10871 generic_parameter_die (parm_pack
,
10872 TREE_VEC_ELT (parm_pack_args
, j
),
10873 false /* Don't emit DW_AT_name */,
10878 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10879 an enumerated type. */
10882 type_is_enum (const_tree type
)
10884 return TREE_CODE (type
) == ENUMERAL_TYPE
;
10887 /* Return the DBX register number described by a given RTL node. */
10889 static unsigned int
10890 dbx_reg_number (const_rtx rtl
)
10892 unsigned regno
= REGNO (rtl
);
10894 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
10896 #ifdef LEAF_REG_REMAP
10897 if (crtl
->uses_only_leaf_regs
)
10899 int leaf_reg
= LEAF_REG_REMAP (regno
);
10900 if (leaf_reg
!= -1)
10901 regno
= (unsigned) leaf_reg
;
10905 regno
= DBX_REGISTER_NUMBER (regno
);
10906 gcc_assert (regno
!= INVALID_REGNUM
);
10910 /* Optionally add a DW_OP_piece term to a location description expression.
10911 DW_OP_piece is only added if the location description expression already
10912 doesn't end with DW_OP_piece. */
10915 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
10917 dw_loc_descr_ref loc
;
10919 if (*list_head
!= NULL
)
10921 /* Find the end of the chain. */
10922 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
10925 if (loc
->dw_loc_opc
!= DW_OP_piece
)
10926 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
10930 /* Return a location descriptor that designates a machine register or
10931 zero if there is none. */
10933 static dw_loc_descr_ref
10934 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
10938 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
10941 /* We only use "frame base" when we're sure we're talking about the
10942 post-prologue local stack frame. We do this by *not* running
10943 register elimination until this point, and recognizing the special
10944 argument pointer and soft frame pointer rtx's.
10945 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
10946 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
10947 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
10949 dw_loc_descr_ref result
= NULL
;
10951 if (dwarf_version
>= 4 || !dwarf_strict
)
10953 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
10956 add_loc_descr (&result
,
10957 new_loc_descr (DW_OP_stack_value
, 0, 0));
10962 regs
= targetm
.dwarf_register_span (rtl
);
10964 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1 || regs
)
10965 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
10968 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
10969 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
10971 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
10975 /* Return a location descriptor that designates a machine register for
10976 a given hard register number. */
10978 static dw_loc_descr_ref
10979 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
10981 dw_loc_descr_ref reg_loc_descr
;
10985 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
10987 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
10989 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10990 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10992 return reg_loc_descr
;
10995 /* Given an RTL of a register, return a location descriptor that
10996 designates a value that spans more than one register. */
10998 static dw_loc_descr_ref
10999 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
11000 enum var_init_status initialized
)
11003 dw_loc_descr_ref loc_result
= NULL
;
11005 /* Simple, contiguous registers. */
11006 if (regs
== NULL_RTX
)
11008 unsigned reg
= REGNO (rtl
);
11011 #ifdef LEAF_REG_REMAP
11012 if (crtl
->uses_only_leaf_regs
)
11014 int leaf_reg
= LEAF_REG_REMAP (reg
);
11015 if (leaf_reg
!= -1)
11016 reg
= (unsigned) leaf_reg
;
11020 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
11021 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
11023 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
11028 dw_loc_descr_ref t
;
11030 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
11031 VAR_INIT_STATUS_INITIALIZED
);
11032 add_loc_descr (&loc_result
, t
);
11033 add_loc_descr_op_piece (&loc_result
, size
);
11039 /* Now onto stupid register sets in non contiguous locations. */
11041 gcc_assert (GET_CODE (regs
) == PARALLEL
);
11043 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
11046 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
11048 dw_loc_descr_ref t
;
11050 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
11051 VAR_INIT_STATUS_INITIALIZED
);
11052 add_loc_descr (&loc_result
, t
);
11053 add_loc_descr_op_piece (&loc_result
, size
);
11056 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11057 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11061 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
11063 /* Return a location descriptor that designates a constant i,
11064 as a compound operation from constant (i >> shift), constant shift
11067 static dw_loc_descr_ref
11068 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11070 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
11071 add_loc_descr (&ret
, int_loc_descriptor (shift
));
11072 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
11076 /* Return a location descriptor that designates a constant. */
11078 static dw_loc_descr_ref
11079 int_loc_descriptor (HOST_WIDE_INT i
)
11081 enum dwarf_location_atom op
;
11083 /* Pick the smallest representation of a constant, rather than just
11084 defaulting to the LEB encoding. */
11087 int clz
= clz_hwi (i
);
11088 int ctz
= ctz_hwi (i
);
11090 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
11091 else if (i
<= 0xff)
11092 op
= DW_OP_const1u
;
11093 else if (i
<= 0xffff)
11094 op
= DW_OP_const2u
;
11095 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11096 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11097 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
11098 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
11099 while DW_OP_const4u is 5 bytes. */
11100 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
11101 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11102 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11103 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
11104 while DW_OP_const4u is 5 bytes. */
11105 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11106 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11107 op
= DW_OP_const4u
;
11108 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11109 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11110 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
11111 while DW_OP_constu of constant >= 0x100000000 takes at least
11113 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11114 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11115 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
11116 >= HOST_BITS_PER_WIDE_INT
)
11117 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
11118 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
11119 while DW_OP_constu takes in this case at least 6 bytes. */
11120 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
11121 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11122 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11123 && size_of_uleb128 (i
) > 6)
11124 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
11125 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
11132 op
= DW_OP_const1s
;
11133 else if (i
>= -0x8000)
11134 op
= DW_OP_const2s
;
11135 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11137 if (size_of_int_loc_descriptor (i
) < 5)
11139 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11140 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11143 op
= DW_OP_const4s
;
11147 if (size_of_int_loc_descriptor (i
)
11148 < (unsigned long) 1 + size_of_sleb128 (i
))
11150 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11151 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11158 return new_loc_descr (op
, i
, 0);
11161 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
11162 without actually allocating it. */
11164 static unsigned long
11165 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11167 return size_of_int_loc_descriptor (i
>> shift
)
11168 + size_of_int_loc_descriptor (shift
)
11172 /* Return size_of_locs (int_loc_descriptor (i)) without
11173 actually allocating it. */
11175 static unsigned long
11176 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
11185 else if (i
<= 0xff)
11187 else if (i
<= 0xffff)
11191 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11192 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11193 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11195 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11196 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11197 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11199 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11201 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
11202 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11203 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11204 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11206 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11207 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
11208 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11210 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11211 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11213 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11222 else if (i
>= -0x8000)
11224 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11226 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11228 s
= size_of_int_loc_descriptor (-i
) + 1;
11236 unsigned long r
= 1 + size_of_sleb128 (i
);
11237 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11239 s
= size_of_int_loc_descriptor (-i
) + 1;
11248 /* Return loc description representing "address" of integer value.
11249 This can appear only as toplevel expression. */
11251 static dw_loc_descr_ref
11252 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
11255 dw_loc_descr_ref loc_result
= NULL
;
11257 if (!(dwarf_version
>= 4 || !dwarf_strict
))
11260 litsize
= size_of_int_loc_descriptor (i
);
11261 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11262 is more compact. For DW_OP_stack_value we need:
11263 litsize + 1 (DW_OP_stack_value)
11264 and for DW_OP_implicit_value:
11265 1 (DW_OP_implicit_value) + 1 (length) + size. */
11266 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
11268 loc_result
= int_loc_descriptor (i
);
11269 add_loc_descr (&loc_result
,
11270 new_loc_descr (DW_OP_stack_value
, 0, 0));
11274 loc_result
= new_loc_descr (DW_OP_implicit_value
,
11276 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
11277 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
11281 /* Return a location descriptor that designates a base+offset location. */
11283 static dw_loc_descr_ref
11284 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
11285 enum var_init_status initialized
)
11287 unsigned int regno
;
11288 dw_loc_descr_ref result
;
11289 dw_fde_ref fde
= cfun
->fde
;
11291 /* We only use "frame base" when we're sure we're talking about the
11292 post-prologue local stack frame. We do this by *not* running
11293 register elimination until this point, and recognizing the special
11294 argument pointer and soft frame pointer rtx's. */
11295 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
11297 rtx elim
= (ira_use_lra_p
11298 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
11299 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
11303 if (GET_CODE (elim
) == PLUS
)
11305 offset
+= INTVAL (XEXP (elim
, 1));
11306 elim
= XEXP (elim
, 0);
11308 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
11309 && (elim
== hard_frame_pointer_rtx
11310 || elim
== stack_pointer_rtx
))
11311 || elim
== (frame_pointer_needed
11312 ? hard_frame_pointer_rtx
11313 : stack_pointer_rtx
));
11315 /* If drap register is used to align stack, use frame
11316 pointer + offset to access stack variables. If stack
11317 is aligned without drap, use stack pointer + offset to
11318 access stack variables. */
11319 if (crtl
->stack_realign_tried
11320 && reg
== frame_pointer_rtx
)
11323 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
11324 ? HARD_FRAME_POINTER_REGNUM
11326 return new_reg_loc_descr (base_reg
, offset
);
11329 gcc_assert (frame_pointer_fb_offset_valid
);
11330 offset
+= frame_pointer_fb_offset
;
11331 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11335 regno
= REGNO (reg
);
11336 #ifdef LEAF_REG_REMAP
11337 if (crtl
->uses_only_leaf_regs
)
11339 int leaf_reg
= LEAF_REG_REMAP (regno
);
11340 if (leaf_reg
!= -1)
11341 regno
= (unsigned) leaf_reg
;
11344 regno
= DWARF_FRAME_REGNUM (regno
);
11346 if (!optimize
&& fde
11347 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
))
11349 /* Use cfa+offset to represent the location of arguments passed
11350 on the stack when drap is used to align stack.
11351 Only do this when not optimizing, for optimized code var-tracking
11352 is supposed to track where the arguments live and the register
11353 used as vdrap or drap in some spot might be used for something
11354 else in other part of the routine. */
11355 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11359 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
11362 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
11364 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11365 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11370 /* Return true if this RTL expression describes a base+offset calculation. */
11373 is_based_loc (const_rtx rtl
)
11375 return (GET_CODE (rtl
) == PLUS
11376 && ((REG_P (XEXP (rtl
, 0))
11377 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
11378 && CONST_INT_P (XEXP (rtl
, 1)))));
11381 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11384 static dw_loc_descr_ref
11385 tls_mem_loc_descriptor (rtx mem
)
11388 dw_loc_descr_ref loc_result
;
11390 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
11393 base
= get_base_address (MEM_EXPR (mem
));
11395 || TREE_CODE (base
) != VAR_DECL
11396 || !DECL_THREAD_LOCAL_P (base
))
11399 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1);
11400 if (loc_result
== NULL
)
11403 if (MEM_OFFSET (mem
))
11404 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
11409 /* Output debug info about reason why we failed to expand expression as dwarf
11413 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
11415 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
11417 fprintf (dump_file
, "Failed to expand as dwarf: ");
11419 print_generic_expr (dump_file
, expr
, dump_flags
);
11422 fprintf (dump_file
, "\n");
11423 print_rtl (dump_file
, rtl
);
11425 fprintf (dump_file
, "\nReason: %s\n", reason
);
11429 /* Helper function for const_ok_for_output, called either directly
11430 or via for_each_rtx. */
11433 const_ok_for_output_1 (rtx
*rtlp
, void *data ATTRIBUTE_UNUSED
)
11437 if (GET_CODE (rtl
) == UNSPEC
)
11439 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
11440 we can't express it in the debug info. */
11441 #ifdef ENABLE_CHECKING
11442 /* Don't complain about TLS UNSPECs, those are just too hard to
11443 delegitimize. Note this could be a non-decl SYMBOL_REF such as
11444 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
11445 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
11446 if (XVECLEN (rtl
, 0) == 0
11447 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
11448 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
)
11449 inform (current_function_decl
11450 ? DECL_SOURCE_LOCATION (current_function_decl
)
11451 : UNKNOWN_LOCATION
,
11452 #if NUM_UNSPEC_VALUES > 0
11453 "non-delegitimized UNSPEC %s (%d) found in variable location",
11454 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
11455 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
11458 "non-delegitimized UNSPEC %d found in variable location",
11462 expansion_failed (NULL_TREE
, rtl
,
11463 "UNSPEC hasn't been delegitimized.\n");
11467 if (targetm
.const_not_ok_for_debug_p (rtl
))
11469 expansion_failed (NULL_TREE
, rtl
,
11470 "Expression rejected for debug by the backend.\n");
11474 /* FIXME: Refer to PR60655. It is possible for simplification
11475 of rtl expressions in var tracking to produce such expressions.
11476 We should really identify / validate expressions
11477 enclosed in CONST that can be handled by assemblers on various
11478 targets and only handle legitimate cases here. */
11479 if (GET_CODE (rtl
) != SYMBOL_REF
)
11481 if (GET_CODE (rtl
) == NOT
)
11487 if (CONSTANT_POOL_ADDRESS_P (rtl
))
11490 get_pool_constant_mark (rtl
, &marked
);
11491 /* If all references to this pool constant were optimized away,
11492 it was not output and thus we can't represent it. */
11495 expansion_failed (NULL_TREE
, rtl
,
11496 "Constant was removed from constant pool.\n");
11501 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
11504 /* Avoid references to external symbols in debug info, on several targets
11505 the linker might even refuse to link when linking a shared library,
11506 and in many other cases the relocations for .debug_info/.debug_loc are
11507 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
11508 to be defined within the same shared library or executable are fine. */
11509 if (SYMBOL_REF_EXTERNAL_P (rtl
))
11511 tree decl
= SYMBOL_REF_DECL (rtl
);
11513 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
11515 expansion_failed (NULL_TREE
, rtl
,
11516 "Symbol not defined in current TU.\n");
11524 /* Return true if constant RTL can be emitted in DW_OP_addr or
11525 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
11526 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
11529 const_ok_for_output (rtx rtl
)
11531 if (GET_CODE (rtl
) == SYMBOL_REF
)
11532 return const_ok_for_output_1 (&rtl
, NULL
) == 0;
11534 if (GET_CODE (rtl
) == CONST
)
11535 return for_each_rtx (&XEXP (rtl
, 0), const_ok_for_output_1
, NULL
) == 0;
11540 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
11541 if possible, NULL otherwise. */
11544 base_type_for_mode (enum machine_mode mode
, bool unsignedp
)
11546 dw_die_ref type_die
;
11547 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
11551 switch (TREE_CODE (type
))
11559 type_die
= lookup_type_die (type
);
11561 type_die
= modified_type_die (type
, false, false, comp_unit_die ());
11562 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
11567 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
11568 type matching MODE, or, if MODE is narrower than or as wide as
11569 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
11572 static dw_loc_descr_ref
11573 convert_descriptor_to_mode (enum machine_mode mode
, dw_loc_descr_ref op
)
11575 enum machine_mode outer_mode
= mode
;
11576 dw_die_ref type_die
;
11577 dw_loc_descr_ref cvt
;
11579 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
11581 add_loc_descr (&op
, new_loc_descr (DW_OP_GNU_convert
, 0, 0));
11584 type_die
= base_type_for_mode (outer_mode
, 1);
11585 if (type_die
== NULL
)
11587 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11588 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11589 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11590 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11591 add_loc_descr (&op
, cvt
);
11595 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
11597 static dw_loc_descr_ref
11598 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
11599 dw_loc_descr_ref op1
)
11601 dw_loc_descr_ref ret
= op0
;
11602 add_loc_descr (&ret
, op1
);
11603 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11604 if (STORE_FLAG_VALUE
!= 1)
11606 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
11607 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
11612 /* Return location descriptor for signed comparison OP RTL. */
11614 static dw_loc_descr_ref
11615 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11616 enum machine_mode mem_mode
)
11618 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11619 dw_loc_descr_ref op0
, op1
;
11622 if (op_mode
== VOIDmode
)
11623 op_mode
= GET_MODE (XEXP (rtl
, 1));
11624 if (op_mode
== VOIDmode
)
11628 && (GET_MODE_CLASS (op_mode
) != MODE_INT
11629 || GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
))
11632 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11633 VAR_INIT_STATUS_INITIALIZED
);
11634 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11635 VAR_INIT_STATUS_INITIALIZED
);
11637 if (op0
== NULL
|| op1
== NULL
)
11640 if (GET_MODE_CLASS (op_mode
) != MODE_INT
11641 || GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11642 return compare_loc_descriptor (op
, op0
, op1
);
11644 if (GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11646 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
11647 dw_loc_descr_ref cvt
;
11649 if (type_die
== NULL
)
11651 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11652 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11653 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11654 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11655 add_loc_descr (&op0
, cvt
);
11656 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11657 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11658 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11659 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11660 add_loc_descr (&op1
, cvt
);
11661 return compare_loc_descriptor (op
, op0
, op1
);
11664 shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
11665 /* For eq/ne, if the operands are known to be zero-extended,
11666 there is no need to do the fancy shifting up. */
11667 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
11669 dw_loc_descr_ref last0
, last1
;
11670 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11672 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11674 /* deref_size zero extends, and for constants we can check
11675 whether they are zero extended or not. */
11676 if (((last0
->dw_loc_opc
== DW_OP_deref_size
11677 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11678 || (CONST_INT_P (XEXP (rtl
, 0))
11679 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
11680 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
11681 && ((last1
->dw_loc_opc
== DW_OP_deref_size
11682 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11683 || (CONST_INT_P (XEXP (rtl
, 1))
11684 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
11685 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
11686 return compare_loc_descriptor (op
, op0
, op1
);
11688 /* EQ/NE comparison against constant in narrower type than
11689 DWARF2_ADDR_SIZE can be performed either as
11690 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
11693 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
11694 DW_OP_{eq,ne}. Pick whatever is shorter. */
11695 if (CONST_INT_P (XEXP (rtl
, 1))
11696 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
11697 && (size_of_int_loc_descriptor (shift
) + 1
11698 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
)
11699 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
11700 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11701 & GET_MODE_MASK (op_mode
))))
11703 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
11704 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11705 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11706 & GET_MODE_MASK (op_mode
));
11707 return compare_loc_descriptor (op
, op0
, op1
);
11710 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11711 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11712 if (CONST_INT_P (XEXP (rtl
, 1)))
11713 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
);
11716 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11717 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11719 return compare_loc_descriptor (op
, op0
, op1
);
11722 /* Return location descriptor for unsigned comparison OP RTL. */
11724 static dw_loc_descr_ref
11725 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11726 enum machine_mode mem_mode
)
11728 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11729 dw_loc_descr_ref op0
, op1
;
11731 if (op_mode
== VOIDmode
)
11732 op_mode
= GET_MODE (XEXP (rtl
, 1));
11733 if (op_mode
== VOIDmode
)
11735 if (GET_MODE_CLASS (op_mode
) != MODE_INT
)
11738 if (dwarf_strict
&& GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11741 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11742 VAR_INIT_STATUS_INITIALIZED
);
11743 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11744 VAR_INIT_STATUS_INITIALIZED
);
11746 if (op0
== NULL
|| op1
== NULL
)
11749 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
11751 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
11752 dw_loc_descr_ref last0
, last1
;
11753 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11755 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11757 if (CONST_INT_P (XEXP (rtl
, 0)))
11758 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
11759 /* deref_size zero extends, so no need to mask it again. */
11760 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
11761 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11763 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11764 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11766 if (CONST_INT_P (XEXP (rtl
, 1)))
11767 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
11768 /* deref_size zero extends, so no need to mask it again. */
11769 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
11770 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11772 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11773 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11776 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11778 HOST_WIDE_INT bias
= 1;
11779 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11780 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11781 if (CONST_INT_P (XEXP (rtl
, 1)))
11782 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
11783 + INTVAL (XEXP (rtl
, 1)));
11785 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
11788 return compare_loc_descriptor (op
, op0
, op1
);
11791 /* Return location descriptor for {U,S}{MIN,MAX}. */
11793 static dw_loc_descr_ref
11794 minmax_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11795 enum machine_mode mem_mode
)
11797 enum dwarf_location_atom op
;
11798 dw_loc_descr_ref op0
, op1
, ret
;
11799 dw_loc_descr_ref bra_node
, drop_node
;
11802 && (GET_MODE_CLASS (mode
) != MODE_INT
11803 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
))
11806 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11807 VAR_INIT_STATUS_INITIALIZED
);
11808 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11809 VAR_INIT_STATUS_INITIALIZED
);
11811 if (op0
== NULL
|| op1
== NULL
)
11814 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
11815 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
11816 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
11817 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
11819 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11821 HOST_WIDE_INT mask
= GET_MODE_MASK (mode
);
11822 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11823 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11824 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11825 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11827 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
11829 HOST_WIDE_INT bias
= 1;
11830 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11831 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11832 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11835 else if (GET_MODE_CLASS (mode
) == MODE_INT
11836 && GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11838 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (mode
)) * BITS_PER_UNIT
;
11839 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11840 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11841 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11842 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11844 else if (GET_MODE_CLASS (mode
) == MODE_INT
11845 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11847 dw_die_ref type_die
= base_type_for_mode (mode
, 0);
11848 dw_loc_descr_ref cvt
;
11849 if (type_die
== NULL
)
11851 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11852 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11853 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11854 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11855 add_loc_descr (&op0
, cvt
);
11856 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11857 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11858 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11859 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11860 add_loc_descr (&op1
, cvt
);
11863 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
11868 add_loc_descr (&ret
, op1
);
11869 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11870 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
11871 add_loc_descr (&ret
, bra_node
);
11872 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11873 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
11874 add_loc_descr (&ret
, drop_node
);
11875 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11876 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
11877 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
11878 && GET_MODE_CLASS (mode
) == MODE_INT
11879 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11880 ret
= convert_descriptor_to_mode (mode
, ret
);
11884 /* Helper function for mem_loc_descriptor. Perform OP binary op,
11885 but after converting arguments to type_die, afterwards
11886 convert back to unsigned. */
11888 static dw_loc_descr_ref
11889 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
11890 enum machine_mode mode
, enum machine_mode mem_mode
)
11892 dw_loc_descr_ref cvt
, op0
, op1
;
11894 if (type_die
== NULL
)
11896 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11897 VAR_INIT_STATUS_INITIALIZED
);
11898 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11899 VAR_INIT_STATUS_INITIALIZED
);
11900 if (op0
== NULL
|| op1
== NULL
)
11902 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11903 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11904 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11905 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11906 add_loc_descr (&op0
, cvt
);
11907 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11908 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11909 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11910 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11911 add_loc_descr (&op1
, cvt
);
11912 add_loc_descr (&op0
, op1
);
11913 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
11914 return convert_descriptor_to_mode (mode
, op0
);
11917 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
11918 const0 is DW_OP_lit0 or corresponding typed constant,
11919 const1 is DW_OP_lit1 or corresponding typed constant
11920 and constMSB is constant with just the MSB bit set
11922 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11923 L1: const0 DW_OP_swap
11924 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
11925 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11930 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11931 L1: const0 DW_OP_swap
11932 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11933 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11938 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
11939 L1: const1 DW_OP_swap
11940 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11941 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11945 static dw_loc_descr_ref
11946 clz_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11947 enum machine_mode mem_mode
)
11949 dw_loc_descr_ref op0
, ret
, tmp
;
11950 HOST_WIDE_INT valv
;
11951 dw_loc_descr_ref l1jump
, l1label
;
11952 dw_loc_descr_ref l2jump
, l2label
;
11953 dw_loc_descr_ref l3jump
, l3label
;
11954 dw_loc_descr_ref l4jump
, l4label
;
11957 if (GET_MODE_CLASS (mode
) != MODE_INT
11958 || GET_MODE (XEXP (rtl
, 0)) != mode
)
11961 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11962 VAR_INIT_STATUS_INITIALIZED
);
11966 if (GET_CODE (rtl
) == CLZ
)
11968 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11969 valv
= GET_MODE_BITSIZE (mode
);
11971 else if (GET_CODE (rtl
) == FFS
)
11973 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11974 valv
= GET_MODE_BITSIZE (mode
);
11975 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11976 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11977 add_loc_descr (&ret
, l1jump
);
11978 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
11979 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
11980 VAR_INIT_STATUS_INITIALIZED
);
11983 add_loc_descr (&ret
, tmp
);
11984 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11985 add_loc_descr (&ret
, l4jump
);
11986 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
11987 ? const1_rtx
: const0_rtx
,
11989 VAR_INIT_STATUS_INITIALIZED
);
11990 if (l1label
== NULL
)
11992 add_loc_descr (&ret
, l1label
);
11993 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11994 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
11995 add_loc_descr (&ret
, l2label
);
11996 if (GET_CODE (rtl
) != CLZ
)
11998 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
11999 msb
= GEN_INT ((unsigned HOST_WIDE_INT
) 1
12000 << (GET_MODE_BITSIZE (mode
) - 1));
12002 msb
= immed_wide_int_const
12003 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
12004 GET_MODE_PRECISION (mode
)), mode
);
12005 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
12006 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12007 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
12008 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
12010 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
12011 VAR_INIT_STATUS_INITIALIZED
);
12014 add_loc_descr (&ret
, tmp
);
12015 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12016 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12017 add_loc_descr (&ret
, l3jump
);
12018 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12019 VAR_INIT_STATUS_INITIALIZED
);
12022 add_loc_descr (&ret
, tmp
);
12023 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
12024 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
12025 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12026 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
12027 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12028 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12029 add_loc_descr (&ret
, l2jump
);
12030 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
12031 add_loc_descr (&ret
, l3label
);
12032 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
12033 add_loc_descr (&ret
, l4label
);
12034 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12035 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12036 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12037 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12038 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12039 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
12040 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12041 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
12045 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
12046 const1 is DW_OP_lit1 or corresponding typed constant):
12048 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12049 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12053 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12054 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12057 static dw_loc_descr_ref
12058 popcount_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12059 enum machine_mode mem_mode
)
12061 dw_loc_descr_ref op0
, ret
, tmp
;
12062 dw_loc_descr_ref l1jump
, l1label
;
12063 dw_loc_descr_ref l2jump
, l2label
;
12065 if (GET_MODE_CLASS (mode
) != MODE_INT
12066 || GET_MODE (XEXP (rtl
, 0)) != mode
)
12069 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12070 VAR_INIT_STATUS_INITIALIZED
);
12074 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12075 VAR_INIT_STATUS_INITIALIZED
);
12078 add_loc_descr (&ret
, tmp
);
12079 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12080 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
12081 add_loc_descr (&ret
, l1label
);
12082 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12083 add_loc_descr (&ret
, l2jump
);
12084 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12085 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
12086 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12087 VAR_INIT_STATUS_INITIALIZED
);
12090 add_loc_descr (&ret
, tmp
);
12091 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12092 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
12093 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
12094 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12095 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12096 VAR_INIT_STATUS_INITIALIZED
);
12097 add_loc_descr (&ret
, tmp
);
12098 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12099 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12100 add_loc_descr (&ret
, l1jump
);
12101 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
12102 add_loc_descr (&ret
, l2label
);
12103 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12104 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12105 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12106 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12110 /* BSWAP (constS is initial shift count, either 56 or 24):
12112 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
12113 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
12114 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
12115 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
12116 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
12118 static dw_loc_descr_ref
12119 bswap_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12120 enum machine_mode mem_mode
)
12122 dw_loc_descr_ref op0
, ret
, tmp
;
12123 dw_loc_descr_ref l1jump
, l1label
;
12124 dw_loc_descr_ref l2jump
, l2label
;
12126 if (GET_MODE_CLASS (mode
) != MODE_INT
12127 || BITS_PER_UNIT
!= 8
12128 || (GET_MODE_BITSIZE (mode
) != 32
12129 && GET_MODE_BITSIZE (mode
) != 64))
12132 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12133 VAR_INIT_STATUS_INITIALIZED
);
12138 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12140 VAR_INIT_STATUS_INITIALIZED
);
12143 add_loc_descr (&ret
, tmp
);
12144 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12145 VAR_INIT_STATUS_INITIALIZED
);
12148 add_loc_descr (&ret
, tmp
);
12149 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
12150 add_loc_descr (&ret
, l1label
);
12151 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12153 VAR_INIT_STATUS_INITIALIZED
);
12154 add_loc_descr (&ret
, tmp
);
12155 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
12156 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12157 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12158 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
12159 VAR_INIT_STATUS_INITIALIZED
);
12162 add_loc_descr (&ret
, tmp
);
12163 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12164 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
12165 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12166 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12167 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12168 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12169 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12170 VAR_INIT_STATUS_INITIALIZED
);
12171 add_loc_descr (&ret
, tmp
);
12172 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
12173 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12174 add_loc_descr (&ret
, l2jump
);
12175 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
12176 VAR_INIT_STATUS_INITIALIZED
);
12177 add_loc_descr (&ret
, tmp
);
12178 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12179 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12180 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12181 add_loc_descr (&ret
, l1jump
);
12182 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
12183 add_loc_descr (&ret
, l2label
);
12184 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12185 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
12186 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12187 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12188 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12189 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12193 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
12194 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12195 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
12196 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
12198 ROTATERT is similar:
12199 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
12200 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12201 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
12203 static dw_loc_descr_ref
12204 rotate_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12205 enum machine_mode mem_mode
)
12207 rtx rtlop1
= XEXP (rtl
, 1);
12208 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
12211 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12214 if (GET_MODE (rtlop1
) != VOIDmode
12215 && GET_MODE_BITSIZE (GET_MODE (rtlop1
)) < GET_MODE_BITSIZE (mode
))
12216 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12217 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12218 VAR_INIT_STATUS_INITIALIZED
);
12219 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12220 VAR_INIT_STATUS_INITIALIZED
);
12221 if (op0
== NULL
|| op1
== NULL
)
12223 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
12224 for (i
= 0; i
< 2; i
++)
12226 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
12227 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
12229 VAR_INIT_STATUS_INITIALIZED
);
12230 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12231 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12233 : HOST_BITS_PER_WIDE_INT
== 64
12234 ? DW_OP_const8u
: DW_OP_constu
,
12235 GET_MODE_MASK (mode
), 0);
12238 if (mask
[i
] == NULL
)
12240 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
12243 add_loc_descr (&ret
, op1
);
12244 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12245 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12246 if (GET_CODE (rtl
) == ROTATERT
)
12248 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12249 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12250 GET_MODE_BITSIZE (mode
), 0));
12252 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12253 if (mask
[0] != NULL
)
12254 add_loc_descr (&ret
, mask
[0]);
12255 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
12256 if (mask
[1] != NULL
)
12258 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12259 add_loc_descr (&ret
, mask
[1]);
12260 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12262 if (GET_CODE (rtl
) == ROTATE
)
12264 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12265 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12266 GET_MODE_BITSIZE (mode
), 0));
12268 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12269 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12273 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
12274 for DEBUG_PARAMETER_REF RTL. */
12276 static dw_loc_descr_ref
12277 parameter_ref_descriptor (rtx rtl
)
12279 dw_loc_descr_ref ret
;
12284 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
12285 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
12286 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
12289 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12290 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
12291 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12295 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
12296 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
12301 /* The following routine converts the RTL for a variable or parameter
12302 (resident in memory) into an equivalent Dwarf representation of a
12303 mechanism for getting the address of that same variable onto the top of a
12304 hypothetical "address evaluation" stack.
12306 When creating memory location descriptors, we are effectively transforming
12307 the RTL for a memory-resident object into its Dwarf postfix expression
12308 equivalent. This routine recursively descends an RTL tree, turning
12309 it into Dwarf postfix code as it goes.
12311 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
12313 MEM_MODE is the mode of the memory reference, needed to handle some
12314 autoincrement addressing modes.
12316 Return 0 if we can't represent the location. */
12319 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12320 enum machine_mode mem_mode
,
12321 enum var_init_status initialized
)
12323 dw_loc_descr_ref mem_loc_result
= NULL
;
12324 enum dwarf_location_atom op
;
12325 dw_loc_descr_ref op0
, op1
;
12326 rtx inner
= NULL_RTX
;
12328 if (mode
== VOIDmode
)
12329 mode
= GET_MODE (rtl
);
12331 /* Note that for a dynamically sized array, the location we will generate a
12332 description of here will be the lowest numbered location which is
12333 actually within the array. That's *not* necessarily the same as the
12334 zeroth element of the array. */
12336 rtl
= targetm
.delegitimize_address (rtl
);
12338 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
12341 switch (GET_CODE (rtl
))
12346 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
12349 /* The case of a subreg may arise when we have a local (register)
12350 variable or a formal (register) parameter which doesn't quite fill
12351 up an entire register. For now, just assume that it is
12352 legitimate to make the Dwarf info refer to the whole register which
12353 contains the given subreg. */
12354 if (!subreg_lowpart_p (rtl
))
12356 inner
= SUBREG_REG (rtl
);
12358 if (inner
== NULL_RTX
)
12359 inner
= XEXP (rtl
, 0);
12360 if (GET_MODE_CLASS (mode
) == MODE_INT
12361 && GET_MODE_CLASS (GET_MODE (inner
)) == MODE_INT
12362 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12363 #ifdef POINTERS_EXTEND_UNSIGNED
12364 || (mode
== Pmode
&& mem_mode
!= VOIDmode
)
12367 && GET_MODE_SIZE (GET_MODE (inner
)) <= DWARF2_ADDR_SIZE
)
12369 mem_loc_result
= mem_loc_descriptor (inner
,
12371 mem_mode
, initialized
);
12376 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (inner
)))
12378 if (GET_MODE_SIZE (mode
) != GET_MODE_SIZE (GET_MODE (inner
))
12379 && (GET_MODE_CLASS (mode
) != MODE_INT
12380 || GET_MODE_CLASS (GET_MODE (inner
)) != MODE_INT
))
12384 dw_die_ref type_die
;
12385 dw_loc_descr_ref cvt
;
12387 mem_loc_result
= mem_loc_descriptor (inner
,
12389 mem_mode
, initialized
);
12390 if (mem_loc_result
== NULL
)
12392 type_die
= base_type_for_mode (mode
,
12393 GET_MODE_CLASS (mode
) == MODE_INT
);
12394 if (type_die
== NULL
)
12396 mem_loc_result
= NULL
;
12399 if (GET_MODE_SIZE (mode
)
12400 != GET_MODE_SIZE (GET_MODE (inner
)))
12401 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12403 cvt
= new_loc_descr (DW_OP_GNU_reinterpret
, 0, 0);
12404 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12405 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12406 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12407 add_loc_descr (&mem_loc_result
, cvt
);
12412 if (GET_MODE_CLASS (mode
) != MODE_INT
12413 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12414 && rtl
!= arg_pointer_rtx
12415 && rtl
!= frame_pointer_rtx
12416 #ifdef POINTERS_EXTEND_UNSIGNED
12417 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12421 dw_die_ref type_die
;
12422 unsigned int dbx_regnum
;
12426 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
12428 type_die
= base_type_for_mode (mode
,
12429 GET_MODE_CLASS (mode
) == MODE_INT
);
12430 if (type_die
== NULL
)
12433 dbx_regnum
= dbx_reg_number (rtl
);
12434 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12436 mem_loc_result
= new_loc_descr (DW_OP_GNU_regval_type
,
12438 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12439 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12440 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12443 /* Whenever a register number forms a part of the description of the
12444 method for calculating the (dynamic) address of a memory resident
12445 object, DWARF rules require the register number be referred to as
12446 a "base register". This distinction is not based in any way upon
12447 what category of register the hardware believes the given register
12448 belongs to. This is strictly DWARF terminology we're dealing with
12449 here. Note that in cases where the location of a memory-resident
12450 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12451 OP_CONST (0)) the actual DWARF location descriptor that we generate
12452 may just be OP_BASEREG (basereg). This may look deceptively like
12453 the object in question was allocated to a register (rather than in
12454 memory) so DWARF consumers need to be aware of the subtle
12455 distinction between OP_REG and OP_BASEREG. */
12456 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
12457 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
12458 else if (stack_realign_drap
12460 && crtl
->args
.internal_arg_pointer
== rtl
12461 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
12463 /* If RTL is internal_arg_pointer, which has been optimized
12464 out, use DRAP instead. */
12465 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
12466 VAR_INIT_STATUS_INITIALIZED
);
12472 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12474 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12475 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12478 else if (GET_CODE (rtl
) == ZERO_EXTEND
12479 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12480 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
12481 < HOST_BITS_PER_WIDE_INT
12482 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
12483 to expand zero extend as two shifts instead of
12485 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= 4)
12487 enum machine_mode imode
= GET_MODE (XEXP (rtl
, 0));
12488 mem_loc_result
= op0
;
12489 add_loc_descr (&mem_loc_result
,
12490 int_loc_descriptor (GET_MODE_MASK (imode
)));
12491 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
12493 else if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12495 int shift
= DWARF2_ADDR_SIZE
12496 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
12497 shift
*= BITS_PER_UNIT
;
12498 if (GET_CODE (rtl
) == SIGN_EXTEND
)
12502 mem_loc_result
= op0
;
12503 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12504 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
12505 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12506 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12508 else if (!dwarf_strict
)
12510 dw_die_ref type_die1
, type_die2
;
12511 dw_loc_descr_ref cvt
;
12513 type_die1
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
12514 GET_CODE (rtl
) == ZERO_EXTEND
);
12515 if (type_die1
== NULL
)
12517 type_die2
= base_type_for_mode (mode
, 1);
12518 if (type_die2
== NULL
)
12520 mem_loc_result
= op0
;
12521 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12522 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12523 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
12524 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12525 add_loc_descr (&mem_loc_result
, cvt
);
12526 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12527 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12528 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
12529 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12530 add_loc_descr (&mem_loc_result
, cvt
);
12536 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
12537 if (new_rtl
!= rtl
)
12539 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
12541 if (mem_loc_result
!= NULL
)
12542 return mem_loc_result
;
12545 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
12546 get_address_mode (rtl
), mode
,
12547 VAR_INIT_STATUS_INITIALIZED
);
12548 if (mem_loc_result
== NULL
)
12549 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
12550 if (mem_loc_result
!= NULL
)
12552 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12553 || GET_MODE_CLASS (mode
) != MODE_INT
)
12555 dw_die_ref type_die
;
12556 dw_loc_descr_ref deref
;
12561 = base_type_for_mode (mode
, GET_MODE_CLASS (mode
) == MODE_INT
);
12562 if (type_die
== NULL
)
12564 deref
= new_loc_descr (DW_OP_GNU_deref_type
,
12565 GET_MODE_SIZE (mode
), 0);
12566 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12567 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12568 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12569 add_loc_descr (&mem_loc_result
, deref
);
12571 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
12572 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
12574 add_loc_descr (&mem_loc_result
,
12575 new_loc_descr (DW_OP_deref_size
,
12576 GET_MODE_SIZE (mode
), 0));
12581 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
12584 /* Some ports can transform a symbol ref into a label ref, because
12585 the symbol ref is too far away and has to be dumped into a constant
12589 if (GET_MODE_CLASS (mode
) != MODE_INT
12590 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12591 #ifdef POINTERS_EXTEND_UNSIGNED
12592 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12596 if (GET_CODE (rtl
) == SYMBOL_REF
12597 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
12599 dw_loc_descr_ref temp
;
12601 /* If this is not defined, we have no way to emit the data. */
12602 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
12605 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
12607 mem_loc_result
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
12608 add_loc_descr (&mem_loc_result
, temp
);
12613 if (!const_ok_for_output (rtl
))
12617 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
12618 vec_safe_push (used_rtx_array
, rtl
);
12624 case DEBUG_IMPLICIT_PTR
:
12625 expansion_failed (NULL_TREE
, rtl
,
12626 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
12632 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
12634 if (GET_MODE_CLASS (mode
) != MODE_INT
12635 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12636 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12637 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12640 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
12641 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12643 op0
= one_reg_loc_descriptor (dbx_regnum
,
12644 VAR_INIT_STATUS_INITIALIZED
);
12647 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
12648 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
12650 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12651 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12652 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
12656 gcc_unreachable ();
12659 mem_loc_result
= new_loc_descr (DW_OP_GNU_entry_value
, 0, 0);
12660 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12661 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
12664 case DEBUG_PARAMETER_REF
:
12665 mem_loc_result
= parameter_ref_descriptor (rtl
);
12669 /* Extract the PLUS expression nested inside and fall into
12670 PLUS code below. */
12671 rtl
= XEXP (rtl
, 1);
12676 /* Turn these into a PLUS expression and fall into the PLUS code
12678 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
12679 gen_int_mode (GET_CODE (rtl
) == PRE_INC
12680 ? GET_MODE_UNIT_SIZE (mem_mode
)
12681 : -GET_MODE_UNIT_SIZE (mem_mode
),
12684 /* ... fall through ... */
12688 if (is_based_loc (rtl
)
12689 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12690 || XEXP (rtl
, 0) == arg_pointer_rtx
12691 || XEXP (rtl
, 0) == frame_pointer_rtx
)
12692 && GET_MODE_CLASS (mode
) == MODE_INT
)
12693 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
12694 INTVAL (XEXP (rtl
, 1)),
12695 VAR_INIT_STATUS_INITIALIZED
);
12698 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12699 VAR_INIT_STATUS_INITIALIZED
);
12700 if (mem_loc_result
== 0)
12703 if (CONST_INT_P (XEXP (rtl
, 1))
12704 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12705 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
12708 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12709 VAR_INIT_STATUS_INITIALIZED
);
12712 add_loc_descr (&mem_loc_result
, op1
);
12713 add_loc_descr (&mem_loc_result
,
12714 new_loc_descr (DW_OP_plus
, 0, 0));
12719 /* If a pseudo-reg is optimized away, it is possible for it to
12720 be replaced with a MEM containing a multiply or shift. */
12731 && GET_MODE_CLASS (mode
) == MODE_INT
12732 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12734 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12735 base_type_for_mode (mode
, 0),
12759 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12761 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12762 VAR_INIT_STATUS_INITIALIZED
);
12764 rtx rtlop1
= XEXP (rtl
, 1);
12765 if (GET_MODE (rtlop1
) != VOIDmode
12766 && GET_MODE_BITSIZE (GET_MODE (rtlop1
))
12767 < GET_MODE_BITSIZE (mode
))
12768 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12769 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12770 VAR_INIT_STATUS_INITIALIZED
);
12773 if (op0
== 0 || op1
== 0)
12776 mem_loc_result
= op0
;
12777 add_loc_descr (&mem_loc_result
, op1
);
12778 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12794 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12795 VAR_INIT_STATUS_INITIALIZED
);
12796 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12797 VAR_INIT_STATUS_INITIALIZED
);
12799 if (op0
== 0 || op1
== 0)
12802 mem_loc_result
= op0
;
12803 add_loc_descr (&mem_loc_result
, op1
);
12804 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12808 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
&& !dwarf_strict
)
12810 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
12811 base_type_for_mode (mode
, 0),
12816 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12817 VAR_INIT_STATUS_INITIALIZED
);
12818 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12819 VAR_INIT_STATUS_INITIALIZED
);
12821 if (op0
== 0 || op1
== 0)
12824 mem_loc_result
= op0
;
12825 add_loc_descr (&mem_loc_result
, op1
);
12826 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12827 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12828 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
12829 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
12830 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
12834 if (!dwarf_strict
&& GET_MODE_CLASS (mode
) == MODE_INT
)
12836 if (GET_MODE_CLASS (mode
) > DWARF2_ADDR_SIZE
)
12841 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12842 base_type_for_mode (mode
, 1),
12860 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12861 VAR_INIT_STATUS_INITIALIZED
);
12866 mem_loc_result
= op0
;
12867 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12871 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12872 #ifdef POINTERS_EXTEND_UNSIGNED
12874 && mem_mode
!= VOIDmode
12875 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
12879 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12883 && (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
12884 || GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_DOUBLE_INT
))
12886 dw_die_ref type_die
= base_type_for_mode (mode
, 1);
12887 enum machine_mode amode
;
12888 if (type_die
== NULL
)
12890 amode
= mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
,
12892 if (INTVAL (rtl
) >= 0
12893 && amode
!= BLKmode
12894 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
12895 /* const DW_OP_GNU_convert <XXX> vs.
12896 DW_OP_GNU_const_type <XXX, 1, const>. */
12897 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
12898 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode
))
12900 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12901 op0
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12902 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12903 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12904 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12905 add_loc_descr (&mem_loc_result
, op0
);
12906 return mem_loc_result
;
12908 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0,
12910 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12911 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12912 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12913 if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12914 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
12917 mem_loc_result
->dw_loc_oprnd2
.val_class
12918 = dw_val_class_const_double
;
12919 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12920 = double_int::from_shwi (INTVAL (rtl
));
12928 dw_die_ref type_die
;
12930 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
12931 CONST_DOUBLE rtx could represent either a large integer
12932 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
12933 the value is always a floating point constant.
12935 When it is an integer, a CONST_DOUBLE is used whenever
12936 the constant requires 2 HWIs to be adequately represented.
12937 We output CONST_DOUBLEs as blocks. */
12938 if (mode
== VOIDmode
12939 || (GET_MODE (rtl
) == VOIDmode
12940 && GET_MODE_BITSIZE (mode
) != HOST_BITS_PER_DOUBLE_INT
))
12942 type_die
= base_type_for_mode (mode
,
12943 GET_MODE_CLASS (mode
) == MODE_INT
);
12944 if (type_die
== NULL
)
12946 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
12947 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12948 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12949 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12950 #if TARGET_SUPPORTS_WIDE_INT == 0
12951 if (!SCALAR_FLOAT_MODE_P (mode
))
12953 mem_loc_result
->dw_loc_oprnd2
.val_class
12954 = dw_val_class_const_double
;
12955 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12956 = rtx_to_double_int (rtl
);
12961 unsigned int length
= GET_MODE_SIZE (mode
);
12962 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
12964 insert_float (rtl
, array
);
12965 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
12966 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
12967 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
12968 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
12973 case CONST_WIDE_INT
:
12976 dw_die_ref type_die
;
12978 type_die
= base_type_for_mode (mode
,
12979 GET_MODE_CLASS (mode
) == MODE_INT
);
12980 if (type_die
== NULL
)
12982 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
12983 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12984 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12985 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12986 mem_loc_result
->dw_loc_oprnd2
.val_class
12987 = dw_val_class_wide_int
;
12988 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_cleared_alloc
<wide_int
> ();
12989 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= std::make_pair (rtl
, mode
);
12994 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
12998 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
13002 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
13006 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
13010 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
13014 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
13018 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
13022 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
13026 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
13030 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
13035 if (GET_MODE_CLASS (mode
) != MODE_INT
)
13040 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
13045 if (CONST_INT_P (XEXP (rtl
, 1))
13046 && CONST_INT_P (XEXP (rtl
, 2))
13047 && ((unsigned) INTVAL (XEXP (rtl
, 1))
13048 + (unsigned) INTVAL (XEXP (rtl
, 2))
13049 <= GET_MODE_BITSIZE (mode
))
13050 && GET_MODE_CLASS (mode
) == MODE_INT
13051 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
13052 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
13055 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
13056 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13059 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
13063 mem_loc_result
= op0
;
13064 size
= INTVAL (XEXP (rtl
, 1));
13065 shift
= INTVAL (XEXP (rtl
, 2));
13066 if (BITS_BIG_ENDIAN
)
13067 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
13069 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
13071 add_loc_descr (&mem_loc_result
,
13072 int_loc_descriptor (DWARF2_ADDR_SIZE
13074 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
13076 if (size
!= (int) DWARF2_ADDR_SIZE
)
13078 add_loc_descr (&mem_loc_result
,
13079 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
13080 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13087 dw_loc_descr_ref op2
, bra_node
, drop_node
;
13088 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
13089 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
13090 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
13091 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13092 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
13093 VAR_INIT_STATUS_INITIALIZED
);
13094 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
13095 VAR_INIT_STATUS_INITIALIZED
);
13096 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
13099 mem_loc_result
= op1
;
13100 add_loc_descr (&mem_loc_result
, op2
);
13101 add_loc_descr (&mem_loc_result
, op0
);
13102 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
13103 add_loc_descr (&mem_loc_result
, bra_node
);
13104 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
13105 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
13106 add_loc_descr (&mem_loc_result
, drop_node
);
13107 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13108 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
13113 case FLOAT_TRUNCATE
:
13115 case UNSIGNED_FLOAT
:
13120 dw_die_ref type_die
;
13121 dw_loc_descr_ref cvt
;
13123 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
13124 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13127 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl
, 0))) == MODE_INT
13128 && (GET_CODE (rtl
) == FLOAT
13129 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)))
13130 <= DWARF2_ADDR_SIZE
))
13132 type_die
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
13133 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
13134 if (type_die
== NULL
)
13136 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13137 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13138 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13139 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13140 add_loc_descr (&op0
, cvt
);
13142 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
13143 if (type_die
== NULL
)
13145 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13146 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13147 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13148 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13149 add_loc_descr (&op0
, cvt
);
13150 if (GET_MODE_CLASS (mode
) == MODE_INT
13151 && (GET_CODE (rtl
) == FIX
13152 || GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
))
13154 op0
= convert_descriptor_to_mode (mode
, op0
);
13158 mem_loc_result
= op0
;
13165 mem_loc_result
= clz_loc_descriptor (rtl
, mode
, mem_mode
);
13170 mem_loc_result
= popcount_loc_descriptor (rtl
, mode
, mem_mode
);
13174 mem_loc_result
= bswap_loc_descriptor (rtl
, mode
, mem_mode
);
13179 mem_loc_result
= rotate_loc_descriptor (rtl
, mode
, mem_mode
);
13183 /* In theory, we could implement the above. */
13184 /* DWARF cannot represent the unsigned compare operations
13209 case FRACT_CONVERT
:
13210 case UNSIGNED_FRACT_CONVERT
:
13212 case UNSIGNED_SAT_FRACT
:
13218 case VEC_DUPLICATE
:
13222 case STRICT_LOW_PART
:
13227 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13228 can't express it in the debug info. This can happen e.g. with some
13233 resolve_one_addr (&rtl
, NULL
);
13237 #ifdef ENABLE_CHECKING
13238 print_rtl (stderr
, rtl
);
13239 gcc_unreachable ();
13245 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13246 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13248 return mem_loc_result
;
13251 /* Return a descriptor that describes the concatenation of two locations.
13252 This is typically a complex variable. */
13254 static dw_loc_descr_ref
13255 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
13257 dw_loc_descr_ref cc_loc_result
= NULL
;
13258 dw_loc_descr_ref x0_ref
13259 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13260 dw_loc_descr_ref x1_ref
13261 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13263 if (x0_ref
== 0 || x1_ref
== 0)
13266 cc_loc_result
= x0_ref
;
13267 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
13269 add_loc_descr (&cc_loc_result
, x1_ref
);
13270 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
13272 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13273 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13275 return cc_loc_result
;
13278 /* Return a descriptor that describes the concatenation of N
13281 static dw_loc_descr_ref
13282 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
13285 dw_loc_descr_ref cc_loc_result
= NULL
;
13286 unsigned int n
= XVECLEN (concatn
, 0);
13288 for (i
= 0; i
< n
; ++i
)
13290 dw_loc_descr_ref ref
;
13291 rtx x
= XVECEXP (concatn
, 0, i
);
13293 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13297 add_loc_descr (&cc_loc_result
, ref
);
13298 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
13301 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13302 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13304 return cc_loc_result
;
13307 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
13308 for DEBUG_IMPLICIT_PTR RTL. */
13310 static dw_loc_descr_ref
13311 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
13313 dw_loc_descr_ref ret
;
13318 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
13319 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
13320 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
13321 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
13322 ret
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
13323 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13326 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13327 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
13328 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13332 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
13333 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
13338 /* Output a proper Dwarf location descriptor for a variable or parameter
13339 which is either allocated in a register or in a memory location. For a
13340 register, we just generate an OP_REG and the register number. For a
13341 memory location we provide a Dwarf postfix expression describing how to
13342 generate the (dynamic) address of the object onto the address stack.
13344 MODE is mode of the decl if this loc_descriptor is going to be used in
13345 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13346 allowed, VOIDmode otherwise.
13348 If we don't know how to describe it, return 0. */
13350 static dw_loc_descr_ref
13351 loc_descriptor (rtx rtl
, enum machine_mode mode
,
13352 enum var_init_status initialized
)
13354 dw_loc_descr_ref loc_result
= NULL
;
13356 switch (GET_CODE (rtl
))
13359 /* The case of a subreg may arise when we have a local (register)
13360 variable or a formal (register) parameter which doesn't quite fill
13361 up an entire register. For now, just assume that it is
13362 legitimate to make the Dwarf info refer to the whole register which
13363 contains the given subreg. */
13364 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
13365 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
13366 GET_MODE (SUBREG_REG (rtl
)), initialized
);
13372 loc_result
= reg_loc_descriptor (rtl
, initialized
);
13376 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
13377 GET_MODE (rtl
), initialized
);
13378 if (loc_result
== NULL
)
13379 loc_result
= tls_mem_loc_descriptor (rtl
);
13380 if (loc_result
== NULL
)
13382 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
13383 if (new_rtl
!= rtl
)
13384 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
13389 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
13394 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
13399 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
13401 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
13402 if (GET_CODE (loc
) == EXPR_LIST
)
13403 loc
= XEXP (loc
, 0);
13404 loc_result
= loc_descriptor (loc
, mode
, initialized
);
13408 rtl
= XEXP (rtl
, 1);
13413 rtvec par_elems
= XVEC (rtl
, 0);
13414 int num_elem
= GET_NUM_ELEM (par_elems
);
13415 enum machine_mode mode
;
13418 /* Create the first one, so we have something to add to. */
13419 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
13420 VOIDmode
, initialized
);
13421 if (loc_result
== NULL
)
13423 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
13424 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13425 for (i
= 1; i
< num_elem
; i
++)
13427 dw_loc_descr_ref temp
;
13429 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
13430 VOIDmode
, initialized
);
13433 add_loc_descr (&loc_result
, temp
);
13434 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
13435 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13441 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
13442 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
13447 if (mode
== VOIDmode
)
13448 mode
= GET_MODE (rtl
);
13450 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13452 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13454 /* Note that a CONST_DOUBLE rtx could represent either an integer
13455 or a floating-point constant. A CONST_DOUBLE is used whenever
13456 the constant requires more than one word in order to be
13457 adequately represented. We output CONST_DOUBLEs as blocks. */
13458 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13459 GET_MODE_SIZE (mode
), 0);
13460 #if TARGET_SUPPORTS_WIDE_INT == 0
13461 if (!SCALAR_FLOAT_MODE_P (mode
))
13463 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
13464 loc_result
->dw_loc_oprnd2
.v
.val_double
13465 = rtx_to_double_int (rtl
);
13470 unsigned int length
= GET_MODE_SIZE (mode
);
13471 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
13473 insert_float (rtl
, array
);
13474 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13475 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
13476 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
13477 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13482 case CONST_WIDE_INT
:
13483 if (mode
== VOIDmode
)
13484 mode
= GET_MODE (rtl
);
13486 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13488 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13489 GET_MODE_SIZE (mode
), 0);
13490 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
13491 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_cleared_alloc
<wide_int
> ();
13492 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= std::make_pair (rtl
, mode
);
13497 if (mode
== VOIDmode
)
13498 mode
= GET_MODE (rtl
);
13500 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13502 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
13503 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
13504 unsigned char *array
13505 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
13508 enum machine_mode imode
= GET_MODE_INNER (mode
);
13510 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13511 switch (GET_MODE_CLASS (mode
))
13513 case MODE_VECTOR_INT
:
13514 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13516 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13517 insert_wide_int (std::make_pair (elt
, imode
), p
, elt_size
);
13521 case MODE_VECTOR_FLOAT
:
13522 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13524 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13525 insert_float (elt
, p
);
13530 gcc_unreachable ();
13533 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13534 length
* elt_size
, 0);
13535 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13536 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
13537 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
13538 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13543 if (mode
== VOIDmode
13544 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
13545 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
13546 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
13548 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
13553 if (!const_ok_for_output (rtl
))
13556 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
13557 && (dwarf_version
>= 4 || !dwarf_strict
))
13559 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
13560 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13561 vec_safe_push (used_rtx_array
, rtl
);
13565 case DEBUG_IMPLICIT_PTR
:
13566 loc_result
= implicit_ptr_descriptor (rtl
, 0);
13570 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
13571 && CONST_INT_P (XEXP (rtl
, 1)))
13574 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
13580 if ((GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE (rtl
) == mode
13581 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
13582 && dwarf_version
>= 4)
13583 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
13585 /* Value expression. */
13586 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
13588 add_loc_descr (&loc_result
,
13589 new_loc_descr (DW_OP_stack_value
, 0, 0));
13597 /* We need to figure out what section we should use as the base for the
13598 address ranges where a given location is valid.
13599 1. If this particular DECL has a section associated with it, use that.
13600 2. If this function has a section associated with it, use that.
13601 3. Otherwise, use the text section.
13602 XXX: If you split a variable across multiple sections, we won't notice. */
13604 static const char *
13605 secname_for_decl (const_tree decl
)
13607 const char *secname
;
13609 if (VAR_OR_FUNCTION_DECL_P (decl
)
13610 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
13611 && DECL_SECTION_NAME (decl
))
13612 secname
= DECL_SECTION_NAME (decl
);
13613 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
13614 secname
= DECL_SECTION_NAME (current_function_decl
);
13615 else if (cfun
&& in_cold_section_p
)
13616 secname
= crtl
->subsections
.cold_section_label
;
13618 secname
= text_section_label
;
13623 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13626 decl_by_reference_p (tree decl
)
13628 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
13629 || TREE_CODE (decl
) == VAR_DECL
)
13630 && DECL_BY_REFERENCE (decl
));
13633 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13636 static dw_loc_descr_ref
13637 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
13638 enum var_init_status initialized
)
13640 int have_address
= 0;
13641 dw_loc_descr_ref descr
;
13642 enum machine_mode mode
;
13644 if (want_address
!= 2)
13646 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
13648 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13650 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13651 if (GET_CODE (varloc
) == EXPR_LIST
)
13652 varloc
= XEXP (varloc
, 0);
13653 mode
= GET_MODE (varloc
);
13654 if (MEM_P (varloc
))
13656 rtx addr
= XEXP (varloc
, 0);
13657 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
13658 mode
, initialized
);
13663 rtx x
= avoid_constant_pool_reference (varloc
);
13665 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
13670 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
13677 if (GET_CODE (varloc
) == VAR_LOCATION
)
13678 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
13680 mode
= DECL_MODE (loc
);
13681 descr
= loc_descriptor (varloc
, mode
, initialized
);
13688 if (want_address
== 2 && !have_address
13689 && (dwarf_version
>= 4 || !dwarf_strict
))
13691 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
13693 expansion_failed (loc
, NULL_RTX
,
13694 "DWARF address size mismatch");
13697 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13700 /* Show if we can't fill the request for an address. */
13701 if (want_address
&& !have_address
)
13703 expansion_failed (loc
, NULL_RTX
,
13704 "Want address and only have value");
13708 /* If we've got an address and don't want one, dereference. */
13709 if (!want_address
&& have_address
)
13711 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
13712 enum dwarf_location_atom op
;
13714 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
13716 expansion_failed (loc
, NULL_RTX
,
13717 "DWARF address size mismatch");
13720 else if (size
== DWARF2_ADDR_SIZE
)
13723 op
= DW_OP_deref_size
;
13725 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
13731 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
13732 if it is not possible. */
13734 static dw_loc_descr_ref
13735 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
13737 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
13738 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
13739 else if (dwarf_version
>= 3 || !dwarf_strict
)
13740 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
13745 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13746 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
13748 static dw_loc_descr_ref
13749 dw_sra_loc_expr (tree decl
, rtx loc
)
13752 unsigned int padsize
= 0;
13753 dw_loc_descr_ref descr
, *descr_tail
;
13754 unsigned HOST_WIDE_INT decl_size
;
13756 enum var_init_status initialized
;
13758 if (DECL_SIZE (decl
) == NULL
13759 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
13762 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
13764 descr_tail
= &descr
;
13766 for (p
= loc
; p
; p
= XEXP (p
, 1))
13768 unsigned int bitsize
= decl_piece_bitsize (p
);
13769 rtx loc_note
= *decl_piece_varloc_ptr (p
);
13770 dw_loc_descr_ref cur_descr
;
13771 dw_loc_descr_ref
*tail
, last
= NULL
;
13772 unsigned int opsize
= 0;
13774 if (loc_note
== NULL_RTX
13775 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
13777 padsize
+= bitsize
;
13780 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
13781 varloc
= NOTE_VAR_LOCATION (loc_note
);
13782 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
13783 if (cur_descr
== NULL
)
13785 padsize
+= bitsize
;
13789 /* Check that cur_descr either doesn't use
13790 DW_OP_*piece operations, or their sum is equal
13791 to bitsize. Otherwise we can't embed it. */
13792 for (tail
= &cur_descr
; *tail
!= NULL
;
13793 tail
= &(*tail
)->dw_loc_next
)
13794 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
13796 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
13800 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
13802 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
13806 if (last
!= NULL
&& opsize
!= bitsize
)
13808 padsize
+= bitsize
;
13809 /* Discard the current piece of the descriptor and release any
13810 addr_table entries it uses. */
13811 remove_loc_list_addr_table_entries (cur_descr
);
13815 /* If there is a hole, add DW_OP_*piece after empty DWARF
13816 expression, which means that those bits are optimized out. */
13819 if (padsize
> decl_size
)
13821 remove_loc_list_addr_table_entries (cur_descr
);
13822 goto discard_descr
;
13824 decl_size
-= padsize
;
13825 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
13826 if (*descr_tail
== NULL
)
13828 remove_loc_list_addr_table_entries (cur_descr
);
13829 goto discard_descr
;
13831 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13834 *descr_tail
= cur_descr
;
13836 if (bitsize
> decl_size
)
13837 goto discard_descr
;
13838 decl_size
-= bitsize
;
13841 HOST_WIDE_INT offset
= 0;
13842 if (GET_CODE (varloc
) == VAR_LOCATION
13843 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13845 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13846 if (GET_CODE (varloc
) == EXPR_LIST
)
13847 varloc
= XEXP (varloc
, 0);
13851 if (GET_CODE (varloc
) == CONST
13852 || GET_CODE (varloc
) == SIGN_EXTEND
13853 || GET_CODE (varloc
) == ZERO_EXTEND
)
13854 varloc
= XEXP (varloc
, 0);
13855 else if (GET_CODE (varloc
) == SUBREG
)
13856 varloc
= SUBREG_REG (varloc
);
13861 /* DW_OP_bit_size offset should be zero for register
13862 or implicit location descriptions and empty location
13863 descriptions, but for memory addresses needs big endian
13865 if (MEM_P (varloc
))
13867 unsigned HOST_WIDE_INT memsize
13868 = MEM_SIZE (varloc
) * BITS_PER_UNIT
;
13869 if (memsize
!= bitsize
)
13871 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
13872 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
13873 goto discard_descr
;
13874 if (memsize
< bitsize
)
13875 goto discard_descr
;
13876 if (BITS_BIG_ENDIAN
)
13877 offset
= memsize
- bitsize
;
13881 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
13882 if (*descr_tail
== NULL
)
13883 goto discard_descr
;
13884 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13888 /* If there were any non-empty expressions, add padding till the end of
13890 if (descr
!= NULL
&& decl_size
!= 0)
13892 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
13893 if (*descr_tail
== NULL
)
13894 goto discard_descr
;
13899 /* Discard the descriptor and release any addr_table entries it uses. */
13900 remove_loc_list_addr_table_entries (descr
);
13904 /* Return the dwarf representation of the location list LOC_LIST of
13905 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
13908 static dw_loc_list_ref
13909 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
13911 const char *endname
, *secname
;
13913 enum var_init_status initialized
;
13914 struct var_loc_node
*node
;
13915 dw_loc_descr_ref descr
;
13916 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
13917 dw_loc_list_ref list
= NULL
;
13918 dw_loc_list_ref
*listp
= &list
;
13920 /* Now that we know what section we are using for a base,
13921 actually construct the list of locations.
13922 The first location information is what is passed to the
13923 function that creates the location list, and the remaining
13924 locations just get added on to that list.
13925 Note that we only know the start address for a location
13926 (IE location changes), so to build the range, we use
13927 the range [current location start, next location start].
13928 This means we have to special case the last node, and generate
13929 a range of [last location start, end of function label]. */
13931 secname
= secname_for_decl (decl
);
13933 for (node
= loc_list
->first
; node
; node
= node
->next
)
13934 if (GET_CODE (node
->loc
) == EXPR_LIST
13935 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
13937 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13939 /* This requires DW_OP_{,bit_}piece, which is not usable
13940 inside DWARF expressions. */
13941 if (want_address
!= 2)
13943 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13949 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13950 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13951 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
13955 bool range_across_switch
= false;
13956 /* If section switch happens in between node->label
13957 and node->next->label (or end of function) and
13958 we can't emit it as a single entry list,
13959 emit two ranges, first one ending at the end
13960 of first partition and second one starting at the
13961 beginning of second partition. */
13962 if (node
== loc_list
->last_before_switch
13963 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
13964 && current_function_decl
)
13966 endname
= cfun
->fde
->dw_fde_end
;
13967 range_across_switch
= true;
13969 /* The variable has a location between NODE->LABEL and
13970 NODE->NEXT->LABEL. */
13971 else if (node
->next
)
13972 endname
= node
->next
->label
;
13973 /* If the variable has a location at the last label
13974 it keeps its location until the end of function. */
13975 else if (!current_function_decl
)
13976 endname
= text_end_label
;
13979 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
13980 current_function_funcdef_no
);
13981 endname
= ggc_strdup (label_id
);
13984 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
13985 if (TREE_CODE (decl
) == PARM_DECL
13986 && node
== loc_list
->first
13987 && NOTE_P (node
->loc
)
13988 && strcmp (node
->label
, endname
) == 0)
13989 (*listp
)->force
= true;
13990 listp
= &(*listp
)->dw_loc_next
;
13992 if (range_across_switch
)
13994 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13995 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13998 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13999 varloc
= NOTE_VAR_LOCATION (node
->loc
);
14000 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
14003 gcc_assert (descr
);
14004 /* The variable has a location between NODE->LABEL and
14005 NODE->NEXT->LABEL. */
14007 endname
= node
->next
->label
;
14009 endname
= cfun
->fde
->dw_fde_second_end
;
14010 *listp
= new_loc_list (descr
,
14011 cfun
->fde
->dw_fde_second_begin
,
14013 listp
= &(*listp
)->dw_loc_next
;
14018 /* Try to avoid the overhead of a location list emitting a location
14019 expression instead, but only if we didn't have more than one
14020 location entry in the first place. If some entries were not
14021 representable, we don't want to pretend a single entry that was
14022 applies to the entire scope in which the variable is
14024 if (list
&& loc_list
->first
->next
)
14030 /* Return if the loc_list has only single element and thus can be represented
14031 as location description. */
14034 single_element_loc_list_p (dw_loc_list_ref list
)
14036 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
14037 return !list
->ll_symbol
;
14040 /* To each location in list LIST add loc descr REF. */
14043 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
14045 dw_loc_descr_ref copy
;
14046 add_loc_descr (&list
->expr
, ref
);
14047 list
= list
->dw_loc_next
;
14050 copy
= ggc_alloc
<dw_loc_descr_node
> ();
14051 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
14052 add_loc_descr (&list
->expr
, copy
);
14053 while (copy
->dw_loc_next
)
14055 dw_loc_descr_ref new_copy
= ggc_alloc
<dw_loc_descr_node
> ();
14056 memcpy (new_copy
, copy
->dw_loc_next
, sizeof (dw_loc_descr_node
));
14057 copy
->dw_loc_next
= new_copy
;
14060 list
= list
->dw_loc_next
;
14064 /* Given two lists RET and LIST
14065 produce location list that is result of adding expression in LIST
14066 to expression in RET on each position in program.
14067 Might be destructive on both RET and LIST.
14069 TODO: We handle only simple cases of RET or LIST having at most one
14070 element. General case would inolve sorting the lists in program order
14071 and merging them that will need some additional work.
14072 Adding that will improve quality of debug info especially for SRA-ed
14076 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
14085 if (!list
->dw_loc_next
)
14087 add_loc_descr_to_each (*ret
, list
->expr
);
14090 if (!(*ret
)->dw_loc_next
)
14092 add_loc_descr_to_each (list
, (*ret
)->expr
);
14096 expansion_failed (NULL_TREE
, NULL_RTX
,
14097 "Don't know how to merge two non-trivial"
14098 " location lists.\n");
14103 /* LOC is constant expression. Try a luck, look it up in constant
14104 pool and return its loc_descr of its address. */
14106 static dw_loc_descr_ref
14107 cst_pool_loc_descr (tree loc
)
14109 /* Get an RTL for this, if something has been emitted. */
14110 rtx rtl
= lookup_constant_def (loc
);
14112 if (!rtl
|| !MEM_P (rtl
))
14117 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
14119 /* TODO: We might get more coverage if we was actually delaying expansion
14120 of all expressions till end of compilation when constant pools are fully
14122 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
14124 expansion_failed (loc
, NULL_RTX
,
14125 "CST value in contant pool but not marked.");
14128 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
14129 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
14132 /* Return dw_loc_list representing address of addr_expr LOC
14133 by looking for inner INDIRECT_REF expression and turning
14134 it into simple arithmetics. */
14136 static dw_loc_list_ref
14137 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
)
14140 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14141 enum machine_mode mode
;
14142 int unsignedp
, volatilep
= 0;
14143 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14145 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
14146 &bitsize
, &bitpos
, &offset
, &mode
,
14147 &unsignedp
, &volatilep
, false);
14149 if (bitpos
% BITS_PER_UNIT
)
14151 expansion_failed (loc
, NULL_RTX
, "bitfield access");
14154 if (!INDIRECT_REF_P (obj
))
14156 expansion_failed (obj
,
14157 NULL_RTX
, "no indirect ref in inner refrence");
14160 if (!offset
&& !bitpos
)
14161 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1);
14163 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
14164 && (dwarf_version
>= 4 || !dwarf_strict
))
14166 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0);
14171 /* Variable offset. */
14172 list_ret1
= loc_list_from_tree (offset
, 0);
14173 if (list_ret1
== 0)
14175 add_loc_list (&list_ret
, list_ret1
);
14178 add_loc_descr_to_each (list_ret
,
14179 new_loc_descr (DW_OP_plus
, 0, 0));
14181 bytepos
= bitpos
/ BITS_PER_UNIT
;
14183 add_loc_descr_to_each (list_ret
,
14184 new_loc_descr (DW_OP_plus_uconst
,
14186 else if (bytepos
< 0)
14187 loc_list_plus_const (list_ret
, bytepos
);
14188 add_loc_descr_to_each (list_ret
,
14189 new_loc_descr (DW_OP_stack_value
, 0, 0));
14195 /* Generate Dwarf location list representing LOC.
14196 If WANT_ADDRESS is false, expression computing LOC will be computed
14197 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14198 if WANT_ADDRESS is 2, expression computing address useable in location
14199 will be returned (i.e. DW_OP_reg can be used
14200 to refer to register values). */
14202 static dw_loc_list_ref
14203 loc_list_from_tree (tree loc
, int want_address
)
14205 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
14206 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14207 int have_address
= 0;
14208 enum dwarf_location_atom op
;
14210 /* ??? Most of the time we do not take proper care for sign/zero
14211 extending the values properly. Hopefully this won't be a real
14214 switch (TREE_CODE (loc
))
14217 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
14220 case PLACEHOLDER_EXPR
:
14221 /* This case involves extracting fields from an object to determine the
14222 position of other fields. We don't try to encode this here. The
14223 only user of this is Ada, which encodes the needed information using
14224 the names of types. */
14225 expansion_failed (loc
, NULL_RTX
, "PLACEHOLDER_EXPR");
14229 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
14230 /* There are no opcodes for these operations. */
14233 case PREINCREMENT_EXPR
:
14234 case PREDECREMENT_EXPR
:
14235 case POSTINCREMENT_EXPR
:
14236 case POSTDECREMENT_EXPR
:
14237 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
14238 /* There are no opcodes for these operations. */
14242 /* If we already want an address, see if there is INDIRECT_REF inside
14243 e.g. for &this->field. */
14246 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
14247 (loc
, want_address
== 2);
14250 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
14251 && (ret
= cst_pool_loc_descr (loc
)))
14254 /* Otherwise, process the argument and look for the address. */
14255 if (!list_ret
&& !ret
)
14256 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 1);
14260 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
14266 if (DECL_THREAD_LOCAL_P (loc
))
14269 enum dwarf_location_atom tls_op
;
14270 enum dtprel_bool dtprel
= dtprel_false
;
14272 if (targetm
.have_tls
)
14274 /* If this is not defined, we have no way to emit the
14276 if (!targetm
.asm_out
.output_dwarf_dtprel
)
14279 /* The way DW_OP_GNU_push_tls_address is specified, we
14280 can only look up addresses of objects in the current
14281 module. We used DW_OP_addr as first op, but that's
14282 wrong, because DW_OP_addr is relocated by the debug
14283 info consumer, while DW_OP_GNU_push_tls_address
14284 operand shouldn't be. */
14285 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
14287 dtprel
= dtprel_true
;
14288 tls_op
= DW_OP_GNU_push_tls_address
;
14292 if (!targetm
.emutls
.debug_form_tls_address
14293 || !(dwarf_version
>= 3 || !dwarf_strict
))
14295 /* We stuffed the control variable into the DECL_VALUE_EXPR
14296 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
14297 no longer appear in gimple code. We used the control
14298 variable in specific so that we could pick it up here. */
14299 loc
= DECL_VALUE_EXPR (loc
);
14300 tls_op
= DW_OP_form_tls_address
;
14303 rtl
= rtl_for_decl_location (loc
);
14304 if (rtl
== NULL_RTX
)
14309 rtl
= XEXP (rtl
, 0);
14310 if (! CONSTANT_P (rtl
))
14313 ret
= new_addr_loc_descr (rtl
, dtprel
);
14314 ret1
= new_loc_descr (tls_op
, 0, 0);
14315 add_loc_descr (&ret
, ret1
);
14324 if (DECL_HAS_VALUE_EXPR_P (loc
))
14325 return loc_list_from_tree (DECL_VALUE_EXPR (loc
),
14329 case FUNCTION_DECL
:
14332 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
14334 if (loc_list
&& loc_list
->first
)
14336 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
14337 have_address
= want_address
!= 0;
14340 rtl
= rtl_for_decl_location (loc
);
14341 if (rtl
== NULL_RTX
)
14343 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
14346 else if (CONST_INT_P (rtl
))
14348 HOST_WIDE_INT val
= INTVAL (rtl
);
14349 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14350 val
&= GET_MODE_MASK (DECL_MODE (loc
));
14351 ret
= int_loc_descriptor (val
);
14353 else if (GET_CODE (rtl
) == CONST_STRING
)
14355 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
14358 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
14359 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
14362 enum machine_mode mode
, mem_mode
;
14364 /* Certain constructs can only be represented at top-level. */
14365 if (want_address
== 2)
14367 ret
= loc_descriptor (rtl
, VOIDmode
,
14368 VAR_INIT_STATUS_INITIALIZED
);
14373 mode
= GET_MODE (rtl
);
14374 mem_mode
= VOIDmode
;
14378 mode
= get_address_mode (rtl
);
14379 rtl
= XEXP (rtl
, 0);
14382 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
14383 VAR_INIT_STATUS_INITIALIZED
);
14386 expansion_failed (loc
, rtl
,
14387 "failed to produce loc descriptor for rtl");
14394 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
14398 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14402 case COMPOUND_EXPR
:
14403 return loc_list_from_tree (TREE_OPERAND (loc
, 1), want_address
);
14406 case VIEW_CONVERT_EXPR
:
14409 return loc_list_from_tree (TREE_OPERAND (loc
, 0), want_address
);
14411 case COMPONENT_REF
:
14412 case BIT_FIELD_REF
:
14414 case ARRAY_RANGE_REF
:
14415 case REALPART_EXPR
:
14416 case IMAGPART_EXPR
:
14419 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14420 enum machine_mode mode
;
14421 int unsignedp
, volatilep
= 0;
14423 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
14424 &unsignedp
, &volatilep
, false);
14426 gcc_assert (obj
!= loc
);
14428 list_ret
= loc_list_from_tree (obj
,
14430 && !bitpos
&& !offset
? 2 : 1);
14431 /* TODO: We can extract value of the small expression via shifting even
14432 for nonzero bitpos. */
14435 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
14437 expansion_failed (loc
, NULL_RTX
,
14438 "bitfield access");
14442 if (offset
!= NULL_TREE
)
14444 /* Variable offset. */
14445 list_ret1
= loc_list_from_tree (offset
, 0);
14446 if (list_ret1
== 0)
14448 add_loc_list (&list_ret
, list_ret1
);
14451 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
14454 bytepos
= bitpos
/ BITS_PER_UNIT
;
14456 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
14457 else if (bytepos
< 0)
14458 loc_list_plus_const (list_ret
, bytepos
);
14465 if ((want_address
|| !tree_fits_shwi_p (loc
))
14466 && (ret
= cst_pool_loc_descr (loc
)))
14468 else if (want_address
== 2
14469 && tree_fits_shwi_p (loc
)
14470 && (ret
= address_of_int_loc_descriptor
14471 (int_size_in_bytes (TREE_TYPE (loc
)),
14472 tree_to_shwi (loc
))))
14474 else if (tree_fits_shwi_p (loc
))
14475 ret
= int_loc_descriptor (tree_to_shwi (loc
));
14478 expansion_failed (loc
, NULL_RTX
,
14479 "Integer operand is not host integer");
14488 if ((ret
= cst_pool_loc_descr (loc
)))
14491 /* We can construct small constants here using int_loc_descriptor. */
14492 expansion_failed (loc
, NULL_RTX
,
14493 "constructor or constant not in constant pool");
14496 case TRUTH_AND_EXPR
:
14497 case TRUTH_ANDIF_EXPR
:
14502 case TRUTH_XOR_EXPR
:
14507 case TRUTH_OR_EXPR
:
14508 case TRUTH_ORIF_EXPR
:
14513 case FLOOR_DIV_EXPR
:
14514 case CEIL_DIV_EXPR
:
14515 case ROUND_DIV_EXPR
:
14516 case TRUNC_DIV_EXPR
:
14517 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14526 case FLOOR_MOD_EXPR
:
14527 case CEIL_MOD_EXPR
:
14528 case ROUND_MOD_EXPR
:
14529 case TRUNC_MOD_EXPR
:
14530 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14535 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14536 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14537 if (list_ret
== 0 || list_ret1
== 0)
14540 add_loc_list (&list_ret
, list_ret1
);
14543 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14544 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14545 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
14546 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14547 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14559 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
14562 case POINTER_PLUS_EXPR
:
14564 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
14566 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14570 loc_list_plus_const (list_ret
, tree_to_shwi (TREE_OPERAND (loc
, 1)));
14578 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14585 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14592 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14599 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14614 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14615 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14616 if (list_ret
== 0 || list_ret1
== 0)
14619 add_loc_list (&list_ret
, list_ret1
);
14622 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14625 case TRUTH_NOT_EXPR
:
14639 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14643 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14649 const enum tree_code code
=
14650 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
14652 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
14653 build2 (code
, integer_type_node
,
14654 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
14655 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
14658 /* ... fall through ... */
14662 dw_loc_descr_ref lhs
14663 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
14664 dw_loc_list_ref rhs
14665 = loc_list_from_tree (TREE_OPERAND (loc
, 2), 0);
14666 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
14668 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14669 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
14672 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14673 add_loc_descr_to_each (list_ret
, bra_node
);
14675 add_loc_list (&list_ret
, rhs
);
14676 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14677 add_loc_descr_to_each (list_ret
, jump_node
);
14679 add_loc_descr_to_each (list_ret
, lhs
);
14680 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14681 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
14683 /* ??? Need a node to point the skip at. Use a nop. */
14684 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14685 add_loc_descr_to_each (list_ret
, tmp
);
14686 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14687 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14691 case FIX_TRUNC_EXPR
:
14695 /* Leave front-end specific codes as simply unknown. This comes
14696 up, for instance, with the C STMT_EXPR. */
14697 if ((unsigned int) TREE_CODE (loc
)
14698 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
14700 expansion_failed (loc
, NULL_RTX
,
14701 "language specific tree node");
14705 #ifdef ENABLE_CHECKING
14706 /* Otherwise this is a generic code; we should just lists all of
14707 these explicitly. We forgot one. */
14708 gcc_unreachable ();
14710 /* In a release build, we want to degrade gracefully: better to
14711 generate incomplete debugging information than to crash. */
14716 if (!ret
&& !list_ret
)
14719 if (want_address
== 2 && !have_address
14720 && (dwarf_version
>= 4 || !dwarf_strict
))
14722 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
14724 expansion_failed (loc
, NULL_RTX
,
14725 "DWARF address size mismatch");
14729 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14731 add_loc_descr_to_each (list_ret
,
14732 new_loc_descr (DW_OP_stack_value
, 0, 0));
14735 /* Show if we can't fill the request for an address. */
14736 if (want_address
&& !have_address
)
14738 expansion_failed (loc
, NULL_RTX
,
14739 "Want address and only have value");
14743 gcc_assert (!ret
|| !list_ret
);
14745 /* If we've got an address and don't want one, dereference. */
14746 if (!want_address
&& have_address
)
14748 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
14750 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
14752 expansion_failed (loc
, NULL_RTX
,
14753 "DWARF address size mismatch");
14756 else if (size
== DWARF2_ADDR_SIZE
)
14759 op
= DW_OP_deref_size
;
14762 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
14764 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
14767 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
14772 /* Same as above but return only single location expression. */
14773 static dw_loc_descr_ref
14774 loc_descriptor_from_tree (tree loc
, int want_address
)
14776 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
);
14779 if (ret
->dw_loc_next
)
14781 expansion_failed (loc
, NULL_RTX
,
14782 "Location list where only loc descriptor needed");
14788 /* Given a value, round it up to the lowest multiple of `boundary'
14789 which is not less than the value itself. */
14791 static inline HOST_WIDE_INT
14792 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
14794 return (((value
+ boundary
- 1) / boundary
) * boundary
);
14797 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
14798 pointer to the declared type for the relevant field variable, or return
14799 `integer_type_node' if the given node turns out to be an
14800 ERROR_MARK node. */
14803 field_type (const_tree decl
)
14807 if (TREE_CODE (decl
) == ERROR_MARK
)
14808 return integer_type_node
;
14810 type
= DECL_BIT_FIELD_TYPE (decl
);
14811 if (type
== NULL_TREE
)
14812 type
= TREE_TYPE (decl
);
14817 /* Given a pointer to a tree node, return the alignment in bits for
14818 it, or else return BITS_PER_WORD if the node actually turns out to
14819 be an ERROR_MARK node. */
14821 static inline unsigned
14822 simple_type_align_in_bits (const_tree type
)
14824 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
14827 static inline unsigned
14828 simple_decl_align_in_bits (const_tree decl
)
14830 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
14833 /* Return the result of rounding T up to ALIGN. */
14835 static inline offset_int
14836 round_up_to_align (const offset_int
&t
, unsigned int align
)
14838 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
14841 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
14842 lowest addressed byte of the "containing object" for the given FIELD_DECL,
14843 or return 0 if we are unable to determine what that offset is, either
14844 because the argument turns out to be a pointer to an ERROR_MARK node, or
14845 because the offset is actually variable. (We can't handle the latter case
14848 static HOST_WIDE_INT
14849 field_byte_offset (const_tree decl
)
14851 offset_int object_offset_in_bits
;
14852 offset_int object_offset_in_bytes
;
14853 offset_int bitpos_int
;
14855 if (TREE_CODE (decl
) == ERROR_MARK
)
14858 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
14860 /* We cannot yet cope with fields whose positions are variable, so
14861 for now, when we see such things, we simply return 0. Someday, we may
14862 be able to handle such cases, but it will be damn difficult. */
14863 if (TREE_CODE (bit_position (decl
)) != INTEGER_CST
)
14866 bitpos_int
= wi::to_offset (bit_position (decl
));
14868 #ifdef PCC_BITFIELD_TYPE_MATTERS
14869 if (PCC_BITFIELD_TYPE_MATTERS
)
14872 tree field_size_tree
;
14873 offset_int deepest_bitpos
;
14874 offset_int field_size_in_bits
;
14875 unsigned int type_align_in_bits
;
14876 unsigned int decl_align_in_bits
;
14877 offset_int type_size_in_bits
;
14879 type
= field_type (decl
);
14880 type_size_in_bits
= offset_int_type_size_in_bits (type
);
14881 type_align_in_bits
= simple_type_align_in_bits (type
);
14883 field_size_tree
= DECL_SIZE (decl
);
14885 /* The size could be unspecified if there was an error, or for
14886 a flexible array member. */
14887 if (!field_size_tree
)
14888 field_size_tree
= bitsize_zero_node
;
14890 /* If the size of the field is not constant, use the type size. */
14891 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
14892 field_size_in_bits
= wi::to_offset (field_size_tree
);
14894 field_size_in_bits
= type_size_in_bits
;
14896 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
14898 /* The GCC front-end doesn't make any attempt to keep track of the
14899 starting bit offset (relative to the start of the containing
14900 structure type) of the hypothetical "containing object" for a
14901 bit-field. Thus, when computing the byte offset value for the
14902 start of the "containing object" of a bit-field, we must deduce
14903 this information on our own. This can be rather tricky to do in
14904 some cases. For example, handling the following structure type
14905 definition when compiling for an i386/i486 target (which only
14906 aligns long long's to 32-bit boundaries) can be very tricky:
14908 struct S { int field1; long long field2:31; };
14910 Fortunately, there is a simple rule-of-thumb which can be used
14911 in such cases. When compiling for an i386/i486, GCC will
14912 allocate 8 bytes for the structure shown above. It decides to
14913 do this based upon one simple rule for bit-field allocation.
14914 GCC allocates each "containing object" for each bit-field at
14915 the first (i.e. lowest addressed) legitimate alignment boundary
14916 (based upon the required minimum alignment for the declared
14917 type of the field) which it can possibly use, subject to the
14918 condition that there is still enough available space remaining
14919 in the containing object (when allocated at the selected point)
14920 to fully accommodate all of the bits of the bit-field itself.
14922 This simple rule makes it obvious why GCC allocates 8 bytes for
14923 each object of the structure type shown above. When looking
14924 for a place to allocate the "containing object" for `field2',
14925 the compiler simply tries to allocate a 64-bit "containing
14926 object" at each successive 32-bit boundary (starting at zero)
14927 until it finds a place to allocate that 64- bit field such that
14928 at least 31 contiguous (and previously unallocated) bits remain
14929 within that selected 64 bit field. (As it turns out, for the
14930 example above, the compiler finds it is OK to allocate the
14931 "containing object" 64-bit field at bit-offset zero within the
14934 Here we attempt to work backwards from the limited set of facts
14935 we're given, and we try to deduce from those facts, where GCC
14936 must have believed that the containing object started (within
14937 the structure type). The value we deduce is then used (by the
14938 callers of this routine) to generate DW_AT_location and
14939 DW_AT_bit_offset attributes for fields (both bit-fields and, in
14940 the case of DW_AT_location, regular fields as well). */
14942 /* Figure out the bit-distance from the start of the structure to
14943 the "deepest" bit of the bit-field. */
14944 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
14946 /* This is the tricky part. Use some fancy footwork to deduce
14947 where the lowest addressed bit of the containing object must
14949 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14951 /* Round up to type_align by default. This works best for
14953 object_offset_in_bits
14954 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
14956 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
14958 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14960 /* Round up to decl_align instead. */
14961 object_offset_in_bits
14962 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
14966 #endif /* PCC_BITFIELD_TYPE_MATTERS */
14967 object_offset_in_bits
= bitpos_int
;
14969 object_offset_in_bytes
14970 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
14971 return object_offset_in_bytes
.to_shwi ();
14974 /* The following routines define various Dwarf attributes and any data
14975 associated with them. */
14977 /* Add a location description attribute value to a DIE.
14979 This emits location attributes suitable for whole variables and
14980 whole parameters. Note that the location attributes for struct fields are
14981 generated by the routine `data_member_location_attribute' below. */
14984 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
14985 dw_loc_list_ref descr
)
14989 if (single_element_loc_list_p (descr
))
14990 add_AT_loc (die
, attr_kind
, descr
->expr
);
14992 add_AT_loc_list (die
, attr_kind
, descr
);
14995 /* Add DW_AT_accessibility attribute to DIE if needed. */
14998 add_accessibility_attribute (dw_die_ref die
, tree decl
)
15000 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
15001 children, otherwise the default is DW_ACCESS_public. In DWARF2
15002 the default has always been DW_ACCESS_public. */
15003 if (TREE_PROTECTED (decl
))
15004 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
15005 else if (TREE_PRIVATE (decl
))
15007 if (dwarf_version
== 2
15008 || die
->die_parent
== NULL
15009 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
15010 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
15012 else if (dwarf_version
> 2
15014 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
15015 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
15018 /* Attach the specialized form of location attribute used for data members of
15019 struct and union types. In the special case of a FIELD_DECL node which
15020 represents a bit-field, the "offset" part of this special location
15021 descriptor must indicate the distance in bytes from the lowest-addressed
15022 byte of the containing struct or union type to the lowest-addressed byte of
15023 the "containing object" for the bit-field. (See the `field_byte_offset'
15026 For any given bit-field, the "containing object" is a hypothetical object
15027 (of some integral or enum type) within which the given bit-field lives. The
15028 type of this hypothetical "containing object" is always the same as the
15029 declared type of the individual bit-field itself (for GCC anyway... the
15030 DWARF spec doesn't actually mandate this). Note that it is the size (in
15031 bytes) of the hypothetical "containing object" which will be given in the
15032 DW_AT_byte_size attribute for this bit-field. (See the
15033 `byte_size_attribute' function below.) It is also used when calculating the
15034 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15035 function below.) */
15038 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
15040 HOST_WIDE_INT offset
;
15041 dw_loc_descr_ref loc_descr
= 0;
15043 if (TREE_CODE (decl
) == TREE_BINFO
)
15045 /* We're working on the TAG_inheritance for a base class. */
15046 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
15048 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15049 aren't at a fixed offset from all (sub)objects of the same
15050 type. We need to extract the appropriate offset from our
15051 vtable. The following dwarf expression means
15053 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15055 This is specific to the V3 ABI, of course. */
15057 dw_loc_descr_ref tmp
;
15059 /* Make a copy of the object address. */
15060 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
15061 add_loc_descr (&loc_descr
, tmp
);
15063 /* Extract the vtable address. */
15064 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
15065 add_loc_descr (&loc_descr
, tmp
);
15067 /* Calculate the address of the offset. */
15068 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
15069 gcc_assert (offset
< 0);
15071 tmp
= int_loc_descriptor (-offset
);
15072 add_loc_descr (&loc_descr
, tmp
);
15073 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
15074 add_loc_descr (&loc_descr
, tmp
);
15076 /* Extract the offset. */
15077 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
15078 add_loc_descr (&loc_descr
, tmp
);
15080 /* Add it to the object address. */
15081 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
15082 add_loc_descr (&loc_descr
, tmp
);
15085 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
15088 offset
= field_byte_offset (decl
);
15092 if (dwarf_version
> 2)
15094 /* Don't need to output a location expression, just the constant. */
15096 add_AT_int (die
, DW_AT_data_member_location
, offset
);
15098 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
15103 enum dwarf_location_atom op
;
15105 /* The DWARF2 standard says that we should assume that the structure
15106 address is already on the stack, so we can specify a structure
15107 field address by using DW_OP_plus_uconst. */
15108 op
= DW_OP_plus_uconst
;
15109 loc_descr
= new_loc_descr (op
, offset
, 0);
15113 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
15116 /* Writes integer values to dw_vec_const array. */
15119 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
15123 *dest
++ = val
& 0xff;
15129 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15131 static HOST_WIDE_INT
15132 extract_int (const unsigned char *src
, unsigned int size
)
15134 HOST_WIDE_INT val
= 0;
15140 val
|= *--src
& 0xff;
15146 /* Writes wide_int values to dw_vec_const array. */
15149 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
15153 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
15155 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
15159 /* We'd have to extend this code to support odd sizes. */
15160 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
15162 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
15164 if (WORDS_BIG_ENDIAN
)
15165 for (i
= n
- 1; i
>= 0; i
--)
15167 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
15168 dest
+= sizeof (HOST_WIDE_INT
);
15171 for (i
= 0; i
< n
; i
++)
15173 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
15174 dest
+= sizeof (HOST_WIDE_INT
);
15178 /* Writes floating point values to dw_vec_const array. */
15181 insert_float (const_rtx rtl
, unsigned char *array
)
15183 REAL_VALUE_TYPE rv
;
15187 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
15188 real_to_target (val
, &rv
, GET_MODE (rtl
));
15190 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15191 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
15193 insert_int (val
[i
], 4, array
);
15198 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15199 does not have a "location" either in memory or in a register. These
15200 things can arise in GNU C when a constant is passed as an actual parameter
15201 to an inlined function. They can also arise in C++ where declared
15202 constants do not necessarily get memory "homes". */
15205 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
15207 switch (GET_CODE (rtl
))
15211 HOST_WIDE_INT val
= INTVAL (rtl
);
15214 add_AT_int (die
, DW_AT_const_value
, val
);
15216 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
15220 case CONST_WIDE_INT
:
15221 add_AT_wide (die
, DW_AT_const_value
,
15222 std::make_pair (rtl
, GET_MODE (rtl
)));
15226 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15227 floating-point constant. A CONST_DOUBLE is used whenever the
15228 constant requires more than one word in order to be adequately
15231 enum machine_mode mode
= GET_MODE (rtl
);
15233 if (TARGET_SUPPORTS_WIDE_INT
== 0 && !SCALAR_FLOAT_MODE_P (mode
))
15234 add_AT_double (die
, DW_AT_const_value
,
15235 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
15238 unsigned int length
= GET_MODE_SIZE (mode
);
15239 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
15241 insert_float (rtl
, array
);
15242 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
15249 enum machine_mode mode
= GET_MODE (rtl
);
15250 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
15251 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
15252 unsigned char *array
15253 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
15256 enum machine_mode imode
= GET_MODE_INNER (mode
);
15258 switch (GET_MODE_CLASS (mode
))
15260 case MODE_VECTOR_INT
:
15261 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15263 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15264 insert_wide_int (std::make_pair (elt
, imode
), p
, elt_size
);
15268 case MODE_VECTOR_FLOAT
:
15269 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15271 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15272 insert_float (elt
, p
);
15277 gcc_unreachable ();
15280 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
15285 if (dwarf_version
>= 4 || !dwarf_strict
)
15287 dw_loc_descr_ref loc_result
;
15288 resolve_one_addr (&rtl
, NULL
);
15290 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15291 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
15292 add_AT_loc (die
, DW_AT_location
, loc_result
);
15293 vec_safe_push (used_rtx_array
, rtl
);
15299 if (CONSTANT_P (XEXP (rtl
, 0)))
15300 return add_const_value_attribute (die
, XEXP (rtl
, 0));
15303 if (!const_ok_for_output (rtl
))
15306 if (dwarf_version
>= 4 || !dwarf_strict
)
15311 /* In cases where an inlined instance of an inline function is passed
15312 the address of an `auto' variable (which is local to the caller) we
15313 can get a situation where the DECL_RTL of the artificial local
15314 variable (for the inlining) which acts as a stand-in for the
15315 corresponding formal parameter (of the inline function) will look
15316 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15317 exactly a compile-time constant expression, but it isn't the address
15318 of the (artificial) local variable either. Rather, it represents the
15319 *value* which the artificial local variable always has during its
15320 lifetime. We currently have no way to represent such quasi-constant
15321 values in Dwarf, so for now we just punt and generate nothing. */
15329 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
15330 && MEM_READONLY_P (rtl
)
15331 && GET_MODE (rtl
) == BLKmode
)
15333 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
15339 /* No other kinds of rtx should be possible here. */
15340 gcc_unreachable ();
15345 /* Determine whether the evaluation of EXPR references any variables
15346 or functions which aren't otherwise used (and therefore may not be
15349 reference_to_unused (tree
* tp
, int * walk_subtrees
,
15350 void * data ATTRIBUTE_UNUSED
)
15352 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
15353 *walk_subtrees
= 0;
15355 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
15356 && ! TREE_ASM_WRITTEN (*tp
))
15358 /* ??? The C++ FE emits debug information for using decls, so
15359 putting gcc_unreachable here falls over. See PR31899. For now
15360 be conservative. */
15361 else if (!cgraph_global_info_ready
15362 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
15364 else if (TREE_CODE (*tp
) == VAR_DECL
)
15366 varpool_node
*node
= varpool_get_node (*tp
);
15367 if (!node
|| !node
->definition
)
15370 else if (TREE_CODE (*tp
) == FUNCTION_DECL
15371 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
15373 /* The call graph machinery must have finished analyzing,
15374 optimizing and gimplifying the CU by now.
15375 So if *TP has no call graph node associated
15376 to it, it means *TP will not be emitted. */
15377 if (!cgraph_get_node (*tp
))
15380 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
15386 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15387 for use in a later add_const_value_attribute call. */
15390 rtl_for_decl_init (tree init
, tree type
)
15392 rtx rtl
= NULL_RTX
;
15396 /* If a variable is initialized with a string constant without embedded
15397 zeros, build CONST_STRING. */
15398 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
15400 tree enttype
= TREE_TYPE (type
);
15401 tree domain
= TYPE_DOMAIN (type
);
15402 enum machine_mode mode
= TYPE_MODE (enttype
);
15404 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
15406 && integer_zerop (TYPE_MIN_VALUE (domain
))
15407 && compare_tree_int (TYPE_MAX_VALUE (domain
),
15408 TREE_STRING_LENGTH (init
) - 1) == 0
15409 && ((size_t) TREE_STRING_LENGTH (init
)
15410 == strlen (TREE_STRING_POINTER (init
)) + 1))
15412 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
15413 ggc_strdup (TREE_STRING_POINTER (init
)));
15414 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
15415 MEM_READONLY_P (rtl
) = 1;
15418 /* Other aggregates, and complex values, could be represented using
15420 else if (AGGREGATE_TYPE_P (type
)
15421 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
15422 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
15423 || TREE_CODE (type
) == COMPLEX_TYPE
)
15425 /* Vectors only work if their mode is supported by the target.
15426 FIXME: generic vectors ought to work too. */
15427 else if (TREE_CODE (type
) == VECTOR_TYPE
15428 && !VECTOR_MODE_P (TYPE_MODE (type
)))
15430 /* If the initializer is something that we know will expand into an
15431 immediate RTL constant, expand it now. We must be careful not to
15432 reference variables which won't be output. */
15433 else if (initializer_constant_valid_p (init
, type
)
15434 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
15436 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15438 if (TREE_CODE (type
) == VECTOR_TYPE
)
15439 switch (TREE_CODE (init
))
15444 if (TREE_CONSTANT (init
))
15446 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
15447 bool constant_p
= true;
15449 unsigned HOST_WIDE_INT ix
;
15451 /* Even when ctor is constant, it might contain non-*_CST
15452 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15453 belong into VECTOR_CST nodes. */
15454 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
15455 if (!CONSTANT_CLASS_P (value
))
15457 constant_p
= false;
15463 init
= build_vector_from_ctor (type
, elts
);
15473 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
15475 /* If expand_expr returns a MEM, it wasn't immediate. */
15476 gcc_assert (!rtl
|| !MEM_P (rtl
));
15482 /* Generate RTL for the variable DECL to represent its location. */
15485 rtl_for_decl_location (tree decl
)
15489 /* Here we have to decide where we are going to say the parameter "lives"
15490 (as far as the debugger is concerned). We only have a couple of
15491 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15493 DECL_RTL normally indicates where the parameter lives during most of the
15494 activation of the function. If optimization is enabled however, this
15495 could be either NULL or else a pseudo-reg. Both of those cases indicate
15496 that the parameter doesn't really live anywhere (as far as the code
15497 generation parts of GCC are concerned) during most of the function's
15498 activation. That will happen (for example) if the parameter is never
15499 referenced within the function.
15501 We could just generate a location descriptor here for all non-NULL
15502 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15503 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15504 where DECL_RTL is NULL or is a pseudo-reg.
15506 Note however that we can only get away with using DECL_INCOMING_RTL as
15507 a backup substitute for DECL_RTL in certain limited cases. In cases
15508 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15509 we can be sure that the parameter was passed using the same type as it is
15510 declared to have within the function, and that its DECL_INCOMING_RTL
15511 points us to a place where a value of that type is passed.
15513 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15514 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15515 because in these cases DECL_INCOMING_RTL points us to a value of some
15516 type which is *different* from the type of the parameter itself. Thus,
15517 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15518 such cases, the debugger would end up (for example) trying to fetch a
15519 `float' from a place which actually contains the first part of a
15520 `double'. That would lead to really incorrect and confusing
15521 output at debug-time.
15523 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15524 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15525 are a couple of exceptions however. On little-endian machines we can
15526 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15527 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15528 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15529 when (on a little-endian machine) a non-prototyped function has a
15530 parameter declared to be of type `short' or `char'. In such cases,
15531 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15532 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15533 passed `int' value. If the debugger then uses that address to fetch
15534 a `short' or a `char' (on a little-endian machine) the result will be
15535 the correct data, so we allow for such exceptional cases below.
15537 Note that our goal here is to describe the place where the given formal
15538 parameter lives during most of the function's activation (i.e. between the
15539 end of the prologue and the start of the epilogue). We'll do that as best
15540 as we can. Note however that if the given formal parameter is modified
15541 sometime during the execution of the function, then a stack backtrace (at
15542 debug-time) will show the function as having been called with the *new*
15543 value rather than the value which was originally passed in. This happens
15544 rarely enough that it is not a major problem, but it *is* a problem, and
15545 I'd like to fix it.
15547 A future version of dwarf2out.c may generate two additional attributes for
15548 any given DW_TAG_formal_parameter DIE which will describe the "passed
15549 type" and the "passed location" for the given formal parameter in addition
15550 to the attributes we now generate to indicate the "declared type" and the
15551 "active location" for each parameter. This additional set of attributes
15552 could be used by debuggers for stack backtraces. Separately, note that
15553 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15554 This happens (for example) for inlined-instances of inline function formal
15555 parameters which are never referenced. This really shouldn't be
15556 happening. All PARM_DECL nodes should get valid non-NULL
15557 DECL_INCOMING_RTL values. FIXME. */
15559 /* Use DECL_RTL as the "location" unless we find something better. */
15560 rtl
= DECL_RTL_IF_SET (decl
);
15562 /* When generating abstract instances, ignore everything except
15563 constants, symbols living in memory, and symbols living in
15564 fixed registers. */
15565 if (! reload_completed
)
15568 && (CONSTANT_P (rtl
)
15570 && CONSTANT_P (XEXP (rtl
, 0)))
15572 && TREE_CODE (decl
) == VAR_DECL
15573 && TREE_STATIC (decl
))))
15575 rtl
= targetm
.delegitimize_address (rtl
);
15580 else if (TREE_CODE (decl
) == PARM_DECL
)
15582 if (rtl
== NULL_RTX
15583 || is_pseudo_reg (rtl
)
15585 && is_pseudo_reg (XEXP (rtl
, 0))
15586 && DECL_INCOMING_RTL (decl
)
15587 && MEM_P (DECL_INCOMING_RTL (decl
))
15588 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
15590 tree declared_type
= TREE_TYPE (decl
);
15591 tree passed_type
= DECL_ARG_TYPE (decl
);
15592 enum machine_mode dmode
= TYPE_MODE (declared_type
);
15593 enum machine_mode pmode
= TYPE_MODE (passed_type
);
15595 /* This decl represents a formal parameter which was optimized out.
15596 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15597 all cases where (rtl == NULL_RTX) just below. */
15598 if (dmode
== pmode
)
15599 rtl
= DECL_INCOMING_RTL (decl
);
15600 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
15601 && SCALAR_INT_MODE_P (dmode
)
15602 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
15603 && DECL_INCOMING_RTL (decl
))
15605 rtx inc
= DECL_INCOMING_RTL (decl
);
15608 else if (MEM_P (inc
))
15610 if (BYTES_BIG_ENDIAN
)
15611 rtl
= adjust_address_nv (inc
, dmode
,
15612 GET_MODE_SIZE (pmode
)
15613 - GET_MODE_SIZE (dmode
));
15620 /* If the parm was passed in registers, but lives on the stack, then
15621 make a big endian correction if the mode of the type of the
15622 parameter is not the same as the mode of the rtl. */
15623 /* ??? This is the same series of checks that are made in dbxout.c before
15624 we reach the big endian correction code there. It isn't clear if all
15625 of these checks are necessary here, but keeping them all is the safe
15627 else if (MEM_P (rtl
)
15628 && XEXP (rtl
, 0) != const0_rtx
15629 && ! CONSTANT_P (XEXP (rtl
, 0))
15630 /* Not passed in memory. */
15631 && !MEM_P (DECL_INCOMING_RTL (decl
))
15632 /* Not passed by invisible reference. */
15633 && (!REG_P (XEXP (rtl
, 0))
15634 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
15635 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
15636 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
15637 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
15640 /* Big endian correction check. */
15641 && BYTES_BIG_ENDIAN
15642 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
15643 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
15646 enum machine_mode addr_mode
= get_address_mode (rtl
);
15647 int offset
= (UNITS_PER_WORD
15648 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
15650 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15651 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
15654 else if (TREE_CODE (decl
) == VAR_DECL
15657 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
15658 && BYTES_BIG_ENDIAN
)
15660 enum machine_mode addr_mode
= get_address_mode (rtl
);
15661 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
15662 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
15664 /* If a variable is declared "register" yet is smaller than
15665 a register, then if we store the variable to memory, it
15666 looks like we're storing a register-sized value, when in
15667 fact we are not. We need to adjust the offset of the
15668 storage location to reflect the actual value's bytes,
15669 else gdb will not be able to display it. */
15671 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15672 plus_constant (addr_mode
, XEXP (rtl
, 0),
15676 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15677 and will have been substituted directly into all expressions that use it.
15678 C does not have such a concept, but C++ and other languages do. */
15679 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
15680 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
15683 rtl
= targetm
.delegitimize_address (rtl
);
15685 /* If we don't look past the constant pool, we risk emitting a
15686 reference to a constant pool entry that isn't referenced from
15687 code, and thus is not emitted. */
15689 rtl
= avoid_constant_pool_reference (rtl
);
15691 /* Try harder to get a rtl. If this symbol ends up not being emitted
15692 in the current CU, resolve_addr will remove the expression referencing
15694 if (rtl
== NULL_RTX
15695 && TREE_CODE (decl
) == VAR_DECL
15696 && !DECL_EXTERNAL (decl
)
15697 && TREE_STATIC (decl
)
15698 && DECL_NAME (decl
)
15699 && !DECL_HARD_REGISTER (decl
)
15700 && DECL_MODE (decl
) != VOIDmode
)
15702 rtl
= make_decl_rtl_for_debug (decl
);
15704 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
15705 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
15712 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15713 returned. If so, the decl for the COMMON block is returned, and the
15714 value is the offset into the common block for the symbol. */
15717 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
15719 tree val_expr
, cvar
;
15720 enum machine_mode mode
;
15721 HOST_WIDE_INT bitsize
, bitpos
;
15723 int unsignedp
, volatilep
= 0;
15725 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15726 it does not have a value (the offset into the common area), or if it
15727 is thread local (as opposed to global) then it isn't common, and shouldn't
15728 be handled as such. */
15729 if (TREE_CODE (decl
) != VAR_DECL
15730 || !TREE_STATIC (decl
)
15731 || !DECL_HAS_VALUE_EXPR_P (decl
)
15735 val_expr
= DECL_VALUE_EXPR (decl
);
15736 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
15739 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
,
15740 &mode
, &unsignedp
, &volatilep
, true);
15742 if (cvar
== NULL_TREE
15743 || TREE_CODE (cvar
) != VAR_DECL
15744 || DECL_ARTIFICIAL (cvar
)
15745 || !TREE_PUBLIC (cvar
))
15749 if (offset
!= NULL
)
15751 if (!tree_fits_shwi_p (offset
))
15753 *value
= tree_to_shwi (offset
);
15756 *value
+= bitpos
/ BITS_PER_UNIT
;
15761 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
15762 data attribute for a variable or a parameter. We generate the
15763 DW_AT_const_value attribute only in those cases where the given variable
15764 or parameter does not have a true "location" either in memory or in a
15765 register. This can happen (for example) when a constant is passed as an
15766 actual argument in a call to an inline function. (It's possible that
15767 these things can crop up in other ways also.) Note that one type of
15768 constant value which can be passed into an inlined function is a constant
15769 pointer. This can happen for example if an actual argument in an inlined
15770 function call evaluates to a compile-time constant address.
15772 CACHE_P is true if it is worth caching the location list for DECL,
15773 so that future calls can reuse it rather than regenerate it from scratch.
15774 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
15775 since we will need to refer to them each time the function is inlined. */
15778 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
,
15779 enum dwarf_attribute attr
)
15782 dw_loc_list_ref list
;
15783 var_loc_list
*loc_list
;
15784 cached_dw_loc_list
*cache
;
15787 if (TREE_CODE (decl
) == ERROR_MARK
)
15790 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
15791 || TREE_CODE (decl
) == RESULT_DECL
);
15793 /* Try to get some constant RTL for this decl, and use that as the value of
15796 rtl
= rtl_for_decl_location (decl
);
15797 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15798 && add_const_value_attribute (die
, rtl
))
15801 /* See if we have single element location list that is equivalent to
15802 a constant value. That way we are better to use add_const_value_attribute
15803 rather than expanding constant value equivalent. */
15804 loc_list
= lookup_decl_loc (decl
);
15807 && loc_list
->first
->next
== NULL
15808 && NOTE_P (loc_list
->first
->loc
)
15809 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
15810 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
15812 struct var_loc_node
*node
;
15814 node
= loc_list
->first
;
15815 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
15816 if (GET_CODE (rtl
) == EXPR_LIST
)
15817 rtl
= XEXP (rtl
, 0);
15818 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15819 && add_const_value_attribute (die
, rtl
))
15822 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
15823 list several times. See if we've already cached the contents. */
15825 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
15829 cache
= (cached_dw_loc_list
*)
15830 htab_find_with_hash (cached_dw_loc_list_table
, decl
, DECL_UID (decl
));
15832 list
= cache
->loc_list
;
15836 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2);
15837 /* It is usually worth caching this result if the decl is from
15838 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
15839 if (cache_p
&& list
&& list
->dw_loc_next
)
15841 slot
= htab_find_slot_with_hash (cached_dw_loc_list_table
, decl
,
15842 DECL_UID (decl
), INSERT
);
15843 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
15844 cache
->decl_id
= DECL_UID (decl
);
15845 cache
->loc_list
= list
;
15851 add_AT_location_description (die
, attr
, list
);
15854 /* None of that worked, so it must not really have a location;
15855 try adding a constant value attribute from the DECL_INITIAL. */
15856 return tree_add_const_value_attribute_for_decl (die
, decl
);
15859 /* Add VARIABLE and DIE into deferred locations list. */
15862 defer_location (tree variable
, dw_die_ref die
)
15864 deferred_locations entry
;
15865 entry
.variable
= variable
;
15867 vec_safe_push (deferred_locations_list
, entry
);
15870 /* Helper function for tree_add_const_value_attribute. Natively encode
15871 initializer INIT into an array. Return true if successful. */
15874 native_encode_initializer (tree init
, unsigned char *array
, int size
)
15878 if (init
== NULL_TREE
)
15882 switch (TREE_CODE (init
))
15885 type
= TREE_TYPE (init
);
15886 if (TREE_CODE (type
) == ARRAY_TYPE
)
15888 tree enttype
= TREE_TYPE (type
);
15889 enum machine_mode mode
= TYPE_MODE (enttype
);
15891 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
15893 if (int_size_in_bytes (type
) != size
)
15895 if (size
> TREE_STRING_LENGTH (init
))
15897 memcpy (array
, TREE_STRING_POINTER (init
),
15898 TREE_STRING_LENGTH (init
));
15899 memset (array
+ TREE_STRING_LENGTH (init
),
15900 '\0', size
- TREE_STRING_LENGTH (init
));
15903 memcpy (array
, TREE_STRING_POINTER (init
), size
);
15908 type
= TREE_TYPE (init
);
15909 if (int_size_in_bytes (type
) != size
)
15911 if (TREE_CODE (type
) == ARRAY_TYPE
)
15913 HOST_WIDE_INT min_index
;
15914 unsigned HOST_WIDE_INT cnt
;
15915 int curpos
= 0, fieldsize
;
15916 constructor_elt
*ce
;
15918 if (TYPE_DOMAIN (type
) == NULL_TREE
15919 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
15922 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
15923 if (fieldsize
<= 0)
15926 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
15927 memset (array
, '\0', size
);
15928 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15930 tree val
= ce
->value
;
15931 tree index
= ce
->index
;
15933 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15934 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
15937 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
15942 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
15945 curpos
= pos
+ fieldsize
;
15946 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15948 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
15949 - tree_to_shwi (TREE_OPERAND (index
, 0));
15950 while (count
-- > 0)
15953 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
15954 curpos
+= fieldsize
;
15957 gcc_assert (curpos
<= size
);
15961 else if (TREE_CODE (type
) == RECORD_TYPE
15962 || TREE_CODE (type
) == UNION_TYPE
)
15964 tree field
= NULL_TREE
;
15965 unsigned HOST_WIDE_INT cnt
;
15966 constructor_elt
*ce
;
15968 if (int_size_in_bytes (type
) != size
)
15971 if (TREE_CODE (type
) == RECORD_TYPE
)
15972 field
= TYPE_FIELDS (type
);
15974 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15976 tree val
= ce
->value
;
15977 int pos
, fieldsize
;
15979 if (ce
->index
!= 0)
15985 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
15988 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
15989 && TYPE_DOMAIN (TREE_TYPE (field
))
15990 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
15992 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
15993 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
15995 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
15996 pos
= int_byte_position (field
);
15997 gcc_assert (pos
+ fieldsize
<= size
);
15999 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
16005 case VIEW_CONVERT_EXPR
:
16006 case NON_LVALUE_EXPR
:
16007 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
16009 return native_encode_expr (init
, array
, size
) == size
;
16013 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16014 attribute is the const value T. */
16017 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
16020 tree type
= TREE_TYPE (t
);
16023 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
16027 gcc_assert (!DECL_P (init
));
16029 rtl
= rtl_for_decl_init (init
, type
);
16031 return add_const_value_attribute (die
, rtl
);
16032 /* If the host and target are sane, try harder. */
16033 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
16034 && initializer_constant_valid_p (init
, type
))
16036 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
16037 if (size
> 0 && (int) size
== size
)
16039 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
16041 if (native_encode_initializer (init
, array
, size
))
16043 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
16052 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16053 attribute is the const value of T, where T is an integral constant
16054 variable with static storage duration
16055 (so it can't be a PARM_DECL or a RESULT_DECL). */
16058 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
16062 || (TREE_CODE (decl
) != VAR_DECL
16063 && TREE_CODE (decl
) != CONST_DECL
)
16064 || (TREE_CODE (decl
) == VAR_DECL
16065 && !TREE_STATIC (decl
)))
16068 if (TREE_READONLY (decl
)
16069 && ! TREE_THIS_VOLATILE (decl
)
16070 && DECL_INITIAL (decl
))
16075 /* Don't add DW_AT_const_value if abstract origin already has one. */
16076 if (get_AT (var_die
, DW_AT_const_value
))
16079 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
16082 /* Convert the CFI instructions for the current function into a
16083 location list. This is used for DW_AT_frame_base when we targeting
16084 a dwarf2 consumer that does not support the dwarf3
16085 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16088 static dw_loc_list_ref
16089 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
16093 dw_loc_list_ref list
, *list_tail
;
16095 dw_cfa_location last_cfa
, next_cfa
;
16096 const char *start_label
, *last_label
, *section
;
16097 dw_cfa_location remember
;
16100 gcc_assert (fde
!= NULL
);
16102 section
= secname_for_decl (current_function_decl
);
16106 memset (&next_cfa
, 0, sizeof (next_cfa
));
16107 next_cfa
.reg
= INVALID_REGNUM
;
16108 remember
= next_cfa
;
16110 start_label
= fde
->dw_fde_begin
;
16112 /* ??? Bald assumption that the CIE opcode list does not contain
16113 advance opcodes. */
16114 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
16115 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16117 last_cfa
= next_cfa
;
16118 last_label
= start_label
;
16120 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
16122 /* If the first partition contained no CFI adjustments, the
16123 CIE opcodes apply to the whole first partition. */
16124 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16125 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
16126 list_tail
=&(*list_tail
)->dw_loc_next
;
16127 start_label
= last_label
= fde
->dw_fde_second_begin
;
16130 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
16132 switch (cfi
->dw_cfi_opc
)
16134 case DW_CFA_set_loc
:
16135 case DW_CFA_advance_loc1
:
16136 case DW_CFA_advance_loc2
:
16137 case DW_CFA_advance_loc4
:
16138 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16140 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16141 start_label
, last_label
, section
);
16143 list_tail
= &(*list_tail
)->dw_loc_next
;
16144 last_cfa
= next_cfa
;
16145 start_label
= last_label
;
16147 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
16150 case DW_CFA_advance_loc
:
16151 /* The encoding is complex enough that we should never emit this. */
16152 gcc_unreachable ();
16155 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16158 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
16160 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16162 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16163 start_label
, last_label
, section
);
16165 list_tail
= &(*list_tail
)->dw_loc_next
;
16166 last_cfa
= next_cfa
;
16167 start_label
= last_label
;
16169 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16170 start_label
, fde
->dw_fde_end
, section
);
16171 list_tail
= &(*list_tail
)->dw_loc_next
;
16172 start_label
= last_label
= fde
->dw_fde_second_begin
;
16176 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16178 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16179 start_label
, last_label
, section
);
16180 list_tail
= &(*list_tail
)->dw_loc_next
;
16181 start_label
= last_label
;
16184 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
16186 fde
->dw_fde_second_begin
16187 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
16190 if (list
&& list
->dw_loc_next
)
16196 /* Compute a displacement from the "steady-state frame pointer" to the
16197 frame base (often the same as the CFA), and store it in
16198 frame_pointer_fb_offset. OFFSET is added to the displacement
16199 before the latter is negated. */
16202 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
16206 #ifdef FRAME_POINTER_CFA_OFFSET
16207 reg
= frame_pointer_rtx
;
16208 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
16210 reg
= arg_pointer_rtx
;
16211 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
16214 elim
= (ira_use_lra_p
16215 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
16216 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
16217 if (GET_CODE (elim
) == PLUS
)
16219 offset
+= INTVAL (XEXP (elim
, 1));
16220 elim
= XEXP (elim
, 0);
16223 frame_pointer_fb_offset
= -offset
;
16225 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
16226 in which to eliminate. This is because it's stack pointer isn't
16227 directly accessible as a register within the ISA. To work around
16228 this, assume that while we cannot provide a proper value for
16229 frame_pointer_fb_offset, we won't need one either. */
16230 frame_pointer_fb_offset_valid
16231 = ((SUPPORTS_STACK_ALIGNMENT
16232 && (elim
== hard_frame_pointer_rtx
16233 || elim
== stack_pointer_rtx
))
16234 || elim
== (frame_pointer_needed
16235 ? hard_frame_pointer_rtx
16236 : stack_pointer_rtx
));
16239 /* Generate a DW_AT_name attribute given some string value to be included as
16240 the value of the attribute. */
16243 add_name_attribute (dw_die_ref die
, const char *name_string
)
16245 if (name_string
!= NULL
&& *name_string
!= 0)
16247 if (demangle_name_func
)
16248 name_string
= (*demangle_name_func
) (name_string
);
16250 add_AT_string (die
, DW_AT_name
, name_string
);
16254 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
16255 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
16256 of TYPE accordingly.
16258 ??? This is a temporary measure until after we're able to generate
16259 regular DWARF for the complex Ada type system. */
16262 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
16263 dw_die_ref context_die
)
16266 dw_die_ref dtype_die
;
16268 if (!lang_hooks
.types
.descriptive_type
)
16271 dtype
= lang_hooks
.types
.descriptive_type (type
);
16275 dtype_die
= lookup_type_die (dtype
);
16278 gen_type_die (dtype
, context_die
);
16279 dtype_die
= lookup_type_die (dtype
);
16280 gcc_assert (dtype_die
);
16283 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
16286 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
16288 static const char *
16289 comp_dir_string (void)
16293 static const char *cached_wd
= NULL
;
16295 if (cached_wd
!= NULL
)
16298 wd
= get_src_pwd ();
16302 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
16306 wdlen
= strlen (wd
);
16307 wd1
= ggc_vec_alloc
<char> (wdlen
+ 2);
16309 wd1
[wdlen
] = DIR_SEPARATOR
;
16310 wd1
[wdlen
+ 1] = 0;
16314 cached_wd
= remap_debug_filename (wd
);
16318 /* Generate a DW_AT_comp_dir attribute for DIE. */
16321 add_comp_dir_attribute (dw_die_ref die
)
16323 const char * wd
= comp_dir_string ();
16325 add_AT_string (die
, DW_AT_comp_dir
, wd
);
16328 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16332 lower_bound_default (void)
16334 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
16339 case DW_LANG_C_plus_plus
:
16341 case DW_LANG_ObjC_plus_plus
:
16344 case DW_LANG_Fortran77
:
16345 case DW_LANG_Fortran90
:
16346 case DW_LANG_Fortran95
:
16350 case DW_LANG_Python
:
16351 return dwarf_version
>= 4 ? 0 : -1;
16352 case DW_LANG_Ada95
:
16353 case DW_LANG_Ada83
:
16354 case DW_LANG_Cobol74
:
16355 case DW_LANG_Cobol85
:
16356 case DW_LANG_Pascal83
:
16357 case DW_LANG_Modula2
:
16359 return dwarf_version
>= 4 ? 1 : -1;
16365 /* Given a tree node describing an array bound (either lower or upper) output
16366 a representation for that bound. */
16369 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
16371 switch (TREE_CODE (bound
))
16376 /* All fixed-bounds are represented by INTEGER_CST nodes. */
16379 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (bound
));
16382 /* Use the default if possible. */
16383 if (bound_attr
== DW_AT_lower_bound
16384 && tree_fits_shwi_p (bound
)
16385 && (dflt
= lower_bound_default ()) != -1
16386 && tree_to_shwi (bound
) == dflt
)
16389 /* If HOST_WIDE_INT is big enough then represent the bound as
16390 a constant value. We need to choose a form based on
16391 whether the type is signed or unsigned. We cannot just
16392 call add_AT_unsigned if the value itself is positive
16393 (add_AT_unsigned might add the unsigned value encoded as
16394 DW_FORM_data[1248]). Some DWARF consumers will lookup the
16395 bounds type and then sign extend any unsigned values found
16396 for signed types. This is needed only for
16397 DW_AT_{lower,upper}_bound, since for most other attributes,
16398 consumers will treat DW_FORM_data[1248] as unsigned values,
16399 regardless of the underlying type. */
16400 else if (prec
<= HOST_BITS_PER_WIDE_INT
16401 || tree_fits_uhwi_p (bound
))
16403 if (TYPE_UNSIGNED (TREE_TYPE (bound
)))
16404 add_AT_unsigned (subrange_die
, bound_attr
,
16405 TREE_INT_CST_LOW (bound
));
16407 add_AT_int (subrange_die
, bound_attr
, TREE_INT_CST_LOW (bound
));
16410 /* Otherwise represent the bound as an unsigned value with
16411 the precision of its type. The precision and signedness
16412 of the type will be necessary to re-interpret it
16414 add_AT_wide (subrange_die
, bound_attr
, bound
);
16419 case VIEW_CONVERT_EXPR
:
16420 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
16430 dw_die_ref decl_die
= lookup_decl_die (bound
);
16432 /* ??? Can this happen, or should the variable have been bound
16433 first? Probably it can, since I imagine that we try to create
16434 the types of parameters in the order in which they exist in
16435 the list, and won't have created a forward reference to a
16436 later parameter. */
16437 if (decl_die
!= NULL
)
16439 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16447 /* Otherwise try to create a stack operation procedure to
16448 evaluate the value of the array bound. */
16450 dw_die_ref ctx
, decl_die
;
16451 dw_loc_list_ref list
;
16453 list
= loc_list_from_tree (bound
, 2);
16454 if (list
== NULL
|| single_element_loc_list_p (list
))
16456 /* If DW_AT_*bound is not a reference nor constant, it is
16457 a DWARF expression rather than location description.
16458 For that loc_list_from_tree (bound, 0) is needed.
16459 If that fails to give a single element list,
16460 fall back to outputting this as a reference anyway. */
16461 dw_loc_list_ref list2
= loc_list_from_tree (bound
, 0);
16462 if (list2
&& single_element_loc_list_p (list2
))
16464 add_AT_loc (subrange_die
, bound_attr
, list2
->expr
);
16471 if (current_function_decl
== 0)
16472 ctx
= comp_unit_die ();
16474 ctx
= lookup_decl_die (current_function_decl
);
16476 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
16477 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
16478 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
16479 add_AT_location_description (decl_die
, DW_AT_location
, list
);
16480 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16486 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16487 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16488 Note that the block of subscript information for an array type also
16489 includes information about the element type of the given array type. */
16492 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
16494 unsigned dimension_number
;
16496 dw_die_ref subrange_die
;
16498 for (dimension_number
= 0;
16499 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
16500 type
= TREE_TYPE (type
), dimension_number
++)
16502 tree domain
= TYPE_DOMAIN (type
);
16504 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
16507 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16508 and (in GNU C only) variable bounds. Handle all three forms
16510 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
16513 /* We have an array type with specified bounds. */
16514 lower
= TYPE_MIN_VALUE (domain
);
16515 upper
= TYPE_MAX_VALUE (domain
);
16517 /* Define the index type. */
16518 if (TREE_TYPE (domain
))
16520 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16521 TREE_TYPE field. We can't emit debug info for this
16522 because it is an unnamed integral type. */
16523 if (TREE_CODE (domain
) == INTEGER_TYPE
16524 && TYPE_NAME (domain
) == NULL_TREE
16525 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
16526 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
16529 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
16533 /* ??? If upper is NULL, the array has unspecified length,
16534 but it does have a lower bound. This happens with Fortran
16536 Since the debugger is definitely going to need to know N
16537 to produce useful results, go ahead and output the lower
16538 bound solo, and hope the debugger can cope. */
16540 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
16542 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
16545 /* Otherwise we have an array type with an unspecified length. The
16546 DWARF-2 spec does not say how to handle this; let's just leave out the
16551 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
16554 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
16556 dw_die_ref decl_die
;
16557 HOST_WIDE_INT size
;
16559 switch (TREE_CODE (tree_node
))
16564 case ENUMERAL_TYPE
:
16567 case QUAL_UNION_TYPE
:
16568 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
16569 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
16571 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
16574 size
= int_size_in_bytes (tree_node
);
16577 /* For a data member of a struct or union, the DW_AT_byte_size is
16578 generally given as the number of bytes normally allocated for an
16579 object of the *declared* type of the member itself. This is true
16580 even for bit-fields. */
16581 size
= int_size_in_bytes (field_type (tree_node
));
16584 gcc_unreachable ();
16587 /* Note that `size' might be -1 when we get to this point. If it is, that
16588 indicates that the byte size of the entity in question is variable. We
16589 have no good way of expressing this fact in Dwarf at the present time,
16590 when location description was not used by the caller code instead. */
16592 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
16595 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16596 which specifies the distance in bits from the highest order bit of the
16597 "containing object" for the bit-field to the highest order bit of the
16600 For any given bit-field, the "containing object" is a hypothetical object
16601 (of some integral or enum type) within which the given bit-field lives. The
16602 type of this hypothetical "containing object" is always the same as the
16603 declared type of the individual bit-field itself. The determination of the
16604 exact location of the "containing object" for a bit-field is rather
16605 complicated. It's handled by the `field_byte_offset' function (above).
16607 Note that it is the size (in bytes) of the hypothetical "containing object"
16608 which will be given in the DW_AT_byte_size attribute for this bit-field.
16609 (See `byte_size_attribute' above). */
16612 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
16614 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
16615 tree type
= DECL_BIT_FIELD_TYPE (decl
);
16616 HOST_WIDE_INT bitpos_int
;
16617 HOST_WIDE_INT highest_order_object_bit_offset
;
16618 HOST_WIDE_INT highest_order_field_bit_offset
;
16619 HOST_WIDE_INT bit_offset
;
16621 /* Must be a field and a bit field. */
16622 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
16624 /* We can't yet handle bit-fields whose offsets are variable, so if we
16625 encounter such things, just return without generating any attribute
16626 whatsoever. Likewise for variable or too large size. */
16627 if (! tree_fits_shwi_p (bit_position (decl
))
16628 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
16631 bitpos_int
= int_bit_position (decl
);
16633 /* Note that the bit offset is always the distance (in bits) from the
16634 highest-order bit of the "containing object" to the highest-order bit of
16635 the bit-field itself. Since the "high-order end" of any object or field
16636 is different on big-endian and little-endian machines, the computation
16637 below must take account of these differences. */
16638 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
16639 highest_order_field_bit_offset
= bitpos_int
;
16641 if (! BYTES_BIG_ENDIAN
)
16643 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
16644 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
16648 = (! BYTES_BIG_ENDIAN
16649 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
16650 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
16652 if (bit_offset
< 0)
16653 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
16655 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
16658 /* For a FIELD_DECL node which represents a bit field, output an attribute
16659 which specifies the length in bits of the given field. */
16662 add_bit_size_attribute (dw_die_ref die
, tree decl
)
16664 /* Must be a field and a bit field. */
16665 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
16666 && DECL_BIT_FIELD_TYPE (decl
));
16668 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
16669 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
16672 /* If the compiled language is ANSI C, then add a 'prototyped'
16673 attribute, if arg types are given for the parameters of a function. */
16676 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
16678 if (get_AT_unsigned (comp_unit_die (), DW_AT_language
) == DW_LANG_C89
16679 && prototype_p (func_type
))
16680 add_AT_flag (die
, DW_AT_prototyped
, 1);
16683 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
16684 by looking in either the type declaration or object declaration
16687 static inline dw_die_ref
16688 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
16690 dw_die_ref origin_die
= NULL
;
16692 if (TREE_CODE (origin
) != FUNCTION_DECL
)
16694 /* We may have gotten separated from the block for the inlined
16695 function, if we're in an exception handler or some such; make
16696 sure that the abstract function has been written out.
16698 Doing this for nested functions is wrong, however; functions are
16699 distinct units, and our context might not even be inline. */
16703 fn
= TYPE_STUB_DECL (fn
);
16705 fn
= decl_function_context (fn
);
16707 dwarf2out_abstract_function (fn
);
16710 if (DECL_P (origin
))
16711 origin_die
= lookup_decl_die (origin
);
16712 else if (TYPE_P (origin
))
16713 origin_die
= lookup_type_die (origin
);
16715 /* XXX: Functions that are never lowered don't always have correct block
16716 trees (in the case of java, they simply have no block tree, in some other
16717 languages). For these functions, there is nothing we can really do to
16718 output correct debug info for inlined functions in all cases. Rather
16719 than die, we'll just produce deficient debug info now, in that we will
16720 have variables without a proper abstract origin. In the future, when all
16721 functions are lowered, we should re-add a gcc_assert (origin_die)
16725 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
16729 /* We do not currently support the pure_virtual attribute. */
16732 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
16734 if (DECL_VINDEX (func_decl
))
16736 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
16738 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
16739 add_AT_loc (die
, DW_AT_vtable_elem_location
,
16740 new_loc_descr (DW_OP_constu
,
16741 tree_to_shwi (DECL_VINDEX (func_decl
)),
16744 /* GNU extension: Record what type this method came from originally. */
16745 if (debug_info_level
> DINFO_LEVEL_TERSE
16746 && DECL_CONTEXT (func_decl
))
16747 add_AT_die_ref (die
, DW_AT_containing_type
,
16748 lookup_type_die (DECL_CONTEXT (func_decl
)));
16752 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
16753 given decl. This used to be a vendor extension until after DWARF 4
16754 standardized it. */
16757 add_linkage_attr (dw_die_ref die
, tree decl
)
16759 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
16761 /* Mimic what assemble_name_raw does with a leading '*'. */
16762 if (name
[0] == '*')
16765 if (dwarf_version
>= 4)
16766 add_AT_string (die
, DW_AT_linkage_name
, name
);
16768 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
16771 /* Add source coordinate attributes for the given decl. */
16774 add_src_coords_attributes (dw_die_ref die
, tree decl
)
16776 expanded_location s
;
16778 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
16780 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
16781 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
16782 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
16785 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
16788 add_linkage_name (dw_die_ref die
, tree decl
)
16790 if (debug_info_level
> DINFO_LEVEL_NONE
16791 && (TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
16792 && TREE_PUBLIC (decl
)
16793 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
16794 && die
->die_tag
!= DW_TAG_member
)
16796 /* Defer until we have an assembler name set. */
16797 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
16799 limbo_die_node
*asm_name
;
16801 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
16802 asm_name
->die
= die
;
16803 asm_name
->created_for
= decl
;
16804 asm_name
->next
= deferred_asm_name
;
16805 deferred_asm_name
= asm_name
;
16807 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
16808 add_linkage_attr (die
, decl
);
16812 /* Add a DW_AT_name attribute and source coordinate attribute for the
16813 given decl, but only if it actually has a name. */
16816 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
16820 decl_name
= DECL_NAME (decl
);
16821 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
16823 const char *name
= dwarf2_name (decl
, 0);
16825 add_name_attribute (die
, name
);
16826 if (! DECL_ARTIFICIAL (decl
))
16827 add_src_coords_attributes (die
, decl
);
16829 add_linkage_name (die
, decl
);
16832 #ifdef VMS_DEBUGGING_INFO
16833 /* Get the function's name, as described by its RTL. This may be different
16834 from the DECL_NAME name used in the source file. */
16835 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
16837 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
16838 XEXP (DECL_RTL (decl
), 0), false);
16839 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
16841 #endif /* VMS_DEBUGGING_INFO */
16844 #ifdef VMS_DEBUGGING_INFO
16845 /* Output the debug main pointer die for VMS */
16848 dwarf2out_vms_debug_main_pointer (void)
16850 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
16853 /* Allocate the VMS debug main subprogram die. */
16854 die
= ggc_cleared_alloc
<die_node
> ();
16855 die
->die_tag
= DW_TAG_subprogram
;
16856 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
16857 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
16858 current_function_funcdef_no
);
16859 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
16861 /* Make it the first child of comp_unit_die (). */
16862 die
->die_parent
= comp_unit_die ();
16863 if (comp_unit_die ()->die_child
)
16865 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
16866 comp_unit_die ()->die_child
->die_sib
= die
;
16870 die
->die_sib
= die
;
16871 comp_unit_die ()->die_child
= die
;
16874 #endif /* VMS_DEBUGGING_INFO */
16876 /* Push a new declaration scope. */
16879 push_decl_scope (tree scope
)
16881 vec_safe_push (decl_scope_table
, scope
);
16884 /* Pop a declaration scope. */
16887 pop_decl_scope (void)
16889 decl_scope_table
->pop ();
16892 /* walk_tree helper function for uses_local_type, below. */
16895 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
16898 *walk_subtrees
= 0;
16901 tree name
= TYPE_NAME (*tp
);
16902 if (name
&& DECL_P (name
) && decl_function_context (name
))
16908 /* If TYPE involves a function-local type (including a local typedef to a
16909 non-local type), returns that type; otherwise returns NULL_TREE. */
16912 uses_local_type (tree type
)
16914 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
16918 /* Return the DIE for the scope that immediately contains this type.
16919 Non-named types that do not involve a function-local type get global
16920 scope. Named types nested in namespaces or other types get their
16921 containing scope. All other types (i.e. function-local named types) get
16922 the current active scope. */
16925 scope_die_for (tree t
, dw_die_ref context_die
)
16927 dw_die_ref scope_die
= NULL
;
16928 tree containing_scope
;
16930 /* Non-types always go in the current scope. */
16931 gcc_assert (TYPE_P (t
));
16933 /* Use the scope of the typedef, rather than the scope of the type
16935 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
16936 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
16938 containing_scope
= TYPE_CONTEXT (t
);
16940 /* Use the containing namespace if there is one. */
16941 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
16943 if (context_die
== lookup_decl_die (containing_scope
))
16945 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
16946 context_die
= get_context_die (containing_scope
);
16948 containing_scope
= NULL_TREE
;
16951 /* Ignore function type "scopes" from the C frontend. They mean that
16952 a tagged type is local to a parmlist of a function declarator, but
16953 that isn't useful to DWARF. */
16954 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
16955 containing_scope
= NULL_TREE
;
16957 if (SCOPE_FILE_SCOPE_P (containing_scope
))
16959 /* If T uses a local type keep it local as well, to avoid references
16960 to function-local DIEs from outside the function. */
16961 if (current_function_decl
&& uses_local_type (t
))
16962 scope_die
= context_die
;
16964 scope_die
= comp_unit_die ();
16966 else if (TYPE_P (containing_scope
))
16968 /* For types, we can just look up the appropriate DIE. */
16969 if (debug_info_level
> DINFO_LEVEL_TERSE
)
16970 scope_die
= get_context_die (containing_scope
);
16973 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
16974 if (scope_die
== NULL
)
16975 scope_die
= comp_unit_die ();
16979 scope_die
= context_die
;
16984 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
16987 local_scope_p (dw_die_ref context_die
)
16989 for (; context_die
; context_die
= context_die
->die_parent
)
16990 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
16991 || context_die
->die_tag
== DW_TAG_subprogram
)
16997 /* Returns nonzero if CONTEXT_DIE is a class. */
17000 class_scope_p (dw_die_ref context_die
)
17002 return (context_die
17003 && (context_die
->die_tag
== DW_TAG_structure_type
17004 || context_die
->die_tag
== DW_TAG_class_type
17005 || context_die
->die_tag
== DW_TAG_interface_type
17006 || context_die
->die_tag
== DW_TAG_union_type
));
17009 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17010 whether or not to treat a DIE in this context as a declaration. */
17013 class_or_namespace_scope_p (dw_die_ref context_die
)
17015 return (class_scope_p (context_die
)
17016 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
17019 /* Many forms of DIEs require a "type description" attribute. This
17020 routine locates the proper "type descriptor" die for the type given
17021 by 'type', and adds a DW_AT_type attribute below the given die. */
17024 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
17025 int decl_volatile
, dw_die_ref context_die
)
17027 enum tree_code code
= TREE_CODE (type
);
17028 dw_die_ref type_die
= NULL
;
17030 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17031 or fixed-point type, use the inner type. This is because we have no
17032 support for unnamed types in base_type_die. This can happen if this is
17033 an Ada subrange type. Correct solution is emit a subrange type die. */
17034 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
17035 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
17036 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
17038 if (code
== ERROR_MARK
17039 /* Handle a special case. For functions whose return type is void, we
17040 generate *no* type attribute. (Note that no object may have type
17041 `void', so this only applies to function return types). */
17042 || code
== VOID_TYPE
)
17045 type_die
= modified_type_die (type
,
17046 decl_const
|| TYPE_READONLY (type
),
17047 decl_volatile
|| TYPE_VOLATILE (type
),
17050 if (type_die
!= NULL
)
17051 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
17054 /* Given an object die, add the calling convention attribute for the
17055 function call type. */
17057 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
17059 enum dwarf_calling_convention value
= DW_CC_normal
;
17061 value
= ((enum dwarf_calling_convention
)
17062 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
17065 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
17067 /* DWARF 2 doesn't provide a way to identify a program's source-level
17068 entry point. DW_AT_calling_convention attributes are only meant
17069 to describe functions' calling conventions. However, lacking a
17070 better way to signal the Fortran main program, we used this for
17071 a long time, following existing custom. Now, DWARF 4 has
17072 DW_AT_main_subprogram, which we add below, but some tools still
17073 rely on the old way, which we thus keep. */
17074 value
= DW_CC_program
;
17076 if (dwarf_version
>= 4 || !dwarf_strict
)
17077 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
17080 /* Only add the attribute if the backend requests it, and
17081 is not DW_CC_normal. */
17082 if (value
&& (value
!= DW_CC_normal
))
17083 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
17086 /* Given a tree pointer to a struct, class, union, or enum type node, return
17087 a pointer to the (string) tag name for the given type, or zero if the type
17088 was declared without a tag. */
17090 static const char *
17091 type_tag (const_tree type
)
17093 const char *name
= 0;
17095 if (TYPE_NAME (type
) != 0)
17099 /* Find the IDENTIFIER_NODE for the type name. */
17100 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
17101 && !TYPE_NAMELESS (type
))
17102 t
= TYPE_NAME (type
);
17104 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17105 a TYPE_DECL node, regardless of whether or not a `typedef' was
17107 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
17108 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
17110 /* We want to be extra verbose. Don't call dwarf_name if
17111 DECL_NAME isn't set. The default hook for decl_printable_name
17112 doesn't like that, and in this context it's correct to return
17113 0, instead of "<anonymous>" or the like. */
17114 if (DECL_NAME (TYPE_NAME (type
))
17115 && !DECL_NAMELESS (TYPE_NAME (type
)))
17116 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
17119 /* Now get the name as a string, or invent one. */
17120 if (!name
&& t
!= 0)
17121 name
= IDENTIFIER_POINTER (t
);
17124 return (name
== 0 || *name
== '\0') ? 0 : name
;
17127 /* Return the type associated with a data member, make a special check
17128 for bit field types. */
17131 member_declared_type (const_tree member
)
17133 return (DECL_BIT_FIELD_TYPE (member
)
17134 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
17137 /* Get the decl's label, as described by its RTL. This may be different
17138 from the DECL_NAME name used in the source file. */
17141 static const char *
17142 decl_start_label (tree decl
)
17145 const char *fnname
;
17147 x
= DECL_RTL (decl
);
17148 gcc_assert (MEM_P (x
));
17151 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
17153 fnname
= XSTR (x
, 0);
17158 /* These routines generate the internal representation of the DIE's for
17159 the compilation unit. Debugging information is collected by walking
17160 the declaration trees passed in from dwarf2out_decl(). */
17163 gen_array_type_die (tree type
, dw_die_ref context_die
)
17165 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17166 dw_die_ref array_die
;
17168 /* GNU compilers represent multidimensional array types as sequences of one
17169 dimensional array types whose element types are themselves array types.
17170 We sometimes squish that down to a single array_type DIE with multiple
17171 subscripts in the Dwarf debugging info. The draft Dwarf specification
17172 say that we are allowed to do this kind of compression in C, because
17173 there is no difference between an array of arrays and a multidimensional
17174 array. We don't do this for Ada to remain as close as possible to the
17175 actual representation, which is especially important against the language
17176 flexibilty wrt arrays of variable size. */
17178 bool collapse_nested_arrays
= !is_ada ();
17181 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17182 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17183 if (TYPE_STRING_FLAG (type
)
17184 && TREE_CODE (type
) == ARRAY_TYPE
17186 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
17188 HOST_WIDE_INT size
;
17190 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
17191 add_name_attribute (array_die
, type_tag (type
));
17192 equate_type_number_to_die (type
, array_die
);
17193 size
= int_size_in_bytes (type
);
17195 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17196 else if (TYPE_DOMAIN (type
) != NULL_TREE
17197 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
17198 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
17200 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
17201 dw_loc_list_ref loc
= loc_list_from_tree (szdecl
, 2);
17203 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
17204 if (loc
&& size
> 0)
17206 add_AT_location_description (array_die
, DW_AT_string_length
, loc
);
17207 if (size
!= DWARF2_ADDR_SIZE
)
17208 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17214 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17215 add_name_attribute (array_die
, type_tag (type
));
17216 equate_type_number_to_die (type
, array_die
);
17218 if (TREE_CODE (type
) == VECTOR_TYPE
)
17219 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
17221 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17223 && TREE_CODE (type
) == ARRAY_TYPE
17224 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
17225 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
17226 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17229 /* We default the array ordering. SDB will probably do
17230 the right things even if DW_AT_ordering is not present. It's not even
17231 an issue until we start to get into multidimensional arrays anyway. If
17232 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17233 then we'll have to put the DW_AT_ordering attribute back in. (But if
17234 and when we find out that we need to put these in, we will only do so
17235 for multidimensional arrays. */
17236 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
17239 if (TREE_CODE (type
) == VECTOR_TYPE
)
17241 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
17242 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17243 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
);
17244 add_bound_info (subrange_die
, DW_AT_upper_bound
,
17245 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
17248 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
17250 /* Add representation of the type of the elements of this array type and
17251 emit the corresponding DIE if we haven't done it already. */
17252 element_type
= TREE_TYPE (type
);
17253 if (collapse_nested_arrays
)
17254 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
17256 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
17258 element_type
= TREE_TYPE (element_type
);
17261 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
17263 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
17264 if (TYPE_ARTIFICIAL (type
))
17265 add_AT_flag (array_die
, DW_AT_artificial
, 1);
17267 if (get_AT (array_die
, DW_AT_name
))
17268 add_pubtype (type
, array_die
);
17271 static dw_loc_descr_ref
17272 descr_info_loc (tree val
, tree base_decl
)
17274 HOST_WIDE_INT size
;
17275 dw_loc_descr_ref loc
, loc2
;
17276 enum dwarf_location_atom op
;
17278 if (val
== base_decl
)
17279 return new_loc_descr (DW_OP_push_object_address
, 0, 0);
17281 switch (TREE_CODE (val
))
17284 return descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17286 return loc_descriptor_from_tree (val
, 0);
17288 if (tree_fits_shwi_p (val
))
17289 return int_loc_descriptor (tree_to_shwi (val
));
17292 size
= int_size_in_bytes (TREE_TYPE (val
));
17295 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17298 if (size
== DWARF2_ADDR_SIZE
)
17299 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref
, 0, 0));
17301 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref_size
, size
, 0));
17303 case POINTER_PLUS_EXPR
:
17305 if (tree_fits_uhwi_p (TREE_OPERAND (val
, 1))
17306 && tree_to_uhwi (TREE_OPERAND (val
, 1)) < 16384)
17308 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17311 loc_descr_plus_const (&loc
, tree_to_shwi (TREE_OPERAND (val
, 1)));
17317 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17320 loc2
= descr_info_loc (TREE_OPERAND (val
, 1), base_decl
);
17323 add_loc_descr (&loc
, loc2
);
17324 add_loc_descr (&loc2
, new_loc_descr (op
, 0, 0));
17346 add_descr_info_field (dw_die_ref die
, enum dwarf_attribute attr
,
17347 tree val
, tree base_decl
)
17349 dw_loc_descr_ref loc
;
17351 if (tree_fits_shwi_p (val
))
17353 add_AT_unsigned (die
, attr
, tree_to_shwi (val
));
17357 loc
= descr_info_loc (val
, base_decl
);
17361 add_AT_loc (die
, attr
, loc
);
17364 /* This routine generates DIE for array with hidden descriptor, details
17365 are filled into *info by a langhook. */
17368 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
17369 dw_die_ref context_die
)
17371 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17372 dw_die_ref array_die
;
17375 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17376 add_name_attribute (array_die
, type_tag (type
));
17377 equate_type_number_to_die (type
, array_die
);
17379 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17381 && info
->ndimensions
>= 2)
17382 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17384 if (info
->data_location
)
17385 add_descr_info_field (array_die
, DW_AT_data_location
, info
->data_location
,
17387 if (info
->associated
)
17388 add_descr_info_field (array_die
, DW_AT_associated
, info
->associated
,
17390 if (info
->allocated
)
17391 add_descr_info_field (array_die
, DW_AT_allocated
, info
->allocated
,
17394 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
17396 dw_die_ref subrange_die
17397 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17399 if (info
->dimen
[dim
].lower_bound
)
17401 /* If it is the default value, omit it. */
17404 if (tree_fits_shwi_p (info
->dimen
[dim
].lower_bound
)
17405 && (dflt
= lower_bound_default ()) != -1
17406 && tree_to_shwi (info
->dimen
[dim
].lower_bound
) == dflt
)
17409 add_descr_info_field (subrange_die
, DW_AT_lower_bound
,
17410 info
->dimen
[dim
].lower_bound
,
17413 if (info
->dimen
[dim
].upper_bound
)
17414 add_descr_info_field (subrange_die
, DW_AT_upper_bound
,
17415 info
->dimen
[dim
].upper_bound
,
17417 if (info
->dimen
[dim
].stride
)
17418 add_descr_info_field (subrange_die
, DW_AT_byte_stride
,
17419 info
->dimen
[dim
].stride
,
17423 gen_type_die (info
->element_type
, context_die
);
17424 add_type_attribute (array_die
, info
->element_type
, 0, 0, context_die
);
17426 if (get_AT (array_die
, DW_AT_name
))
17427 add_pubtype (type
, array_die
);
17432 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
17434 tree origin
= decl_ultimate_origin (decl
);
17435 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
17437 if (origin
!= NULL
)
17438 add_abstract_origin_attribute (decl_die
, origin
);
17441 add_name_and_src_coords_attributes (decl_die
, decl
);
17442 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
17443 0, 0, context_die
);
17446 if (DECL_ABSTRACT (decl
))
17447 equate_decl_number_to_die (decl
, decl_die
);
17449 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
17453 /* Walk through the list of incomplete types again, trying once more to
17454 emit full debugging info for them. */
17457 retry_incomplete_types (void)
17461 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
17462 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
17463 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
17466 /* Determine what tag to use for a record type. */
17468 static enum dwarf_tag
17469 record_type_tag (tree type
)
17471 if (! lang_hooks
.types
.classify_record
)
17472 return DW_TAG_structure_type
;
17474 switch (lang_hooks
.types
.classify_record (type
))
17476 case RECORD_IS_STRUCT
:
17477 return DW_TAG_structure_type
;
17479 case RECORD_IS_CLASS
:
17480 return DW_TAG_class_type
;
17482 case RECORD_IS_INTERFACE
:
17483 if (dwarf_version
>= 3 || !dwarf_strict
)
17484 return DW_TAG_interface_type
;
17485 return DW_TAG_structure_type
;
17488 gcc_unreachable ();
17492 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17493 include all of the information about the enumeration values also. Each
17494 enumerated type name/value is listed as a child of the enumerated type
17498 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
17500 dw_die_ref type_die
= lookup_type_die (type
);
17502 if (type_die
== NULL
)
17504 type_die
= new_die (DW_TAG_enumeration_type
,
17505 scope_die_for (type
, context_die
), type
);
17506 equate_type_number_to_die (type
, type_die
);
17507 add_name_attribute (type_die
, type_tag (type
));
17508 if (dwarf_version
>= 4 || !dwarf_strict
)
17510 if (ENUM_IS_SCOPED (type
))
17511 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
17512 if (ENUM_IS_OPAQUE (type
))
17513 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17516 else if (! TYPE_SIZE (type
))
17519 remove_AT (type_die
, DW_AT_declaration
);
17521 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17522 given enum type is incomplete, do not generate the DW_AT_byte_size
17523 attribute or the DW_AT_element_list attribute. */
17524 if (TYPE_SIZE (type
))
17528 TREE_ASM_WRITTEN (type
) = 1;
17529 add_byte_size_attribute (type_die
, type
);
17530 if (dwarf_version
>= 3 || !dwarf_strict
)
17532 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
17533 add_type_attribute (type_die
, underlying
, 0, 0, context_die
);
17535 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
17537 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
17538 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
17541 /* If the first reference to this type was as the return type of an
17542 inline function, then it may not have a parent. Fix this now. */
17543 if (type_die
->die_parent
== NULL
)
17544 add_child_die (scope_die_for (type
, context_die
), type_die
);
17546 for (link
= TYPE_VALUES (type
);
17547 link
!= NULL
; link
= TREE_CHAIN (link
))
17549 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
17550 tree value
= TREE_VALUE (link
);
17552 add_name_attribute (enum_die
,
17553 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
17555 if (TREE_CODE (value
) == CONST_DECL
)
17556 value
= DECL_INITIAL (value
);
17558 if (simple_type_size_in_bits (TREE_TYPE (value
))
17559 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
17561 /* For constant forms created by add_AT_unsigned DWARF
17562 consumers (GDB, elfutils, etc.) always zero extend
17563 the value. Only when the actual value is negative
17564 do we need to use add_AT_int to generate a constant
17565 form that can represent negative values. */
17566 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
17567 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
17568 add_AT_unsigned (enum_die
, DW_AT_const_value
,
17569 (unsigned HOST_WIDE_INT
) val
);
17571 add_AT_int (enum_die
, DW_AT_const_value
, val
);
17574 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
17575 that here. TODO: This should be re-worked to use correct
17576 signed/unsigned double tags for all cases. */
17577 add_AT_wide (enum_die
, DW_AT_const_value
, value
);
17580 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
17581 if (TYPE_ARTIFICIAL (type
))
17582 add_AT_flag (type_die
, DW_AT_artificial
, 1);
17585 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17587 add_pubtype (type
, type_die
);
17592 /* Generate a DIE to represent either a real live formal parameter decl or to
17593 represent just the type of some formal parameter position in some function
17596 Note that this routine is a bit unusual because its argument may be a
17597 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17598 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17599 node. If it's the former then this function is being called to output a
17600 DIE to represent a formal parameter object (or some inlining thereof). If
17601 it's the latter, then this function is only being called to output a
17602 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17603 argument type of some subprogram type.
17604 If EMIT_NAME_P is true, name and source coordinate attributes
17608 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
17609 dw_die_ref context_die
)
17611 tree node_or_origin
= node
? node
: origin
;
17612 tree ultimate_origin
;
17613 dw_die_ref parm_die
17614 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
17616 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
17618 case tcc_declaration
:
17619 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
17620 if (node
|| ultimate_origin
)
17621 origin
= ultimate_origin
;
17622 if (origin
!= NULL
)
17623 add_abstract_origin_attribute (parm_die
, origin
);
17624 else if (emit_name_p
)
17625 add_name_and_src_coords_attributes (parm_die
, node
);
17627 || (! DECL_ABSTRACT (node_or_origin
)
17628 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
17629 decl_function_context
17630 (node_or_origin
))))
17632 tree type
= TREE_TYPE (node_or_origin
);
17633 if (decl_by_reference_p (node_or_origin
))
17634 add_type_attribute (parm_die
, TREE_TYPE (type
), 0, 0,
17637 add_type_attribute (parm_die
, type
,
17638 TREE_READONLY (node_or_origin
),
17639 TREE_THIS_VOLATILE (node_or_origin
),
17642 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
17643 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17645 if (node
&& node
!= origin
)
17646 equate_decl_number_to_die (node
, parm_die
);
17647 if (! DECL_ABSTRACT (node_or_origin
))
17648 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
17649 node
== NULL
, DW_AT_location
);
17654 /* We were called with some kind of a ..._TYPE node. */
17655 add_type_attribute (parm_die
, node_or_origin
, 0, 0, context_die
);
17659 gcc_unreachable ();
17665 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17666 children DW_TAG_formal_parameter DIEs representing the arguments of the
17669 PARM_PACK must be a function parameter pack.
17670 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17671 must point to the subsequent arguments of the function PACK_ARG belongs to.
17672 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17673 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17674 following the last one for which a DIE was generated. */
17677 gen_formal_parameter_pack_die (tree parm_pack
,
17679 dw_die_ref subr_die
,
17683 dw_die_ref parm_pack_die
;
17685 gcc_assert (parm_pack
17686 && lang_hooks
.function_parameter_pack_p (parm_pack
)
17689 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
17690 add_src_coords_attributes (parm_pack_die
, parm_pack
);
17692 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
17694 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
17697 gen_formal_parameter_die (arg
, NULL
,
17698 false /* Don't emit name attribute. */,
17703 return parm_pack_die
;
17706 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17707 at the end of an (ANSI prototyped) formal parameters list. */
17710 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
17712 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
17715 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17716 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17717 parameters as specified in some function type specification (except for
17718 those which appear as part of a function *definition*). */
17721 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
17724 tree formal_type
= NULL
;
17725 tree first_parm_type
;
17728 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
17730 arg
= DECL_ARGUMENTS (function_or_method_type
);
17731 function_or_method_type
= TREE_TYPE (function_or_method_type
);
17736 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
17738 /* Make our first pass over the list of formal parameter types and output a
17739 DW_TAG_formal_parameter DIE for each one. */
17740 for (link
= first_parm_type
; link
; )
17742 dw_die_ref parm_die
;
17744 formal_type
= TREE_VALUE (link
);
17745 if (formal_type
== void_type_node
)
17748 /* Output a (nameless) DIE to represent the formal parameter itself. */
17749 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
17750 true /* Emit name attribute. */,
17752 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
17753 && link
== first_parm_type
)
17755 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17756 if (dwarf_version
>= 3 || !dwarf_strict
)
17757 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
17759 else if (arg
&& DECL_ARTIFICIAL (arg
))
17760 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17762 link
= TREE_CHAIN (link
);
17764 arg
= DECL_CHAIN (arg
);
17767 /* If this function type has an ellipsis, add a
17768 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
17769 if (formal_type
!= void_type_node
)
17770 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
17772 /* Make our second (and final) pass over the list of formal parameter types
17773 and output DIEs to represent those types (as necessary). */
17774 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
17775 link
&& TREE_VALUE (link
);
17776 link
= TREE_CHAIN (link
))
17777 gen_type_die (TREE_VALUE (link
), context_die
);
17780 /* We want to generate the DIE for TYPE so that we can generate the
17781 die for MEMBER, which has been defined; we will need to refer back
17782 to the member declaration nested within TYPE. If we're trying to
17783 generate minimal debug info for TYPE, processing TYPE won't do the
17784 trick; we need to attach the member declaration by hand. */
17787 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
17789 gen_type_die (type
, context_die
);
17791 /* If we're trying to avoid duplicate debug info, we may not have
17792 emitted the member decl for this function. Emit it now. */
17793 if (TYPE_STUB_DECL (type
)
17794 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
17795 && ! lookup_decl_die (member
))
17797 dw_die_ref type_die
;
17798 gcc_assert (!decl_ultimate_origin (member
));
17800 push_decl_scope (type
);
17801 type_die
= lookup_type_die_strip_naming_typedef (type
);
17802 if (TREE_CODE (member
) == FUNCTION_DECL
)
17803 gen_subprogram_die (member
, type_die
);
17804 else if (TREE_CODE (member
) == FIELD_DECL
)
17806 /* Ignore the nameless fields that are used to skip bits but handle
17807 C++ anonymous unions and structs. */
17808 if (DECL_NAME (member
) != NULL_TREE
17809 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
17810 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
17812 gen_type_die (member_declared_type (member
), type_die
);
17813 gen_field_die (member
, type_die
);
17817 gen_variable_die (member
, NULL_TREE
, type_die
);
17823 /* Forward declare these functions, because they are mutually recursive
17824 with their set_block_* pairing functions. */
17825 static void set_decl_origin_self (tree
);
17826 static void set_decl_abstract_flags (tree
, int);
17828 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
17829 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
17830 that it points to the node itself, thus indicating that the node is its
17831 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
17832 the given node is NULL, recursively descend the decl/block tree which
17833 it is the root of, and for each other ..._DECL or BLOCK node contained
17834 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
17835 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
17836 values to point to themselves. */
17839 set_block_origin_self (tree stmt
)
17841 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
17843 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
17848 for (local_decl
= BLOCK_VARS (stmt
);
17849 local_decl
!= NULL_TREE
;
17850 local_decl
= DECL_CHAIN (local_decl
))
17851 if (! DECL_EXTERNAL (local_decl
))
17852 set_decl_origin_self (local_decl
); /* Potential recursion. */
17858 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17859 subblock
!= NULL_TREE
;
17860 subblock
= BLOCK_CHAIN (subblock
))
17861 set_block_origin_self (subblock
); /* Recurse. */
17866 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
17867 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
17868 node to so that it points to the node itself, thus indicating that the
17869 node represents its own (abstract) origin. Additionally, if the
17870 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
17871 the decl/block tree of which the given node is the root of, and for
17872 each other ..._DECL or BLOCK node contained therein whose
17873 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
17874 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
17875 point to themselves. */
17878 set_decl_origin_self (tree decl
)
17880 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
17882 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
17883 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17887 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17888 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
17889 if (DECL_INITIAL (decl
) != NULL_TREE
17890 && DECL_INITIAL (decl
) != error_mark_node
)
17891 set_block_origin_self (DECL_INITIAL (decl
));
17896 /* Given a pointer to some BLOCK node, and a boolean value to set the
17897 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
17898 the given block, and for all local decls and all local sub-blocks
17899 (recursively) which are contained therein. */
17902 set_block_abstract_flags (tree stmt
, int setting
)
17908 BLOCK_ABSTRACT (stmt
) = setting
;
17910 for (local_decl
= BLOCK_VARS (stmt
);
17911 local_decl
!= NULL_TREE
;
17912 local_decl
= DECL_CHAIN (local_decl
))
17913 if (! DECL_EXTERNAL (local_decl
))
17914 set_decl_abstract_flags (local_decl
, setting
);
17916 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
17918 local_decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
17919 if ((TREE_CODE (local_decl
) == VAR_DECL
&& !TREE_STATIC (local_decl
))
17920 || TREE_CODE (local_decl
) == PARM_DECL
)
17921 set_decl_abstract_flags (local_decl
, setting
);
17924 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17925 subblock
!= NULL_TREE
;
17926 subblock
= BLOCK_CHAIN (subblock
))
17927 set_block_abstract_flags (subblock
, setting
);
17930 /* Given a pointer to some ..._DECL node, and a boolean value to set the
17931 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
17932 given decl, and (in the case where the decl is a FUNCTION_DECL) also
17933 set the abstract flags for all of the parameters, local vars, local
17934 blocks and sub-blocks (recursively) to the same setting. */
17937 set_decl_abstract_flags (tree decl
, int setting
)
17939 DECL_ABSTRACT (decl
) = setting
;
17940 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17944 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17945 DECL_ABSTRACT (arg
) = setting
;
17946 if (DECL_INITIAL (decl
) != NULL_TREE
17947 && DECL_INITIAL (decl
) != error_mark_node
)
17948 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
17952 /* Generate the DWARF2 info for the "abstract" instance of a function which we
17953 may later generate inlined and/or out-of-line instances of. */
17956 dwarf2out_abstract_function (tree decl
)
17958 dw_die_ref old_die
;
17962 htab_t old_decl_loc_table
;
17963 htab_t old_cached_dw_loc_list_table
;
17964 int old_call_site_count
, old_tail_call_site_count
;
17965 struct call_arg_loc_node
*old_call_arg_locations
;
17967 /* Make sure we have the actual abstract inline, not a clone. */
17968 decl
= DECL_ORIGIN (decl
);
17970 old_die
= lookup_decl_die (decl
);
17971 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
17972 /* We've already generated the abstract instance. */
17975 /* We can be called while recursively when seeing block defining inlined subroutine
17976 DIE. Be sure to not clobber the outer location table nor use it or we would
17977 get locations in abstract instantces. */
17978 old_decl_loc_table
= decl_loc_table
;
17979 decl_loc_table
= NULL
;
17980 old_cached_dw_loc_list_table
= cached_dw_loc_list_table
;
17981 cached_dw_loc_list_table
= NULL
;
17982 old_call_arg_locations
= call_arg_locations
;
17983 call_arg_locations
= NULL
;
17984 old_call_site_count
= call_site_count
;
17985 call_site_count
= -1;
17986 old_tail_call_site_count
= tail_call_site_count
;
17987 tail_call_site_count
= -1;
17989 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
17990 we don't get confused by DECL_ABSTRACT. */
17991 if (debug_info_level
> DINFO_LEVEL_TERSE
)
17993 context
= decl_class_context (decl
);
17995 gen_type_die_for_member
17996 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die ());
17999 /* Pretend we've just finished compiling this function. */
18000 save_fn
= current_function_decl
;
18001 current_function_decl
= decl
;
18003 was_abstract
= DECL_ABSTRACT (decl
);
18004 set_decl_abstract_flags (decl
, 1);
18005 dwarf2out_decl (decl
);
18006 if (! was_abstract
)
18007 set_decl_abstract_flags (decl
, 0);
18009 current_function_decl
= save_fn
;
18010 decl_loc_table
= old_decl_loc_table
;
18011 cached_dw_loc_list_table
= old_cached_dw_loc_list_table
;
18012 call_arg_locations
= old_call_arg_locations
;
18013 call_site_count
= old_call_site_count
;
18014 tail_call_site_count
= old_tail_call_site_count
;
18017 /* Helper function of premark_used_types() which gets called through
18020 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18021 marked as unused by prune_unused_types. */
18024 premark_used_types_helper (void **slot
, void *data ATTRIBUTE_UNUSED
)
18029 type
= (tree
) *slot
;
18030 die
= lookup_type_die (type
);
18032 die
->die_perennial_p
= 1;
18036 /* Helper function of premark_types_used_by_global_vars which gets called
18037 through htab_traverse.
18039 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18040 marked as unused by prune_unused_types. The DIE of the type is marked
18041 only if the global variable using the type will actually be emitted. */
18044 premark_types_used_by_global_vars_helper (void **slot
,
18045 void *data ATTRIBUTE_UNUSED
)
18047 struct types_used_by_vars_entry
*entry
;
18050 entry
= (struct types_used_by_vars_entry
*) *slot
;
18051 gcc_assert (entry
->type
!= NULL
18052 && entry
->var_decl
!= NULL
);
18053 die
= lookup_type_die (entry
->type
);
18056 /* Ask cgraph if the global variable really is to be emitted.
18057 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18058 varpool_node
*node
= varpool_get_node (entry
->var_decl
);
18059 if (node
&& node
->definition
)
18061 die
->die_perennial_p
= 1;
18062 /* Keep the parent DIEs as well. */
18063 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
18064 die
->die_perennial_p
= 1;
18070 /* Mark all members of used_types_hash as perennial. */
18073 premark_used_types (struct function
*fun
)
18075 if (fun
&& fun
->used_types_hash
)
18076 htab_traverse (fun
->used_types_hash
, premark_used_types_helper
, NULL
);
18079 /* Mark all members of types_used_by_vars_entry as perennial. */
18082 premark_types_used_by_global_vars (void)
18084 if (types_used_by_vars_hash
)
18085 htab_traverse (types_used_by_vars_hash
,
18086 premark_types_used_by_global_vars_helper
, NULL
);
18089 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
18090 for CA_LOC call arg loc node. */
18093 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
18094 struct call_arg_loc_node
*ca_loc
)
18096 dw_die_ref stmt_die
= NULL
, die
;
18097 tree block
= ca_loc
->block
;
18100 && block
!= DECL_INITIAL (decl
)
18101 && TREE_CODE (block
) == BLOCK
)
18103 if (block_map
.length () > BLOCK_NUMBER (block
))
18104 stmt_die
= block_map
[BLOCK_NUMBER (block
)];
18107 block
= BLOCK_SUPERCONTEXT (block
);
18109 if (stmt_die
== NULL
)
18110 stmt_die
= subr_die
;
18111 die
= new_die (DW_TAG_GNU_call_site
, stmt_die
, NULL_TREE
);
18112 add_AT_lbl_id (die
, DW_AT_low_pc
, ca_loc
->label
);
18113 if (ca_loc
->tail_call_p
)
18114 add_AT_flag (die
, DW_AT_GNU_tail_call
, 1);
18115 if (ca_loc
->symbol_ref
)
18117 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
18119 add_AT_die_ref (die
, DW_AT_abstract_origin
, tdie
);
18121 add_AT_addr (die
, DW_AT_abstract_origin
, ca_loc
->symbol_ref
, false);
18126 /* Generate a DIE to represent a declared function (either file-scope or
18130 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
18132 tree origin
= decl_ultimate_origin (decl
);
18133 dw_die_ref subr_die
;
18135 dw_die_ref old_die
= lookup_decl_die (decl
);
18136 int declaration
= (current_function_decl
!= decl
18137 || class_or_namespace_scope_p (context_die
));
18139 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
18141 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
18142 started to generate the abstract instance of an inline, decided to output
18143 its containing class, and proceeded to emit the declaration of the inline
18144 from the member list for the class. If so, DECLARATION takes priority;
18145 we'll get back to the abstract instance when done with the class. */
18147 /* The class-scope declaration DIE must be the primary DIE. */
18148 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
18151 gcc_assert (!old_die
);
18154 /* Now that the C++ front end lazily declares artificial member fns, we
18155 might need to retrofit the declaration into its class. */
18156 if (!declaration
&& !origin
&& !old_die
18157 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
18158 && !class_or_namespace_scope_p (context_die
)
18159 && debug_info_level
> DINFO_LEVEL_TERSE
)
18160 old_die
= force_decl_die (decl
);
18162 if (origin
!= NULL
)
18164 gcc_assert (!declaration
|| local_scope_p (context_die
));
18166 /* Fixup die_parent for the abstract instance of a nested
18167 inline function. */
18168 if (old_die
&& old_die
->die_parent
== NULL
)
18169 add_child_die (context_die
, old_die
);
18171 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18172 add_abstract_origin_attribute (subr_die
, origin
);
18173 /* This is where the actual code for a cloned function is.
18174 Let's emit linkage name attribute for it. This helps
18175 debuggers to e.g, set breakpoints into
18176 constructors/destructors when the user asks "break
18178 add_linkage_name (subr_die
, decl
);
18182 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18183 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18185 if (!get_AT_flag (old_die
, DW_AT_declaration
)
18186 /* We can have a normal definition following an inline one in the
18187 case of redefinition of GNU C extern inlines.
18188 It seems reasonable to use AT_specification in this case. */
18189 && !get_AT (old_die
, DW_AT_inline
))
18191 /* Detect and ignore this case, where we are trying to output
18192 something we have already output. */
18196 /* If the definition comes from the same place as the declaration,
18197 maybe use the old DIE. We always want the DIE for this function
18198 that has the *_pc attributes to be under comp_unit_die so the
18199 debugger can find it. We also need to do this for abstract
18200 instances of inlines, since the spec requires the out-of-line copy
18201 to have the same parent. For local class methods, this doesn't
18202 apply; we just use the old DIE. */
18203 if ((is_cu_die (old_die
->die_parent
) || context_die
== NULL
)
18204 && (DECL_ARTIFICIAL (decl
)
18205 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
18206 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
18207 == (unsigned) s
.line
))))
18209 subr_die
= old_die
;
18211 /* Clear out the declaration attribute and the formal parameters.
18212 Do not remove all children, because it is possible that this
18213 declaration die was forced using force_decl_die(). In such
18214 cases die that forced declaration die (e.g. TAG_imported_module)
18215 is one of the children that we do not want to remove. */
18216 remove_AT (subr_die
, DW_AT_declaration
);
18217 remove_AT (subr_die
, DW_AT_object_pointer
);
18218 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
18222 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18223 add_AT_specification (subr_die
, old_die
);
18224 add_pubname (decl
, subr_die
);
18225 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18226 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
18227 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18228 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
18230 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
18231 emit the real type on the definition die. */
18232 if (is_cxx() && debug_info_level
> DINFO_LEVEL_TERSE
)
18234 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
18235 if (die
== auto_die
|| die
== decltype_auto_die
)
18236 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18237 0, 0, context_die
);
18243 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18245 if (TREE_PUBLIC (decl
))
18246 add_AT_flag (subr_die
, DW_AT_external
, 1);
18248 add_name_and_src_coords_attributes (subr_die
, decl
);
18249 add_pubname (decl
, subr_die
);
18250 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18252 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
18253 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18254 0, 0, context_die
);
18257 add_pure_or_virtual_attribute (subr_die
, decl
);
18258 if (DECL_ARTIFICIAL (decl
))
18259 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18261 add_accessibility_attribute (subr_die
, decl
);
18266 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18268 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
18270 /* If this is an explicit function declaration then generate
18271 a DW_AT_explicit attribute. */
18272 if (lang_hooks
.decls
.function_decl_explicit_p (decl
)
18273 && (dwarf_version
>= 3 || !dwarf_strict
))
18274 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
18276 /* The first time we see a member function, it is in the context of
18277 the class to which it belongs. We make sure of this by emitting
18278 the class first. The next time is the definition, which is
18279 handled above. The two may come from the same source text.
18281 Note that force_decl_die() forces function declaration die. It is
18282 later reused to represent definition. */
18283 equate_decl_number_to_die (decl
, subr_die
);
18286 else if (DECL_ABSTRACT (decl
))
18288 if (DECL_DECLARED_INLINE_P (decl
))
18290 if (cgraph_function_possibly_inlined_p (decl
))
18291 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
18293 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
18297 if (cgraph_function_possibly_inlined_p (decl
))
18298 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
18300 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
18303 if (DECL_DECLARED_INLINE_P (decl
)
18304 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
18305 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18307 equate_decl_number_to_die (decl
, subr_die
);
18309 else if (!DECL_EXTERNAL (decl
))
18311 HOST_WIDE_INT cfa_fb_offset
;
18312 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
18314 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18315 equate_decl_number_to_die (decl
, subr_die
);
18317 gcc_checking_assert (fun
);
18318 if (!flag_reorder_blocks_and_partition
)
18320 dw_fde_ref fde
= fun
->fde
;
18321 if (fde
->dw_fde_begin
)
18323 /* We have already generated the labels. */
18324 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18325 fde
->dw_fde_end
, false);
18329 /* Create start/end labels and add the range. */
18330 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
18331 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
18332 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
18333 current_function_funcdef_no
);
18334 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
18335 current_function_funcdef_no
);
18336 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
18340 #if VMS_DEBUGGING_INFO
18341 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18342 Section 2.3 Prologue and Epilogue Attributes:
18343 When a breakpoint is set on entry to a function, it is generally
18344 desirable for execution to be suspended, not on the very first
18345 instruction of the function, but rather at a point after the
18346 function's frame has been set up, after any language defined local
18347 declaration processing has been completed, and before execution of
18348 the first statement of the function begins. Debuggers generally
18349 cannot properly determine where this point is. Similarly for a
18350 breakpoint set on exit from a function. The prologue and epilogue
18351 attributes allow a compiler to communicate the location(s) to use. */
18354 if (fde
->dw_fde_vms_end_prologue
)
18355 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
18356 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
18358 if (fde
->dw_fde_vms_begin_epilogue
)
18359 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
18360 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
18367 /* Generate pubnames entries for the split function code ranges. */
18368 dw_fde_ref fde
= fun
->fde
;
18370 if (fde
->dw_fde_second_begin
)
18372 if (dwarf_version
>= 3 || !dwarf_strict
)
18374 /* We should use ranges for non-contiguous code section
18375 addresses. Use the actual code range for the initial
18376 section, since the HOT/COLD labels might precede an
18377 alignment offset. */
18378 bool range_list_added
= false;
18379 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
18380 fde
->dw_fde_end
, &range_list_added
,
18382 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
18383 fde
->dw_fde_second_end
,
18384 &range_list_added
, false);
18385 if (range_list_added
)
18390 /* There is no real support in DW2 for this .. so we make
18391 a work-around. First, emit the pub name for the segment
18392 containing the function label. Then make and emit a
18393 simplified subprogram DIE for the second segment with the
18394 name pre-fixed by __hot/cold_sect_of_. We use the same
18395 linkage name for the second die so that gdb will find both
18396 sections when given "b foo". */
18397 const char *name
= NULL
;
18398 tree decl_name
= DECL_NAME (decl
);
18399 dw_die_ref seg_die
;
18401 /* Do the 'primary' section. */
18402 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18403 fde
->dw_fde_end
, false);
18405 /* Build a minimal DIE for the secondary section. */
18406 seg_die
= new_die (DW_TAG_subprogram
,
18407 subr_die
->die_parent
, decl
);
18409 if (TREE_PUBLIC (decl
))
18410 add_AT_flag (seg_die
, DW_AT_external
, 1);
18412 if (decl_name
!= NULL
18413 && IDENTIFIER_POINTER (decl_name
) != NULL
)
18415 name
= dwarf2_name (decl
, 1);
18416 if (! DECL_ARTIFICIAL (decl
))
18417 add_src_coords_attributes (seg_die
, decl
);
18419 add_linkage_name (seg_die
, decl
);
18421 gcc_assert (name
!= NULL
);
18422 add_pure_or_virtual_attribute (seg_die
, decl
);
18423 if (DECL_ARTIFICIAL (decl
))
18424 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
18426 name
= concat ("__second_sect_of_", name
, NULL
);
18427 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
18428 fde
->dw_fde_second_end
, false);
18429 add_name_attribute (seg_die
, name
);
18430 if (want_pubnames ())
18431 add_pubname_string (name
, seg_die
);
18435 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
18439 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
18441 /* We define the "frame base" as the function's CFA. This is more
18442 convenient for several reasons: (1) It's stable across the prologue
18443 and epilogue, which makes it better than just a frame pointer,
18444 (2) With dwarf3, there exists a one-byte encoding that allows us
18445 to reference the .debug_frame data by proxy, but failing that,
18446 (3) We can at least reuse the code inspection and interpretation
18447 code that determines the CFA position at various points in the
18449 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
18451 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
18452 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
18456 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
18457 if (list
->dw_loc_next
)
18458 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
18460 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
18463 /* Compute a displacement from the "steady-state frame pointer" to
18464 the CFA. The former is what all stack slots and argument slots
18465 will reference in the rtl; the latter is what we've told the
18466 debugger about. We'll need to adjust all frame_base references
18467 by this displacement. */
18468 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
18470 if (fun
->static_chain_decl
)
18471 add_AT_location_description (subr_die
, DW_AT_static_link
,
18472 loc_list_from_tree (fun
->static_chain_decl
, 2));
18475 /* Generate child dies for template paramaters. */
18476 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18477 gen_generic_params_dies (decl
);
18479 /* Now output descriptions of the arguments for this function. This gets
18480 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18481 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18482 `...' at the end of the formal parameter list. In order to find out if
18483 there was a trailing ellipsis or not, we must instead look at the type
18484 associated with the FUNCTION_DECL. This will be a node of type
18485 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18486 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18487 an ellipsis at the end. */
18489 /* In the case where we are describing a mere function declaration, all we
18490 need to do here (and all we *can* do here) is to describe the *types* of
18491 its formal parameters. */
18492 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
18494 else if (declaration
)
18495 gen_formal_types_die (decl
, subr_die
);
18498 /* Generate DIEs to represent all known formal parameters. */
18499 tree parm
= DECL_ARGUMENTS (decl
);
18500 tree generic_decl
= lang_hooks
.decls
.get_generic_function_decl (decl
);
18501 tree generic_decl_parm
= generic_decl
18502 ? DECL_ARGUMENTS (generic_decl
)
18505 /* Now we want to walk the list of parameters of the function and
18506 emit their relevant DIEs.
18508 We consider the case of DECL being an instance of a generic function
18509 as well as it being a normal function.
18511 If DECL is an instance of a generic function we walk the
18512 parameters of the generic function declaration _and_ the parameters of
18513 DECL itself. This is useful because we want to emit specific DIEs for
18514 function parameter packs and those are declared as part of the
18515 generic function declaration. In that particular case,
18516 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18517 That DIE has children DIEs representing the set of arguments
18518 of the pack. Note that the set of pack arguments can be empty.
18519 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18522 Otherwise, we just consider the parameters of DECL. */
18523 while (generic_decl_parm
|| parm
)
18525 if (generic_decl_parm
18526 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
18527 gen_formal_parameter_pack_die (generic_decl_parm
,
18532 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, subr_die
);
18534 if (parm
== DECL_ARGUMENTS (decl
)
18535 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
18537 && (dwarf_version
>= 3 || !dwarf_strict
))
18538 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
18540 parm
= DECL_CHAIN (parm
);
18543 if (generic_decl_parm
)
18544 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
18547 /* Decide whether we need an unspecified_parameters DIE at the end.
18548 There are 2 more cases to do this for: 1) the ansi ... declaration -
18549 this is detectable when the end of the arg list is not a
18550 void_type_node 2) an unprototyped function declaration (not a
18551 definition). This just means that we have no info about the
18552 parameters at all. */
18553 if (prototype_p (TREE_TYPE (decl
)))
18555 /* This is the prototyped case, check for.... */
18556 if (stdarg_p (TREE_TYPE (decl
)))
18557 gen_unspecified_parameters_die (decl
, subr_die
);
18559 else if (DECL_INITIAL (decl
) == NULL_TREE
)
18560 gen_unspecified_parameters_die (decl
, subr_die
);
18563 /* Output Dwarf info for all of the stuff within the body of the function
18564 (if it has one - it may be just a declaration). */
18565 outer_scope
= DECL_INITIAL (decl
);
18567 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18568 a function. This BLOCK actually represents the outermost binding contour
18569 for the function, i.e. the contour in which the function's formal
18570 parameters and labels get declared. Curiously, it appears that the front
18571 end doesn't actually put the PARM_DECL nodes for the current function onto
18572 the BLOCK_VARS list for this outer scope, but are strung off of the
18573 DECL_ARGUMENTS list for the function instead.
18575 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18576 the LABEL_DECL nodes for the function however, and we output DWARF info
18577 for those in decls_for_scope. Just within the `outer_scope' there will be
18578 a BLOCK node representing the function's outermost pair of curly braces,
18579 and any blocks used for the base and member initializers of a C++
18580 constructor function. */
18581 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
18583 int call_site_note_count
= 0;
18584 int tail_call_site_note_count
= 0;
18586 /* Emit a DW_TAG_variable DIE for a named return value. */
18587 if (DECL_NAME (DECL_RESULT (decl
)))
18588 gen_decl_die (DECL_RESULT (decl
), NULL
, subr_die
);
18590 current_function_has_inlines
= 0;
18591 decls_for_scope (outer_scope
, subr_die
, 0);
18593 if (call_arg_locations
&& !dwarf_strict
)
18595 struct call_arg_loc_node
*ca_loc
;
18596 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
18598 dw_die_ref die
= NULL
;
18599 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
18602 for (arg
= NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
);
18603 arg
; arg
= next_arg
)
18605 dw_loc_descr_ref reg
, val
;
18606 enum machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
18607 dw_die_ref cdie
, tdie
= NULL
;
18609 next_arg
= XEXP (arg
, 1);
18610 if (REG_P (XEXP (XEXP (arg
, 0), 0))
18612 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
18613 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
18614 && REGNO (XEXP (XEXP (arg
, 0), 0))
18615 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
18616 next_arg
= XEXP (next_arg
, 1);
18617 if (mode
== VOIDmode
)
18619 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
18620 if (mode
== VOIDmode
)
18621 mode
= GET_MODE (XEXP (arg
, 0));
18623 if (mode
== VOIDmode
|| mode
== BLKmode
)
18625 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
18627 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18628 tloc
= XEXP (XEXP (arg
, 0), 1);
18631 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
18632 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
18634 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18635 tlocc
= XEXP (XEXP (arg
, 0), 1);
18639 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
18640 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
18641 VAR_INIT_STATUS_INITIALIZED
);
18642 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
18644 rtx mem
= XEXP (XEXP (arg
, 0), 0);
18645 reg
= mem_loc_descriptor (XEXP (mem
, 0),
18646 get_address_mode (mem
),
18648 VAR_INIT_STATUS_INITIALIZED
);
18650 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
18651 == DEBUG_PARAMETER_REF
)
18654 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
18655 tdie
= lookup_decl_die (tdecl
);
18662 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
18663 != DEBUG_PARAMETER_REF
)
18665 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
18667 VAR_INIT_STATUS_INITIALIZED
);
18671 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18672 cdie
= new_die (DW_TAG_GNU_call_site_parameter
, die
,
18675 add_AT_loc (cdie
, DW_AT_location
, reg
);
18676 else if (tdie
!= NULL
)
18677 add_AT_die_ref (cdie
, DW_AT_abstract_origin
, tdie
);
18678 add_AT_loc (cdie
, DW_AT_GNU_call_site_value
, val
);
18679 if (next_arg
!= XEXP (arg
, 1))
18681 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
18682 if (mode
== VOIDmode
)
18683 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
18684 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
18687 VAR_INIT_STATUS_INITIALIZED
);
18689 add_AT_loc (cdie
, DW_AT_GNU_call_site_data_value
, val
);
18693 && (ca_loc
->symbol_ref
|| tloc
))
18694 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18695 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
18697 dw_loc_descr_ref tval
= NULL
;
18699 if (tloc
!= NULL_RTX
)
18700 tval
= mem_loc_descriptor (tloc
,
18701 GET_MODE (tloc
) == VOIDmode
18702 ? Pmode
: GET_MODE (tloc
),
18704 VAR_INIT_STATUS_INITIALIZED
);
18706 add_AT_loc (die
, DW_AT_GNU_call_site_target
, tval
);
18707 else if (tlocc
!= NULL_RTX
)
18709 tval
= mem_loc_descriptor (tlocc
,
18710 GET_MODE (tlocc
) == VOIDmode
18711 ? Pmode
: GET_MODE (tlocc
),
18713 VAR_INIT_STATUS_INITIALIZED
);
18715 add_AT_loc (die
, DW_AT_GNU_call_site_target_clobbered
,
18721 call_site_note_count
++;
18722 if (ca_loc
->tail_call_p
)
18723 tail_call_site_note_count
++;
18727 call_arg_locations
= NULL
;
18728 call_arg_loc_last
= NULL
;
18729 if (tail_call_site_count
>= 0
18730 && tail_call_site_count
== tail_call_site_note_count
18733 if (call_site_count
>= 0
18734 && call_site_count
== call_site_note_count
)
18735 add_AT_flag (subr_die
, DW_AT_GNU_all_call_sites
, 1);
18737 add_AT_flag (subr_die
, DW_AT_GNU_all_tail_call_sites
, 1);
18739 call_site_count
= -1;
18740 tail_call_site_count
= -1;
18743 if (subr_die
!= old_die
)
18744 /* Add the calling convention attribute if requested. */
18745 add_calling_convention_attribute (subr_die
, decl
);
18748 /* Returns a hash value for X (which really is a die_struct). */
18751 common_block_die_table_hash (const void *x
)
18753 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18754 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
18757 /* Return nonzero if decl_id and die_parent of die_struct X is the same
18758 as decl_id and die_parent of die_struct Y. */
18761 common_block_die_table_eq (const void *x
, const void *y
)
18763 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18764 const_dw_die_ref e
= (const_dw_die_ref
) y
;
18765 return d
->decl_id
== e
->decl_id
&& d
->die_parent
== e
->die_parent
;
18768 /* Generate a DIE to represent a declared data object.
18769 Either DECL or ORIGIN must be non-null. */
18772 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
18774 HOST_WIDE_INT off
= 0;
18776 tree decl_or_origin
= decl
? decl
: origin
;
18777 tree ultimate_origin
;
18778 dw_die_ref var_die
;
18779 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
18780 dw_die_ref origin_die
;
18781 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
18782 || class_or_namespace_scope_p (context_die
));
18783 bool specialization_p
= false;
18785 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
18786 if (decl
|| ultimate_origin
)
18787 origin
= ultimate_origin
;
18788 com_decl
= fortran_common (decl_or_origin
, &off
);
18790 /* Symbol in common gets emitted as a child of the common block, in the form
18791 of a data member. */
18794 dw_die_ref com_die
;
18795 dw_loc_list_ref loc
;
18796 die_node com_die_arg
;
18798 var_die
= lookup_decl_die (decl_or_origin
);
18801 if (get_AT (var_die
, DW_AT_location
) == NULL
)
18803 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2);
18808 /* Optimize the common case. */
18809 if (single_element_loc_list_p (loc
)
18810 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18811 && loc
->expr
->dw_loc_next
== NULL
18812 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
18815 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18816 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18817 = plus_constant (GET_MODE (x
), x
, off
);
18820 loc_list_plus_const (loc
, off
);
18822 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18823 remove_AT (var_die
, DW_AT_declaration
);
18829 if (common_block_die_table
== NULL
)
18830 common_block_die_table
18831 = htab_create_ggc (10, common_block_die_table_hash
,
18832 common_block_die_table_eq
, NULL
);
18834 com_die_arg
.decl_id
= DECL_UID (com_decl
);
18835 com_die_arg
.die_parent
= context_die
;
18836 com_die
= (dw_die_ref
) htab_find (common_block_die_table
, &com_die_arg
);
18837 loc
= loc_list_from_tree (com_decl
, 2);
18838 if (com_die
== NULL
)
18841 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
18844 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
18845 add_name_and_src_coords_attributes (com_die
, com_decl
);
18848 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18849 /* Avoid sharing the same loc descriptor between
18850 DW_TAG_common_block and DW_TAG_variable. */
18851 loc
= loc_list_from_tree (com_decl
, 2);
18853 else if (DECL_EXTERNAL (decl
))
18854 add_AT_flag (com_die
, DW_AT_declaration
, 1);
18855 if (want_pubnames ())
18856 add_pubname_string (cnam
, com_die
); /* ??? needed? */
18857 com_die
->decl_id
= DECL_UID (com_decl
);
18858 slot
= htab_find_slot (common_block_die_table
, com_die
, INSERT
);
18859 *slot
= (void *) com_die
;
18861 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
18863 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18864 loc
= loc_list_from_tree (com_decl
, 2);
18865 remove_AT (com_die
, DW_AT_declaration
);
18867 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
18868 add_name_and_src_coords_attributes (var_die
, decl
);
18869 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
18870 TREE_THIS_VOLATILE (decl
), context_die
);
18871 add_AT_flag (var_die
, DW_AT_external
, 1);
18876 /* Optimize the common case. */
18877 if (single_element_loc_list_p (loc
)
18878 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18879 && loc
->expr
->dw_loc_next
== NULL
18880 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
18882 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18883 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18884 = plus_constant (GET_MODE (x
), x
, off
);
18887 loc_list_plus_const (loc
, off
);
18889 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18891 else if (DECL_EXTERNAL (decl
))
18892 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18893 equate_decl_number_to_die (decl
, var_die
);
18897 /* If the compiler emitted a definition for the DECL declaration
18898 and if we already emitted a DIE for it, don't emit a second
18899 DIE for it again. Allow re-declarations of DECLs that are
18900 inside functions, though. */
18901 if (old_die
&& declaration
&& !local_scope_p (context_die
))
18904 /* For static data members, the declaration in the class is supposed
18905 to have DW_TAG_member tag; the specification should still be
18906 DW_TAG_variable referencing the DW_TAG_member DIE. */
18907 if (declaration
&& class_scope_p (context_die
))
18908 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
18910 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
18913 if (origin
!= NULL
)
18914 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
18916 /* Loop unrolling can create multiple blocks that refer to the same
18917 static variable, so we must test for the DW_AT_declaration flag.
18919 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
18920 copy decls and set the DECL_ABSTRACT flag on them instead of
18923 ??? Duplicated blocks have been rewritten to use .debug_ranges.
18925 ??? The declare_in_namespace support causes us to get two DIEs for one
18926 variable, both of which are declarations. We want to avoid considering
18927 one to be a specification, so we must test that this DIE is not a
18929 else if (old_die
&& TREE_STATIC (decl
) && ! declaration
18930 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
18932 /* This is a definition of a C++ class level static. */
18933 add_AT_specification (var_die
, old_die
);
18934 specialization_p
= true;
18935 if (DECL_NAME (decl
))
18937 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18938 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18940 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18941 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
18943 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18944 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
18946 if (old_die
->die_tag
== DW_TAG_member
)
18947 add_linkage_name (var_die
, decl
);
18951 add_name_and_src_coords_attributes (var_die
, decl
);
18953 if ((origin
== NULL
&& !specialization_p
)
18955 && !DECL_ABSTRACT (decl_or_origin
)
18956 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
18957 decl_function_context
18958 (decl_or_origin
))))
18960 tree type
= TREE_TYPE (decl_or_origin
);
18962 if (decl_by_reference_p (decl_or_origin
))
18963 add_type_attribute (var_die
, TREE_TYPE (type
), 0, 0, context_die
);
18965 add_type_attribute (var_die
, type
, TREE_READONLY (decl_or_origin
),
18966 TREE_THIS_VOLATILE (decl_or_origin
), context_die
);
18969 if (origin
== NULL
&& !specialization_p
)
18971 if (TREE_PUBLIC (decl
))
18972 add_AT_flag (var_die
, DW_AT_external
, 1);
18974 if (DECL_ARTIFICIAL (decl
))
18975 add_AT_flag (var_die
, DW_AT_artificial
, 1);
18977 add_accessibility_attribute (var_die
, decl
);
18981 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18983 if (decl
&& (DECL_ABSTRACT (decl
) || declaration
|| old_die
== NULL
))
18984 equate_decl_number_to_die (decl
, var_die
);
18987 && (! DECL_ABSTRACT (decl_or_origin
)
18988 /* Local static vars are shared between all clones/inlines,
18989 so emit DW_AT_location on the abstract DIE if DECL_RTL is
18991 || (TREE_CODE (decl_or_origin
) == VAR_DECL
18992 && TREE_STATIC (decl_or_origin
)
18993 && DECL_RTL_SET_P (decl_or_origin
)))
18994 /* When abstract origin already has DW_AT_location attribute, no need
18995 to add it again. */
18996 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
18998 if (TREE_CODE (decl_or_origin
) == VAR_DECL
&& TREE_STATIC (decl_or_origin
)
18999 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin
)))
19000 defer_location (decl_or_origin
, var_die
);
19002 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
19003 decl
== NULL
, DW_AT_location
);
19004 add_pubname (decl_or_origin
, var_die
);
19007 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
19010 /* Generate a DIE to represent a named constant. */
19013 gen_const_die (tree decl
, dw_die_ref context_die
)
19015 dw_die_ref const_die
;
19016 tree type
= TREE_TYPE (decl
);
19018 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
19019 add_name_and_src_coords_attributes (const_die
, decl
);
19020 add_type_attribute (const_die
, type
, 1, 0, context_die
);
19021 if (TREE_PUBLIC (decl
))
19022 add_AT_flag (const_die
, DW_AT_external
, 1);
19023 if (DECL_ARTIFICIAL (decl
))
19024 add_AT_flag (const_die
, DW_AT_artificial
, 1);
19025 tree_add_const_value_attribute_for_decl (const_die
, decl
);
19028 /* Generate a DIE to represent a label identifier. */
19031 gen_label_die (tree decl
, dw_die_ref context_die
)
19033 tree origin
= decl_ultimate_origin (decl
);
19034 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
19036 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
19038 if (origin
!= NULL
)
19039 add_abstract_origin_attribute (lbl_die
, origin
);
19041 add_name_and_src_coords_attributes (lbl_die
, decl
);
19043 if (DECL_ABSTRACT (decl
))
19044 equate_decl_number_to_die (decl
, lbl_die
);
19047 insn
= DECL_RTL_IF_SET (decl
);
19049 /* Deleted labels are programmer specified labels which have been
19050 eliminated because of various optimizations. We still emit them
19051 here so that it is possible to put breakpoints on them. */
19055 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
19057 /* When optimization is enabled (via -O) some parts of the compiler
19058 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19059 represent source-level labels which were explicitly declared by
19060 the user. This really shouldn't be happening though, so catch
19061 it if it ever does happen. */
19062 gcc_assert (!INSN_DELETED_P (insn
));
19064 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
19065 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
19069 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
19070 && CODE_LABEL_NUMBER (insn
) != -1)
19072 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
19073 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
19078 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19079 attributes to the DIE for a block STMT, to describe where the inlined
19080 function was called from. This is similar to add_src_coords_attributes. */
19083 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
19085 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
19087 if (dwarf_version
>= 3 || !dwarf_strict
)
19089 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
19090 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
19095 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19096 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19099 add_high_low_attributes (tree stmt
, dw_die_ref die
)
19101 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
19103 if (BLOCK_FRAGMENT_CHAIN (stmt
)
19104 && (dwarf_version
>= 3 || !dwarf_strict
))
19106 tree chain
, superblock
= NULL_TREE
;
19108 dw_attr_ref attr
= NULL
;
19110 if (inlined_function_outer_scope_p (stmt
))
19112 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19113 BLOCK_NUMBER (stmt
));
19114 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
19117 /* Optimize duplicate .debug_ranges lists or even tails of
19118 lists. If this BLOCK has same ranges as its supercontext,
19119 lookup DW_AT_ranges attribute in the supercontext (and
19120 recursively so), verify that the ranges_table contains the
19121 right values and use it instead of adding a new .debug_range. */
19122 for (chain
= stmt
, pdie
= die
;
19123 BLOCK_SAME_RANGE (chain
);
19124 chain
= BLOCK_SUPERCONTEXT (chain
))
19126 dw_attr_ref new_attr
;
19128 pdie
= pdie
->die_parent
;
19131 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
19133 new_attr
= get_AT (pdie
, DW_AT_ranges
);
19134 if (new_attr
== NULL
19135 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
19138 superblock
= BLOCK_SUPERCONTEXT (chain
);
19141 && (ranges_table
[attr
->dw_attr_val
.v
.val_offset
19142 / 2 / DWARF2_ADDR_SIZE
].num
19143 == BLOCK_NUMBER (superblock
))
19144 && BLOCK_FRAGMENT_CHAIN (superblock
))
19146 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
19147 / 2 / DWARF2_ADDR_SIZE
;
19148 unsigned long supercnt
= 0, thiscnt
= 0;
19149 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
19150 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
19153 gcc_checking_assert (ranges_table
[off
+ supercnt
].num
19154 == BLOCK_NUMBER (chain
));
19156 gcc_checking_assert (ranges_table
[off
+ supercnt
+ 1].num
== 0);
19157 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19158 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
19160 gcc_assert (supercnt
>= thiscnt
);
19161 add_AT_range_list (die
, DW_AT_ranges
,
19162 ((off
+ supercnt
- thiscnt
)
19163 * 2 * DWARF2_ADDR_SIZE
),
19168 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
), false);
19170 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19173 add_ranges (chain
);
19174 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
19181 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
19182 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19183 BLOCK_NUMBER (stmt
));
19184 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
19185 BLOCK_NUMBER (stmt
));
19186 add_AT_low_high_pc (die
, label
, label_high
, false);
19190 /* Generate a DIE for a lexical block. */
19193 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19195 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
19197 if (call_arg_locations
)
19199 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19200 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19201 block_map
[BLOCK_NUMBER (stmt
)] = stmt_die
;
19204 if (! BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
19205 add_high_low_attributes (stmt
, stmt_die
);
19207 decls_for_scope (stmt
, stmt_die
, depth
);
19210 /* Generate a DIE for an inlined subprogram. */
19213 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
19217 /* The instance of function that is effectively being inlined shall not
19219 gcc_assert (! BLOCK_ABSTRACT (stmt
));
19221 decl
= block_ultimate_origin (stmt
);
19223 /* Emit info for the abstract instance first, if we haven't yet. We
19224 must emit this even if the block is abstract, otherwise when we
19225 emit the block below (or elsewhere), we may end up trying to emit
19226 a die whose origin die hasn't been emitted, and crashing. */
19227 dwarf2out_abstract_function (decl
);
19229 if (! BLOCK_ABSTRACT (stmt
))
19231 dw_die_ref subr_die
19232 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
19234 if (call_arg_locations
)
19236 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19237 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19238 block_map
[BLOCK_NUMBER (stmt
)] = subr_die
;
19240 add_abstract_origin_attribute (subr_die
, decl
);
19241 if (TREE_ASM_WRITTEN (stmt
))
19242 add_high_low_attributes (stmt
, subr_die
);
19243 add_call_src_coords_attributes (stmt
, subr_die
);
19245 decls_for_scope (stmt
, subr_die
, depth
);
19246 current_function_has_inlines
= 1;
19250 /* Generate a DIE for a field in a record, or structure. */
19253 gen_field_die (tree decl
, dw_die_ref context_die
)
19255 dw_die_ref decl_die
;
19257 if (TREE_TYPE (decl
) == error_mark_node
)
19260 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
19261 add_name_and_src_coords_attributes (decl_die
, decl
);
19262 add_type_attribute (decl_die
, member_declared_type (decl
),
19263 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
19266 if (DECL_BIT_FIELD_TYPE (decl
))
19268 add_byte_size_attribute (decl_die
, decl
);
19269 add_bit_size_attribute (decl_die
, decl
);
19270 add_bit_offset_attribute (decl_die
, decl
);
19273 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
19274 add_data_member_location_attribute (decl_die
, decl
);
19276 if (DECL_ARTIFICIAL (decl
))
19277 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
19279 add_accessibility_attribute (decl_die
, decl
);
19281 /* Equate decl number to die, so that we can look up this decl later on. */
19282 equate_decl_number_to_die (decl
, decl_die
);
19286 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19287 Use modified_type_die instead.
19288 We keep this code here just in case these types of DIEs may be needed to
19289 represent certain things in other languages (e.g. Pascal) someday. */
19292 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
19295 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
19297 equate_type_number_to_die (type
, ptr_die
);
19298 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19299 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19302 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19303 Use modified_type_die instead.
19304 We keep this code here just in case these types of DIEs may be needed to
19305 represent certain things in other languages (e.g. Pascal) someday. */
19308 gen_reference_type_die (tree type
, dw_die_ref context_die
)
19310 dw_die_ref ref_die
, scope_die
= scope_die_for (type
, context_die
);
19312 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
19313 ref_die
= new_die (DW_TAG_rvalue_reference_type
, scope_die
, type
);
19315 ref_die
= new_die (DW_TAG_reference_type
, scope_die
, type
);
19317 equate_type_number_to_die (type
, ref_die
);
19318 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
19319 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19323 /* Generate a DIE for a pointer to a member type. */
19326 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
19329 = new_die (DW_TAG_ptr_to_member_type
,
19330 scope_die_for (type
, context_die
), type
);
19332 equate_type_number_to_die (type
, ptr_die
);
19333 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
19334 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
19335 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19338 typedef const char *dchar_p
; /* For DEF_VEC_P. */
19340 static char *producer_string
;
19342 /* Return a heap allocated producer string including command line options
19343 if -grecord-gcc-switches. */
19346 gen_producer_string (void)
19349 auto_vec
<dchar_p
> switches
;
19350 const char *language_string
= lang_hooks
.name
;
19351 char *producer
, *tail
;
19353 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
19354 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
19356 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
19357 switch (save_decoded_options
[j
].opt_index
)
19364 case OPT_auxbase_strip
:
19373 case OPT_SPECIAL_unknown
:
19374 case OPT_SPECIAL_ignore
:
19375 case OPT_SPECIAL_program_name
:
19376 case OPT_SPECIAL_input_file
:
19377 case OPT_grecord_gcc_switches
:
19378 case OPT_gno_record_gcc_switches
:
19379 case OPT__output_pch_
:
19380 case OPT_fdiagnostics_show_location_
:
19381 case OPT_fdiagnostics_show_option
:
19382 case OPT_fdiagnostics_show_caret
:
19383 case OPT_fdiagnostics_color_
:
19384 case OPT_fverbose_asm
:
19386 case OPT__sysroot_
:
19388 case OPT_nostdinc__
:
19389 /* Ignore these. */
19392 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
19393 & CL_NO_DWARF_RECORD
)
19395 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
19397 switch (save_decoded_options
[j
].canonical_option
[0][1])
19404 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
19411 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
19412 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
19416 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
19418 sprintf (tail
, "%s %s", language_string
, version_string
);
19421 FOR_EACH_VEC_ELT (switches
, j
, p
)
19425 memcpy (tail
+ 1, p
, len
);
19433 /* Generate the DIE for the compilation unit. */
19436 gen_compile_unit_die (const char *filename
)
19439 const char *language_string
= lang_hooks
.name
;
19442 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
19446 add_name_attribute (die
, filename
);
19447 /* Don't add cwd for <built-in>. */
19448 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
19449 add_comp_dir_attribute (die
);
19452 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
19454 /* If our producer is LTO try to figure out a common language to use
19455 from the global list of translation units. */
19456 if (strcmp (language_string
, "GNU GIMPLE") == 0)
19460 const char *common_lang
= NULL
;
19462 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
19464 if (!TRANSLATION_UNIT_LANGUAGE (t
))
19467 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
19468 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
19470 else if (strncmp (common_lang
, "GNU C", 5) == 0
19471 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
19472 /* Mixing C and C++ is ok, use C++ in that case. */
19473 common_lang
= "GNU C++";
19476 /* Fall back to C. */
19477 common_lang
= NULL
;
19483 language_string
= common_lang
;
19486 language
= DW_LANG_C89
;
19487 if (strcmp (language_string
, "GNU C++") == 0)
19488 language
= DW_LANG_C_plus_plus
;
19489 else if (strcmp (language_string
, "GNU F77") == 0)
19490 language
= DW_LANG_Fortran77
;
19491 else if (strcmp (language_string
, "GNU Pascal") == 0)
19492 language
= DW_LANG_Pascal83
;
19493 else if (dwarf_version
>= 3 || !dwarf_strict
)
19495 if (strcmp (language_string
, "GNU Ada") == 0)
19496 language
= DW_LANG_Ada95
;
19497 else if (strcmp (language_string
, "GNU Fortran") == 0)
19498 language
= DW_LANG_Fortran95
;
19499 else if (strcmp (language_string
, "GNU Java") == 0)
19500 language
= DW_LANG_Java
;
19501 else if (strcmp (language_string
, "GNU Objective-C") == 0)
19502 language
= DW_LANG_ObjC
;
19503 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
19504 language
= DW_LANG_ObjC_plus_plus
;
19505 else if (dwarf_version
>= 5 || !dwarf_strict
)
19507 if (strcmp (language_string
, "GNU Go") == 0)
19508 language
= DW_LANG_Go
;
19511 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
19512 else if (strcmp (language_string
, "GNU Fortran") == 0)
19513 language
= DW_LANG_Fortran90
;
19515 add_AT_unsigned (die
, DW_AT_language
, language
);
19519 case DW_LANG_Fortran77
:
19520 case DW_LANG_Fortran90
:
19521 case DW_LANG_Fortran95
:
19522 /* Fortran has case insensitive identifiers and the front-end
19523 lowercases everything. */
19524 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
19527 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19533 /* Generate the DIE for a base class. */
19536 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
19538 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
19540 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
19541 add_data_member_location_attribute (die
, binfo
);
19543 if (BINFO_VIRTUAL_P (binfo
))
19544 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
19546 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19547 children, otherwise the default is DW_ACCESS_public. In DWARF2
19548 the default has always been DW_ACCESS_private. */
19549 if (access
== access_public_node
)
19551 if (dwarf_version
== 2
19552 || context_die
->die_tag
== DW_TAG_class_type
)
19553 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19555 else if (access
== access_protected_node
)
19556 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19557 else if (dwarf_version
> 2
19558 && context_die
->die_tag
!= DW_TAG_class_type
)
19559 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19562 /* Generate a DIE for a class member. */
19565 gen_member_die (tree type
, dw_die_ref context_die
)
19568 tree binfo
= TYPE_BINFO (type
);
19571 /* If this is not an incomplete type, output descriptions of each of its
19572 members. Note that as we output the DIEs necessary to represent the
19573 members of this record or union type, we will also be trying to output
19574 DIEs to represent the *types* of those members. However the `type'
19575 function (above) will specifically avoid generating type DIEs for member
19576 types *within* the list of member DIEs for this (containing) type except
19577 for those types (of members) which are explicitly marked as also being
19578 members of this (containing) type themselves. The g++ front- end can
19579 force any given type to be treated as a member of some other (containing)
19580 type by setting the TYPE_CONTEXT of the given (member) type to point to
19581 the TREE node representing the appropriate (containing) type. */
19583 /* First output info about the base classes. */
19586 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
19590 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
19591 gen_inheritance_die (base
,
19592 (accesses
? (*accesses
)[i
] : access_public_node
),
19596 /* Now output info about the data members and type members. */
19597 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
19599 /* If we thought we were generating minimal debug info for TYPE
19600 and then changed our minds, some of the member declarations
19601 may have already been defined. Don't define them again, but
19602 do put them in the right order. */
19604 child
= lookup_decl_die (member
);
19606 splice_child_die (context_die
, child
);
19608 gen_decl_die (member
, NULL
, context_die
);
19611 /* Now output info about the function members (if any). */
19612 for (member
= TYPE_METHODS (type
); member
; member
= DECL_CHAIN (member
))
19614 /* Don't include clones in the member list. */
19615 if (DECL_ABSTRACT_ORIGIN (member
))
19618 child
= lookup_decl_die (member
);
19620 splice_child_die (context_die
, child
);
19622 gen_decl_die (member
, NULL
, context_die
);
19626 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19627 is set, we pretend that the type was never defined, so we only get the
19628 member DIEs needed by later specification DIEs. */
19631 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
19632 enum debug_info_usage usage
)
19634 dw_die_ref type_die
= lookup_type_die (type
);
19635 dw_die_ref scope_die
= 0;
19637 int complete
= (TYPE_SIZE (type
)
19638 && (! TYPE_STUB_DECL (type
)
19639 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
19640 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
19641 complete
= complete
&& should_emit_struct_debug (type
, usage
);
19643 if (type_die
&& ! complete
)
19646 if (TYPE_CONTEXT (type
) != NULL_TREE
19647 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19648 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
19651 scope_die
= scope_die_for (type
, context_die
);
19653 /* Generate child dies for template paramaters. */
19654 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
19655 schedule_generic_params_dies_gen (type
);
19657 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
19658 /* First occurrence of type or toplevel definition of nested class. */
19660 dw_die_ref old_die
= type_die
;
19662 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
19663 ? record_type_tag (type
) : DW_TAG_union_type
,
19665 equate_type_number_to_die (type
, type_die
);
19667 add_AT_specification (type_die
, old_die
);
19669 add_name_attribute (type_die
, type_tag (type
));
19672 remove_AT (type_die
, DW_AT_declaration
);
19674 /* If this type has been completed, then give it a byte_size attribute and
19675 then give a list of members. */
19676 if (complete
&& !ns_decl
)
19678 /* Prevent infinite recursion in cases where the type of some member of
19679 this type is expressed in terms of this type itself. */
19680 TREE_ASM_WRITTEN (type
) = 1;
19681 add_byte_size_attribute (type_die
, type
);
19682 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
19684 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
19685 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
19688 /* If the first reference to this type was as the return type of an
19689 inline function, then it may not have a parent. Fix this now. */
19690 if (type_die
->die_parent
== NULL
)
19691 add_child_die (scope_die
, type_die
);
19693 push_decl_scope (type
);
19694 gen_member_die (type
, type_die
);
19697 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
19698 if (TYPE_ARTIFICIAL (type
))
19699 add_AT_flag (type_die
, DW_AT_artificial
, 1);
19701 /* GNU extension: Record what type our vtable lives in. */
19702 if (TYPE_VFIELD (type
))
19704 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
19706 gen_type_die (vtype
, context_die
);
19707 add_AT_die_ref (type_die
, DW_AT_containing_type
,
19708 lookup_type_die (vtype
));
19713 add_AT_flag (type_die
, DW_AT_declaration
, 1);
19715 /* We don't need to do this for function-local types. */
19716 if (TYPE_STUB_DECL (type
)
19717 && ! decl_function_context (TYPE_STUB_DECL (type
)))
19718 vec_safe_push (incomplete_types
, type
);
19721 if (get_AT (type_die
, DW_AT_name
))
19722 add_pubtype (type
, type_die
);
19725 /* Generate a DIE for a subroutine _type_. */
19728 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
19730 tree return_type
= TREE_TYPE (type
);
19731 dw_die_ref subr_die
19732 = new_die (DW_TAG_subroutine_type
,
19733 scope_die_for (type
, context_die
), type
);
19735 equate_type_number_to_die (type
, subr_die
);
19736 add_prototyped_attribute (subr_die
, type
);
19737 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
19738 gen_formal_types_die (type
, subr_die
);
19740 if (get_AT (subr_die
, DW_AT_name
))
19741 add_pubtype (type
, subr_die
);
19744 /* Generate a DIE for a type definition. */
19747 gen_typedef_die (tree decl
, dw_die_ref context_die
)
19749 dw_die_ref type_die
;
19752 if (TREE_ASM_WRITTEN (decl
))
19755 TREE_ASM_WRITTEN (decl
) = 1;
19756 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
19757 origin
= decl_ultimate_origin (decl
);
19758 if (origin
!= NULL
)
19759 add_abstract_origin_attribute (type_die
, origin
);
19764 add_name_and_src_coords_attributes (type_die
, decl
);
19765 if (DECL_ORIGINAL_TYPE (decl
))
19767 type
= DECL_ORIGINAL_TYPE (decl
);
19769 gcc_assert (type
!= TREE_TYPE (decl
));
19770 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
19774 type
= TREE_TYPE (decl
);
19776 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19778 /* Here, we are in the case of decl being a typedef naming
19779 an anonymous type, e.g:
19780 typedef struct {...} foo;
19781 In that case TREE_TYPE (decl) is not a typedef variant
19782 type and TYPE_NAME of the anonymous type is set to the
19783 TYPE_DECL of the typedef. This construct is emitted by
19786 TYPE is the anonymous struct named by the typedef
19787 DECL. As we need the DW_AT_type attribute of the
19788 DW_TAG_typedef to point to the DIE of TYPE, let's
19789 generate that DIE right away. add_type_attribute
19790 called below will then pick (via lookup_type_die) that
19791 anonymous struct DIE. */
19792 if (!TREE_ASM_WRITTEN (type
))
19793 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
19795 /* This is a GNU Extension. We are adding a
19796 DW_AT_linkage_name attribute to the DIE of the
19797 anonymous struct TYPE. The value of that attribute
19798 is the name of the typedef decl naming the anonymous
19799 struct. This greatly eases the work of consumers of
19800 this debug info. */
19801 add_linkage_attr (lookup_type_die (type
), decl
);
19805 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
19806 TREE_THIS_VOLATILE (decl
), context_die
);
19808 if (is_naming_typedef_decl (decl
))
19809 /* We want that all subsequent calls to lookup_type_die with
19810 TYPE in argument yield the DW_TAG_typedef we have just
19812 equate_type_number_to_die (type
, type_die
);
19814 add_accessibility_attribute (type_die
, decl
);
19817 if (DECL_ABSTRACT (decl
))
19818 equate_decl_number_to_die (decl
, type_die
);
19820 if (get_AT (type_die
, DW_AT_name
))
19821 add_pubtype (decl
, type_die
);
19824 /* Generate a DIE for a struct, class, enum or union type. */
19827 gen_tagged_type_die (tree type
,
19828 dw_die_ref context_die
,
19829 enum debug_info_usage usage
)
19833 if (type
== NULL_TREE
19834 || !is_tagged_type (type
))
19837 /* If this is a nested type whose containing class hasn't been written
19838 out yet, writing it out will cover this one, too. This does not apply
19839 to instantiations of member class templates; they need to be added to
19840 the containing class as they are generated. FIXME: This hurts the
19841 idea of combining type decls from multiple TUs, since we can't predict
19842 what set of template instantiations we'll get. */
19843 if (TYPE_CONTEXT (type
)
19844 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19845 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
19847 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
19849 if (TREE_ASM_WRITTEN (type
))
19852 /* If that failed, attach ourselves to the stub. */
19853 push_decl_scope (TYPE_CONTEXT (type
));
19854 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
19857 else if (TYPE_CONTEXT (type
) != NULL_TREE
19858 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
19860 /* If this type is local to a function that hasn't been written
19861 out yet, use a NULL context for now; it will be fixed up in
19862 decls_for_scope. */
19863 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
19864 /* A declaration DIE doesn't count; nested types need to go in the
19866 if (context_die
&& is_declaration_die (context_die
))
19867 context_die
= NULL
;
19872 context_die
= declare_in_namespace (type
, context_die
);
19876 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
19878 /* This might have been written out by the call to
19879 declare_in_namespace. */
19880 if (!TREE_ASM_WRITTEN (type
))
19881 gen_enumeration_type_die (type
, context_die
);
19884 gen_struct_or_union_type_die (type
, context_die
, usage
);
19889 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
19890 it up if it is ever completed. gen_*_type_die will set it for us
19891 when appropriate. */
19894 /* Generate a type description DIE. */
19897 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
19898 enum debug_info_usage usage
)
19900 struct array_descr_info info
;
19902 if (type
== NULL_TREE
|| type
== error_mark_node
)
19905 if (TYPE_NAME (type
) != NULL_TREE
19906 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
19907 && is_redundant_typedef (TYPE_NAME (type
))
19908 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
19909 /* The DECL of this type is a typedef we don't want to emit debug
19910 info for but we want debug info for its underlying typedef.
19911 This can happen for e.g, the injected-class-name of a C++
19913 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
19915 /* If TYPE is a typedef type variant, let's generate debug info
19916 for the parent typedef which TYPE is a type of. */
19917 if (typedef_variant_p (type
))
19919 if (TREE_ASM_WRITTEN (type
))
19922 /* Prevent broken recursion; we can't hand off to the same type. */
19923 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
19925 /* Give typedefs the right scope. */
19926 context_die
= scope_die_for (type
, context_die
);
19928 TREE_ASM_WRITTEN (type
) = 1;
19930 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19934 /* If type is an anonymous tagged type named by a typedef, let's
19935 generate debug info for the typedef. */
19936 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19938 /* Use the DIE of the containing namespace as the parent DIE of
19939 the type description DIE we want to generate. */
19940 if (DECL_CONTEXT (TYPE_NAME (type
))
19941 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
19942 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
19944 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19948 /* If this is an array type with hidden descriptor, handle it first. */
19949 if (!TREE_ASM_WRITTEN (type
)
19950 && lang_hooks
.types
.get_array_descr_info
19951 && lang_hooks
.types
.get_array_descr_info (type
, &info
)
19952 && (dwarf_version
>= 3 || !dwarf_strict
))
19954 gen_descr_array_type_die (type
, &info
, context_die
);
19955 TREE_ASM_WRITTEN (type
) = 1;
19959 /* We are going to output a DIE to represent the unqualified version
19960 of this type (i.e. without any const or volatile qualifiers) so
19961 get the main variant (i.e. the unqualified version) of this type
19962 now. (Vectors are special because the debugging info is in the
19963 cloned type itself). */
19964 if (TREE_CODE (type
) != VECTOR_TYPE
)
19965 type
= type_main_variant (type
);
19967 if (TREE_ASM_WRITTEN (type
))
19970 switch (TREE_CODE (type
))
19976 case REFERENCE_TYPE
:
19977 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
19978 ensures that the gen_type_die recursion will terminate even if the
19979 type is recursive. Recursive types are possible in Ada. */
19980 /* ??? We could perhaps do this for all types before the switch
19982 TREE_ASM_WRITTEN (type
) = 1;
19984 /* For these types, all that is required is that we output a DIE (or a
19985 set of DIEs) to represent the "basis" type. */
19986 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19987 DINFO_USAGE_IND_USE
);
19991 /* This code is used for C++ pointer-to-data-member types.
19992 Output a description of the relevant class type. */
19993 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
19994 DINFO_USAGE_IND_USE
);
19996 /* Output a description of the type of the object pointed to. */
19997 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19998 DINFO_USAGE_IND_USE
);
20000 /* Now output a DIE to represent this pointer-to-data-member type
20002 gen_ptr_to_mbr_type_die (type
, context_die
);
20005 case FUNCTION_TYPE
:
20006 /* Force out return type (in case it wasn't forced out already). */
20007 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20008 DINFO_USAGE_DIR_USE
);
20009 gen_subroutine_type_die (type
, context_die
);
20013 /* Force out return type (in case it wasn't forced out already). */
20014 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20015 DINFO_USAGE_DIR_USE
);
20016 gen_subroutine_type_die (type
, context_die
);
20020 gen_array_type_die (type
, context_die
);
20024 gen_array_type_die (type
, context_die
);
20027 case ENUMERAL_TYPE
:
20030 case QUAL_UNION_TYPE
:
20031 gen_tagged_type_die (type
, context_die
, usage
);
20037 case FIXED_POINT_TYPE
:
20040 /* No DIEs needed for fundamental types. */
20045 /* Just use DW_TAG_unspecified_type. */
20047 dw_die_ref type_die
= lookup_type_die (type
);
20048 if (type_die
== NULL
)
20050 tree name
= TYPE_IDENTIFIER (type
);
20051 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
20053 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
20054 equate_type_number_to_die (type
, type_die
);
20060 if (is_cxx_auto (type
))
20062 tree name
= TYPE_IDENTIFIER (type
);
20063 dw_die_ref
*die
= (name
== get_identifier ("auto")
20064 ? &auto_die
: &decltype_auto_die
);
20067 *die
= new_die (DW_TAG_unspecified_type
,
20068 comp_unit_die (), NULL_TREE
);
20069 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
20071 equate_type_number_to_die (type
, *die
);
20074 gcc_unreachable ();
20077 TREE_ASM_WRITTEN (type
) = 1;
20081 gen_type_die (tree type
, dw_die_ref context_die
)
20083 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
20086 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
20087 things which are local to the given block. */
20090 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
20092 int must_output_die
= 0;
20095 /* Ignore blocks that are NULL. */
20096 if (stmt
== NULL_TREE
)
20099 inlined_func
= inlined_function_outer_scope_p (stmt
);
20101 /* If the block is one fragment of a non-contiguous block, do not
20102 process the variables, since they will have been done by the
20103 origin block. Do process subblocks. */
20104 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
20108 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
20109 gen_block_die (sub
, context_die
, depth
+ 1);
20114 /* Determine if we need to output any Dwarf DIEs at all to represent this
20117 /* The outer scopes for inlinings *must* always be represented. We
20118 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20119 must_output_die
= 1;
20122 /* Determine if this block directly contains any "significant"
20123 local declarations which we will need to output DIEs for. */
20124 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20125 /* We are not in terse mode so *any* local declaration counts
20126 as being a "significant" one. */
20127 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
20128 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
20129 && (TREE_USED (stmt
)
20130 || TREE_ASM_WRITTEN (stmt
)
20131 || BLOCK_ABSTRACT (stmt
)));
20132 else if ((TREE_USED (stmt
)
20133 || TREE_ASM_WRITTEN (stmt
)
20134 || BLOCK_ABSTRACT (stmt
))
20135 && !dwarf2out_ignore_block (stmt
))
20136 must_output_die
= 1;
20139 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20140 DIE for any block which contains no significant local declarations at
20141 all. Rather, in such cases we just call `decls_for_scope' so that any
20142 needed Dwarf info for any sub-blocks will get properly generated. Note
20143 that in terse mode, our definition of what constitutes a "significant"
20144 local declaration gets restricted to include only inlined function
20145 instances and local (nested) function definitions. */
20146 if (must_output_die
)
20150 /* If STMT block is abstract, that means we have been called
20151 indirectly from dwarf2out_abstract_function.
20152 That function rightfully marks the descendent blocks (of
20153 the abstract function it is dealing with) as being abstract,
20154 precisely to prevent us from emitting any
20155 DW_TAG_inlined_subroutine DIE as a descendent
20156 of an abstract function instance. So in that case, we should
20157 not call gen_inlined_subroutine_die.
20159 Later though, when cgraph asks dwarf2out to emit info
20160 for the concrete instance of the function decl into which
20161 the concrete instance of STMT got inlined, the later will lead
20162 to the generation of a DW_TAG_inlined_subroutine DIE. */
20163 if (! BLOCK_ABSTRACT (stmt
))
20164 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
20167 gen_lexical_block_die (stmt
, context_die
, depth
);
20170 decls_for_scope (stmt
, context_die
, depth
);
20173 /* Process variable DECL (or variable with origin ORIGIN) within
20174 block STMT and add it to CONTEXT_DIE. */
20176 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
20179 tree decl_or_origin
= decl
? decl
: origin
;
20181 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
20182 die
= lookup_decl_die (decl_or_origin
);
20183 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
20184 && TYPE_DECL_IS_STUB (decl_or_origin
))
20185 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
20189 if (die
!= NULL
&& die
->die_parent
== NULL
)
20190 add_child_die (context_die
, die
);
20191 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
20192 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
20193 stmt
, context_die
);
20195 gen_decl_die (decl
, origin
, context_die
);
20198 /* Generate all of the decls declared within a given scope and (recursively)
20199 all of its sub-blocks. */
20202 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
20208 /* Ignore NULL blocks. */
20209 if (stmt
== NULL_TREE
)
20212 /* Output the DIEs to represent all of the data objects and typedefs
20213 declared directly within this block but not within any nested
20214 sub-blocks. Also, nested function and tag DIEs have been
20215 generated with a parent of NULL; fix that up now. We don't
20216 have to do this if we're at -g1. */
20217 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20219 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
20220 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
20221 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
20222 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
20226 /* Even if we're at -g1, we need to process the subblocks in order to get
20227 inlined call information. */
20229 /* Output the DIEs to represent all sub-blocks (and the items declared
20230 therein) of this block. */
20231 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
20233 subblocks
= BLOCK_CHAIN (subblocks
))
20234 gen_block_die (subblocks
, context_die
, depth
+ 1);
20237 /* Is this a typedef we can avoid emitting? */
20240 is_redundant_typedef (const_tree decl
)
20242 if (TYPE_DECL_IS_STUB (decl
))
20245 if (DECL_ARTIFICIAL (decl
)
20246 && DECL_CONTEXT (decl
)
20247 && is_tagged_type (DECL_CONTEXT (decl
))
20248 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
20249 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
20250 /* Also ignore the artificial member typedef for the class name. */
20256 /* Return TRUE if TYPE is a typedef that names a type for linkage
20257 purposes. This kind of typedefs is produced by the C++ FE for
20260 typedef struct {...} foo;
20262 In that case, there is no typedef variant type produced for foo.
20263 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20267 is_naming_typedef_decl (const_tree decl
)
20269 if (decl
== NULL_TREE
20270 || TREE_CODE (decl
) != TYPE_DECL
20271 || !is_tagged_type (TREE_TYPE (decl
))
20272 || DECL_IS_BUILTIN (decl
)
20273 || is_redundant_typedef (decl
)
20274 /* It looks like Ada produces TYPE_DECLs that are very similar
20275 to C++ naming typedefs but that have different
20276 semantics. Let's be specific to c++ for now. */
20280 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
20281 && TYPE_NAME (TREE_TYPE (decl
)) == decl
20282 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
20283 != TYPE_NAME (TREE_TYPE (decl
))));
20286 /* Returns the DIE for a context. */
20288 static inline dw_die_ref
20289 get_context_die (tree context
)
20293 /* Find die that represents this context. */
20294 if (TYPE_P (context
))
20296 context
= TYPE_MAIN_VARIANT (context
);
20297 return strip_naming_typedef (context
, force_type_die (context
));
20300 return force_decl_die (context
);
20302 return comp_unit_die ();
20305 /* Returns the DIE for decl. A DIE will always be returned. */
20308 force_decl_die (tree decl
)
20310 dw_die_ref decl_die
;
20311 unsigned saved_external_flag
;
20312 tree save_fn
= NULL_TREE
;
20313 decl_die
= lookup_decl_die (decl
);
20316 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
20318 decl_die
= lookup_decl_die (decl
);
20322 switch (TREE_CODE (decl
))
20324 case FUNCTION_DECL
:
20325 /* Clear current_function_decl, so that gen_subprogram_die thinks
20326 that this is a declaration. At this point, we just want to force
20327 declaration die. */
20328 save_fn
= current_function_decl
;
20329 current_function_decl
= NULL_TREE
;
20330 gen_subprogram_die (decl
, context_die
);
20331 current_function_decl
= save_fn
;
20335 /* Set external flag to force declaration die. Restore it after
20336 gen_decl_die() call. */
20337 saved_external_flag
= DECL_EXTERNAL (decl
);
20338 DECL_EXTERNAL (decl
) = 1;
20339 gen_decl_die (decl
, NULL
, context_die
);
20340 DECL_EXTERNAL (decl
) = saved_external_flag
;
20343 case NAMESPACE_DECL
:
20344 if (dwarf_version
>= 3 || !dwarf_strict
)
20345 dwarf2out_decl (decl
);
20347 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20348 decl_die
= comp_unit_die ();
20351 case TRANSLATION_UNIT_DECL
:
20352 decl_die
= comp_unit_die ();
20356 gcc_unreachable ();
20359 /* We should be able to find the DIE now. */
20361 decl_die
= lookup_decl_die (decl
);
20362 gcc_assert (decl_die
);
20368 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20369 always returned. */
20372 force_type_die (tree type
)
20374 dw_die_ref type_die
;
20376 type_die
= lookup_type_die (type
);
20379 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
20381 type_die
= modified_type_die (type
, TYPE_READONLY (type
),
20382 TYPE_VOLATILE (type
), context_die
);
20383 gcc_assert (type_die
);
20388 /* Force out any required namespaces to be able to output DECL,
20389 and return the new context_die for it, if it's changed. */
20392 setup_namespace_context (tree thing
, dw_die_ref context_die
)
20394 tree context
= (DECL_P (thing
)
20395 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
20396 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
20397 /* Force out the namespace. */
20398 context_die
= force_decl_die (context
);
20400 return context_die
;
20403 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20404 type) within its namespace, if appropriate.
20406 For compatibility with older debuggers, namespace DIEs only contain
20407 declarations; all definitions are emitted at CU scope. */
20410 declare_in_namespace (tree thing
, dw_die_ref context_die
)
20412 dw_die_ref ns_context
;
20414 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20415 return context_die
;
20417 /* If this decl is from an inlined function, then don't try to emit it in its
20418 namespace, as we will get confused. It would have already been emitted
20419 when the abstract instance of the inline function was emitted anyways. */
20420 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
20421 return context_die
;
20423 ns_context
= setup_namespace_context (thing
, context_die
);
20425 if (ns_context
!= context_die
)
20429 if (DECL_P (thing
))
20430 gen_decl_die (thing
, NULL
, ns_context
);
20432 gen_type_die (thing
, ns_context
);
20434 return context_die
;
20437 /* Generate a DIE for a namespace or namespace alias. */
20440 gen_namespace_die (tree decl
, dw_die_ref context_die
)
20442 dw_die_ref namespace_die
;
20444 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20445 they are an alias of. */
20446 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
20448 /* Output a real namespace or module. */
20449 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20450 namespace_die
= new_die (is_fortran ()
20451 ? DW_TAG_module
: DW_TAG_namespace
,
20452 context_die
, decl
);
20453 /* For Fortran modules defined in different CU don't add src coords. */
20454 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
20456 const char *name
= dwarf2_name (decl
, 0);
20458 add_name_attribute (namespace_die
, name
);
20461 add_name_and_src_coords_attributes (namespace_die
, decl
);
20462 if (DECL_EXTERNAL (decl
))
20463 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
20464 equate_decl_number_to_die (decl
, namespace_die
);
20468 /* Output a namespace alias. */
20470 /* Force out the namespace we are an alias of, if necessary. */
20471 dw_die_ref origin_die
20472 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
20474 if (DECL_FILE_SCOPE_P (decl
)
20475 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
20476 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20477 /* Now create the namespace alias DIE. */
20478 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
20479 add_name_and_src_coords_attributes (namespace_die
, decl
);
20480 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
20481 equate_decl_number_to_die (decl
, namespace_die
);
20483 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
20484 if (want_pubnames ())
20485 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
20488 /* Generate Dwarf debug information for a decl described by DECL.
20489 The return value is currently only meaningful for PARM_DECLs,
20490 for all other decls it returns NULL. */
20493 gen_decl_die (tree decl
, tree origin
, dw_die_ref context_die
)
20495 tree decl_or_origin
= decl
? decl
: origin
;
20496 tree class_origin
= NULL
, ultimate_origin
;
20498 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
20501 switch (TREE_CODE (decl_or_origin
))
20507 if (!is_fortran () && !is_ada ())
20509 /* The individual enumerators of an enum type get output when we output
20510 the Dwarf representation of the relevant enum type itself. */
20514 /* Emit its type. */
20515 gen_type_die (TREE_TYPE (decl
), context_die
);
20517 /* And its containing namespace. */
20518 context_die
= declare_in_namespace (decl
, context_die
);
20520 gen_const_die (decl
, context_die
);
20523 case FUNCTION_DECL
:
20524 /* Don't output any DIEs to represent mere function declarations,
20525 unless they are class members or explicit block externs. */
20526 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
20527 && DECL_FILE_SCOPE_P (decl_or_origin
)
20528 && (current_function_decl
== NULL_TREE
20529 || DECL_ARTIFICIAL (decl_or_origin
)))
20534 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20535 on local redeclarations of global functions. That seems broken. */
20536 if (current_function_decl
!= decl
)
20537 /* This is only a declaration. */;
20540 /* If we're emitting a clone, emit info for the abstract instance. */
20541 if (origin
|| DECL_ORIGIN (decl
) != decl
)
20542 dwarf2out_abstract_function (origin
20543 ? DECL_ORIGIN (origin
)
20544 : DECL_ABSTRACT_ORIGIN (decl
));
20546 /* If we're emitting an out-of-line copy of an inline function,
20547 emit info for the abstract instance and set up to refer to it. */
20548 else if (cgraph_function_possibly_inlined_p (decl
)
20549 && ! DECL_ABSTRACT (decl
)
20550 && ! class_or_namespace_scope_p (context_die
)
20551 /* dwarf2out_abstract_function won't emit a die if this is just
20552 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20553 that case, because that works only if we have a die. */
20554 && DECL_INITIAL (decl
) != NULL_TREE
)
20556 dwarf2out_abstract_function (decl
);
20557 set_decl_origin_self (decl
);
20560 /* Otherwise we're emitting the primary DIE for this decl. */
20561 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
20563 /* Before we describe the FUNCTION_DECL itself, make sure that we
20564 have its containing type. */
20566 origin
= decl_class_context (decl
);
20567 if (origin
!= NULL_TREE
)
20568 gen_type_die (origin
, context_die
);
20570 /* And its return type. */
20571 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
20573 /* And its virtual context. */
20574 if (DECL_VINDEX (decl
) != NULL_TREE
)
20575 gen_type_die (DECL_CONTEXT (decl
), context_die
);
20577 /* Make sure we have a member DIE for decl. */
20578 if (origin
!= NULL_TREE
)
20579 gen_type_die_for_member (origin
, decl
, context_die
);
20581 /* And its containing namespace. */
20582 context_die
= declare_in_namespace (decl
, context_die
);
20585 /* Now output a DIE to represent the function itself. */
20587 gen_subprogram_die (decl
, context_die
);
20591 /* If we are in terse mode, don't generate any DIEs to represent any
20592 actual typedefs. */
20593 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20596 /* In the special case of a TYPE_DECL node representing the declaration
20597 of some type tag, if the given TYPE_DECL is marked as having been
20598 instantiated from some other (original) TYPE_DECL node (e.g. one which
20599 was generated within the original definition of an inline function) we
20600 used to generate a special (abbreviated) DW_TAG_structure_type,
20601 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20602 should be actually referencing those DIEs, as variable DIEs with that
20603 type would be emitted already in the abstract origin, so it was always
20604 removed during unused type prunning. Don't add anything in this
20606 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
20609 if (is_redundant_typedef (decl
))
20610 gen_type_die (TREE_TYPE (decl
), context_die
);
20612 /* Output a DIE to represent the typedef itself. */
20613 gen_typedef_die (decl
, context_die
);
20617 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
20618 gen_label_die (decl
, context_die
);
20623 /* If we are in terse mode, don't generate any DIEs to represent any
20624 variable declarations or definitions. */
20625 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20628 /* Output any DIEs that are needed to specify the type of this data
20630 if (decl_by_reference_p (decl_or_origin
))
20631 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20633 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20635 /* And its containing type. */
20636 class_origin
= decl_class_context (decl_or_origin
);
20637 if (class_origin
!= NULL_TREE
)
20638 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
20640 /* And its containing namespace. */
20641 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
20643 /* Now output the DIE to represent the data object itself. This gets
20644 complicated because of the possibility that the VAR_DECL really
20645 represents an inlined instance of a formal parameter for an inline
20647 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
20648 if (ultimate_origin
!= NULL_TREE
20649 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
20650 gen_formal_parameter_die (decl
, origin
,
20651 true /* Emit name attribute. */,
20654 gen_variable_die (decl
, origin
, context_die
);
20658 /* Ignore the nameless fields that are used to skip bits but handle C++
20659 anonymous unions and structs. */
20660 if (DECL_NAME (decl
) != NULL_TREE
20661 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
20662 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
20664 gen_type_die (member_declared_type (decl
), context_die
);
20665 gen_field_die (decl
, context_die
);
20670 if (DECL_BY_REFERENCE (decl_or_origin
))
20671 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20673 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20674 return gen_formal_parameter_die (decl
, origin
,
20675 true /* Emit name attribute. */,
20678 case NAMESPACE_DECL
:
20679 case IMPORTED_DECL
:
20680 if (dwarf_version
>= 3 || !dwarf_strict
)
20681 gen_namespace_die (decl
, context_die
);
20684 case NAMELIST_DECL
:
20685 gen_namelist_decl (DECL_NAME (decl
), context_die
,
20686 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
20690 /* Probably some frontend-internal decl. Assume we don't care. */
20691 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
20698 /* Output debug information for global decl DECL. Called from toplev.c after
20699 compilation proper has finished. */
20702 dwarf2out_global_decl (tree decl
)
20704 /* Output DWARF2 information for file-scope tentative data object
20705 declarations, file-scope (extern) function declarations (which
20706 had no corresponding body) and file-scope tagged type declarations
20707 and definitions which have not yet been forced out. */
20708 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
20709 dwarf2out_decl (decl
);
20712 /* Output debug information for type decl DECL. Called from toplev.c
20713 and from language front ends (to record built-in types). */
20715 dwarf2out_type_decl (tree decl
, int local
)
20718 dwarf2out_decl (decl
);
20721 /* Output debug information for imported module or decl DECL.
20722 NAME is non-NULL name in the lexical block if the decl has been renamed.
20723 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
20724 that DECL belongs to.
20725 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
20727 dwarf2out_imported_module_or_decl_1 (tree decl
,
20729 tree lexical_block
,
20730 dw_die_ref lexical_block_die
)
20732 expanded_location xloc
;
20733 dw_die_ref imported_die
= NULL
;
20734 dw_die_ref at_import_die
;
20736 if (TREE_CODE (decl
) == IMPORTED_DECL
)
20738 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
20739 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
20743 xloc
= expand_location (input_location
);
20745 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
20747 at_import_die
= force_type_die (TREE_TYPE (decl
));
20748 /* For namespace N { typedef void T; } using N::T; base_type_die
20749 returns NULL, but DW_TAG_imported_declaration requires
20750 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
20751 if (!at_import_die
)
20753 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
20754 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
20755 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
20756 gcc_assert (at_import_die
);
20761 at_import_die
= lookup_decl_die (decl
);
20762 if (!at_import_die
)
20764 /* If we're trying to avoid duplicate debug info, we may not have
20765 emitted the member decl for this field. Emit it now. */
20766 if (TREE_CODE (decl
) == FIELD_DECL
)
20768 tree type
= DECL_CONTEXT (decl
);
20770 if (TYPE_CONTEXT (type
)
20771 && TYPE_P (TYPE_CONTEXT (type
))
20772 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
20773 DINFO_USAGE_DIR_USE
))
20775 gen_type_die_for_member (type
, decl
,
20776 get_context_die (TYPE_CONTEXT (type
)));
20778 if (TREE_CODE (decl
) == NAMELIST_DECL
)
20779 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
20780 get_context_die (DECL_CONTEXT (decl
)),
20783 at_import_die
= force_decl_die (decl
);
20787 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
20789 if (dwarf_version
>= 3 || !dwarf_strict
)
20790 imported_die
= new_die (DW_TAG_imported_module
,
20797 imported_die
= new_die (DW_TAG_imported_declaration
,
20801 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
20802 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
20804 add_AT_string (imported_die
, DW_AT_name
,
20805 IDENTIFIER_POINTER (name
));
20806 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
20809 /* Output debug information for imported module or decl DECL.
20810 NAME is non-NULL name in context if the decl has been renamed.
20811 CHILD is true if decl is one of the renamed decls as part of
20812 importing whole module. */
20815 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
20818 /* dw_die_ref at_import_die; */
20819 dw_die_ref scope_die
;
20821 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20826 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
20827 We need decl DIE for reference and scope die. First, get DIE for the decl
20830 /* Get the scope die for decl context. Use comp_unit_die for global module
20831 or decl. If die is not found for non globals, force new die. */
20833 && TYPE_P (context
)
20834 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
20837 if (!(dwarf_version
>= 3 || !dwarf_strict
))
20840 scope_die
= get_context_die (context
);
20844 gcc_assert (scope_die
->die_child
);
20845 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
20846 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
20847 scope_die
= scope_die
->die_child
;
20850 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
20851 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
20855 /* Output debug information for namelists. */
20858 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
20860 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
20864 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20867 gcc_assert (scope_die
!= NULL
);
20868 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
20869 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
20871 /* If there are no item_decls, we have a nondefining namelist, e.g.
20872 with USE association; hence, set DW_AT_declaration. */
20873 if (item_decls
== NULL_TREE
)
20875 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
20879 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
20881 nml_item_ref_die
= lookup_decl_die (value
);
20882 if (!nml_item_ref_die
)
20883 nml_item_ref_die
= force_decl_die (value
);
20885 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
20886 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
20892 /* Write the debugging output for DECL. */
20895 dwarf2out_decl (tree decl
)
20897 dw_die_ref context_die
= comp_unit_die ();
20899 switch (TREE_CODE (decl
))
20904 case FUNCTION_DECL
:
20905 /* What we would really like to do here is to filter out all mere
20906 file-scope declarations of file-scope functions which are never
20907 referenced later within this translation unit (and keep all of ones
20908 that *are* referenced later on) but we aren't clairvoyant, so we have
20909 no idea which functions will be referenced in the future (i.e. later
20910 on within the current translation unit). So here we just ignore all
20911 file-scope function declarations which are not also definitions. If
20912 and when the debugger needs to know something about these functions,
20913 it will have to hunt around and find the DWARF information associated
20914 with the definition of the function.
20916 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
20917 nodes represent definitions and which ones represent mere
20918 declarations. We have to check DECL_INITIAL instead. That's because
20919 the C front-end supports some weird semantics for "extern inline"
20920 function definitions. These can get inlined within the current
20921 translation unit (and thus, we need to generate Dwarf info for their
20922 abstract instances so that the Dwarf info for the concrete inlined
20923 instances can have something to refer to) but the compiler never
20924 generates any out-of-lines instances of such things (despite the fact
20925 that they *are* definitions).
20927 The important point is that the C front-end marks these "extern
20928 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
20929 them anyway. Note that the C++ front-end also plays some similar games
20930 for inline function definitions appearing within include files which
20931 also contain `#pragma interface' pragmas.
20933 If we are called from dwarf2out_abstract_function output a DIE
20934 anyway. We can end up here this way with early inlining and LTO
20935 where the inlined function is output in a different LTRANS unit
20937 if (DECL_INITIAL (decl
) == NULL_TREE
20938 && ! DECL_ABSTRACT (decl
))
20941 /* If we're a nested function, initially use a parent of NULL; if we're
20942 a plain function, this will be fixed up in decls_for_scope. If
20943 we're a method, it will be ignored, since we already have a DIE. */
20944 if (decl_function_context (decl
)
20945 /* But if we're in terse mode, we don't care about scope. */
20946 && debug_info_level
> DINFO_LEVEL_TERSE
)
20947 context_die
= NULL
;
20951 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
20952 declaration and if the declaration was never even referenced from
20953 within this entire compilation unit. We suppress these DIEs in
20954 order to save space in the .debug section (by eliminating entries
20955 which are probably useless). Note that we must not suppress
20956 block-local extern declarations (whether used or not) because that
20957 would screw-up the debugger's name lookup mechanism and cause it to
20958 miss things which really ought to be in scope at a given point. */
20959 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
20962 /* For local statics lookup proper context die. */
20963 if (TREE_STATIC (decl
)
20964 && DECL_CONTEXT (decl
)
20965 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
20966 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20968 /* If we are in terse mode, don't generate any DIEs to represent any
20969 variable declarations or definitions. */
20970 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20975 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20977 if (!is_fortran () && !is_ada ())
20979 if (TREE_STATIC (decl
) && decl_function_context (decl
))
20980 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20983 case NAMESPACE_DECL
:
20984 case IMPORTED_DECL
:
20985 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20987 if (lookup_decl_die (decl
) != NULL
)
20992 /* Don't emit stubs for types unless they are needed by other DIEs. */
20993 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
20996 /* Don't bother trying to generate any DIEs to represent any of the
20997 normal built-in types for the language we are compiling. */
20998 if (DECL_IS_BUILTIN (decl
))
21001 /* If we are in terse mode, don't generate any DIEs for types. */
21002 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
21005 /* If we're a function-scope tag, initially use a parent of NULL;
21006 this will be fixed up in decls_for_scope. */
21007 if (decl_function_context (decl
))
21008 context_die
= NULL
;
21012 case NAMELIST_DECL
:
21019 gen_decl_die (decl
, NULL
, context_die
);
21022 /* Write the debugging output for DECL. */
21025 dwarf2out_function_decl (tree decl
)
21027 dwarf2out_decl (decl
);
21028 call_arg_locations
= NULL
;
21029 call_arg_loc_last
= NULL
;
21030 call_site_count
= -1;
21031 tail_call_site_count
= -1;
21032 block_map
.release ();
21033 htab_empty (decl_loc_table
);
21034 htab_empty (cached_dw_loc_list_table
);
21037 /* Output a marker (i.e. a label) for the beginning of the generated code for
21038 a lexical block. */
21041 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
21042 unsigned int blocknum
)
21044 switch_to_section (current_function_section ());
21045 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
21048 /* Output a marker (i.e. a label) for the end of the generated code for a
21052 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
21054 switch_to_section (current_function_section ());
21055 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
21058 /* Returns nonzero if it is appropriate not to emit any debugging
21059 information for BLOCK, because it doesn't contain any instructions.
21061 Don't allow this for blocks with nested functions or local classes
21062 as we would end up with orphans, and in the presence of scheduling
21063 we may end up calling them anyway. */
21066 dwarf2out_ignore_block (const_tree block
)
21071 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
21072 if (TREE_CODE (decl
) == FUNCTION_DECL
21073 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
21075 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
21077 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
21078 if (TREE_CODE (decl
) == FUNCTION_DECL
21079 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
21086 /* Hash table routines for file_hash. */
21089 file_table_eq (const void *p1_p
, const void *p2_p
)
21091 const struct dwarf_file_data
*const p1
=
21092 (const struct dwarf_file_data
*) p1_p
;
21093 const char *const p2
= (const char *) p2_p
;
21094 return filename_cmp (p1
->filename
, p2
) == 0;
21098 file_table_hash (const void *p_p
)
21100 const struct dwarf_file_data
*const p
= (const struct dwarf_file_data
*) p_p
;
21101 return htab_hash_string (p
->filename
);
21104 /* Lookup FILE_NAME (in the list of filenames that we know about here in
21105 dwarf2out.c) and return its "index". The index of each (known) filename is
21106 just a unique number which is associated with only that one filename. We
21107 need such numbers for the sake of generating labels (in the .debug_sfnames
21108 section) and references to those files numbers (in the .debug_srcinfo
21109 and.debug_macinfo sections). If the filename given as an argument is not
21110 found in our current list, add it to the list and assign it the next
21111 available unique index number. In order to speed up searches, we remember
21112 the index of the filename was looked up last. This handles the majority of
21115 static struct dwarf_file_data
*
21116 lookup_filename (const char *file_name
)
21119 struct dwarf_file_data
* created
;
21121 /* Check to see if the file name that was searched on the previous
21122 call matches this file name. If so, return the index. */
21123 if (file_table_last_lookup
21124 && (file_name
== file_table_last_lookup
->filename
21125 || filename_cmp (file_table_last_lookup
->filename
, file_name
) == 0))
21126 return file_table_last_lookup
;
21128 /* Didn't match the previous lookup, search the table. */
21129 slot
= htab_find_slot_with_hash (file_table
, file_name
,
21130 htab_hash_string (file_name
), INSERT
);
21132 return (struct dwarf_file_data
*) *slot
;
21134 created
= ggc_alloc
<dwarf_file_data
> ();
21135 created
->filename
= file_name
;
21136 created
->emitted_number
= 0;
21141 /* If the assembler will construct the file table, then translate the compiler
21142 internal file table number into the assembler file table number, and emit
21143 a .file directive if we haven't already emitted one yet. The file table
21144 numbers are different because we prune debug info for unused variables and
21145 types, which may include filenames. */
21148 maybe_emit_file (struct dwarf_file_data
* fd
)
21150 if (! fd
->emitted_number
)
21152 if (last_emitted_file
)
21153 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
21155 fd
->emitted_number
= 1;
21156 last_emitted_file
= fd
;
21158 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21160 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
21161 output_quoted_string (asm_out_file
,
21162 remap_debug_filename (fd
->filename
));
21163 fputc ('\n', asm_out_file
);
21167 return fd
->emitted_number
;
21170 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21171 That generation should happen after function debug info has been
21172 generated. The value of the attribute is the constant value of ARG. */
21175 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
21177 die_arg_entry entry
;
21182 if (!tmpl_value_parm_die_table
)
21183 vec_alloc (tmpl_value_parm_die_table
, 32);
21187 vec_safe_push (tmpl_value_parm_die_table
, entry
);
21190 /* Return TRUE if T is an instance of generic type, FALSE
21194 generic_type_p (tree t
)
21196 if (t
== NULL_TREE
|| !TYPE_P (t
))
21198 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
21201 /* Schedule the generation of the generic parameter dies for the
21202 instance of generic type T. The proper generation itself is later
21203 done by gen_scheduled_generic_parms_dies. */
21206 schedule_generic_params_dies_gen (tree t
)
21208 if (!generic_type_p (t
))
21211 if (!generic_type_instances
)
21212 vec_alloc (generic_type_instances
, 256);
21214 vec_safe_push (generic_type_instances
, t
);
21217 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21218 by append_entry_to_tmpl_value_parm_die_table. This function must
21219 be called after function DIEs have been generated. */
21222 gen_remaining_tmpl_value_param_die_attribute (void)
21224 if (tmpl_value_parm_die_table
)
21229 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
21230 tree_add_const_value_attribute (e
->die
, e
->arg
);
21234 /* Generate generic parameters DIEs for instances of generic types
21235 that have been previously scheduled by
21236 schedule_generic_params_dies_gen. This function must be called
21237 after all the types of the CU have been laid out. */
21240 gen_scheduled_generic_parms_dies (void)
21245 if (!generic_type_instances
)
21248 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
21249 if (COMPLETE_TYPE_P (t
))
21250 gen_generic_params_dies (t
);
21254 /* Replace DW_AT_name for the decl with name. */
21257 dwarf2out_set_name (tree decl
, tree name
)
21263 die
= TYPE_SYMTAB_DIE (decl
);
21267 dname
= dwarf2_name (name
, 0);
21271 attr
= get_AT (die
, DW_AT_name
);
21274 struct indirect_string_node
*node
;
21276 node
= find_AT_string (dname
);
21277 /* replace the string. */
21278 attr
->dw_attr_val
.v
.val_str
= node
;
21282 add_name_attribute (die
, dname
);
21285 /* True if before or during processing of the first function being emitted. */
21286 static bool in_first_function_p
= true;
21287 /* True if loc_note during dwarf2out_var_location call might still be
21288 before first real instruction at address equal to .Ltext0. */
21289 static bool maybe_at_text_label_p
= true;
21290 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
21291 static unsigned int first_loclabel_num_not_at_text_label
;
21293 /* Called by the final INSN scan whenever we see a var location. We
21294 use it to drop labels in the right places, and throw the location in
21295 our lookup table. */
21298 dwarf2out_var_location (rtx loc_note
)
21300 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
21301 struct var_loc_node
*newloc
;
21302 rtx next_real
, next_note
;
21303 static const char *last_label
;
21304 static const char *last_postcall_label
;
21305 static bool last_in_cold_section_p
;
21306 static rtx expected_next_loc_note
;
21310 if (!NOTE_P (loc_note
))
21312 if (CALL_P (loc_note
))
21315 if (SIBLING_CALL_P (loc_note
))
21316 tail_call_site_count
++;
21321 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
21322 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
21325 /* Optimize processing a large consecutive sequence of location
21326 notes so we don't spend too much time in next_real_insn. If the
21327 next insn is another location note, remember the next_real_insn
21328 calculation for next time. */
21329 next_real
= cached_next_real_insn
;
21332 if (expected_next_loc_note
!= loc_note
)
21333 next_real
= NULL_RTX
;
21336 next_note
= NEXT_INSN (loc_note
);
21338 || INSN_DELETED_P (next_note
)
21339 || ! NOTE_P (next_note
)
21340 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
21341 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
21342 next_note
= NULL_RTX
;
21345 next_real
= next_real_insn (loc_note
);
21349 expected_next_loc_note
= next_note
;
21350 cached_next_real_insn
= next_real
;
21353 cached_next_real_insn
= NULL_RTX
;
21355 /* If there are no instructions which would be affected by this note,
21356 don't do anything. */
21358 && next_real
== NULL_RTX
21359 && !NOTE_DURING_CALL_P (loc_note
))
21362 if (next_real
== NULL_RTX
)
21363 next_real
= get_last_insn ();
21365 /* If there were any real insns between note we processed last time
21366 and this note (or if it is the first note), clear
21367 last_{,postcall_}label so that they are not reused this time. */
21368 if (last_var_location_insn
== NULL_RTX
21369 || last_var_location_insn
!= next_real
21370 || last_in_cold_section_p
!= in_cold_section_p
)
21373 last_postcall_label
= NULL
;
21378 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
21379 newloc
= add_var_loc_to_decl (decl
, loc_note
,
21380 NOTE_DURING_CALL_P (loc_note
)
21381 ? last_postcall_label
: last_label
);
21382 if (newloc
== NULL
)
21391 /* If there were no real insns between note we processed last time
21392 and this note, use the label we emitted last time. Otherwise
21393 create a new label and emit it. */
21394 if (last_label
== NULL
)
21396 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
21397 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
21399 last_label
= ggc_strdup (loclabel
);
21400 /* See if loclabel might be equal to .Ltext0. If yes,
21401 bump first_loclabel_num_not_at_text_label. */
21402 if (!have_multiple_function_sections
21403 && in_first_function_p
21404 && maybe_at_text_label_p
)
21406 static rtx last_start
;
21408 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
21409 if (insn
== last_start
)
21411 else if (!NONDEBUG_INSN_P (insn
))
21415 rtx body
= PATTERN (insn
);
21416 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
21418 /* Inline asm could occupy zero bytes. */
21419 else if (GET_CODE (body
) == ASM_INPUT
21420 || asm_noperands (body
) >= 0)
21422 #ifdef HAVE_attr_length
21423 else if (get_attr_min_length (insn
) == 0)
21428 /* Assume insn has non-zero length. */
21429 maybe_at_text_label_p
= false;
21433 if (maybe_at_text_label_p
)
21435 last_start
= loc_note
;
21436 first_loclabel_num_not_at_text_label
= loclabel_num
;
21443 struct call_arg_loc_node
*ca_loc
21444 = ggc_cleared_alloc
<call_arg_loc_node
> ();
21445 rtx prev
= prev_real_insn (loc_note
), x
;
21446 ca_loc
->call_arg_loc_note
= loc_note
;
21447 ca_loc
->next
= NULL
;
21448 ca_loc
->label
= last_label
;
21451 || (NONJUMP_INSN_P (prev
)
21452 && GET_CODE (PATTERN (prev
)) == SEQUENCE
21453 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
21454 if (!CALL_P (prev
))
21455 prev
= XVECEXP (PATTERN (prev
), 0, 0);
21456 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
21457 x
= get_call_rtx_from (PATTERN (prev
));
21460 x
= XEXP (XEXP (x
, 0), 0);
21461 if (GET_CODE (x
) == SYMBOL_REF
21462 && SYMBOL_REF_DECL (x
)
21463 && TREE_CODE (SYMBOL_REF_DECL (x
)) == FUNCTION_DECL
)
21464 ca_loc
->symbol_ref
= x
;
21466 ca_loc
->block
= insn_scope (prev
);
21467 if (call_arg_locations
)
21468 call_arg_loc_last
->next
= ca_loc
;
21470 call_arg_locations
= ca_loc
;
21471 call_arg_loc_last
= ca_loc
;
21473 else if (!NOTE_DURING_CALL_P (loc_note
))
21474 newloc
->label
= last_label
;
21477 if (!last_postcall_label
)
21479 sprintf (loclabel
, "%s-1", last_label
);
21480 last_postcall_label
= ggc_strdup (loclabel
);
21482 newloc
->label
= last_postcall_label
;
21485 last_var_location_insn
= next_real
;
21486 last_in_cold_section_p
= in_cold_section_p
;
21489 /* Note in one location list that text section has changed. */
21492 var_location_switch_text_section_1 (void **slot
, void *data ATTRIBUTE_UNUSED
)
21494 var_loc_list
*list
= (var_loc_list
*) *slot
;
21496 list
->last_before_switch
21497 = list
->last
->next
? list
->last
->next
: list
->last
;
21501 /* Note in all location lists that text section has changed. */
21504 var_location_switch_text_section (void)
21506 if (decl_loc_table
== NULL
)
21509 htab_traverse (decl_loc_table
, var_location_switch_text_section_1
, NULL
);
21512 /* Create a new line number table. */
21514 static dw_line_info_table
*
21515 new_line_info_table (void)
21517 dw_line_info_table
*table
;
21519 table
= ggc_cleared_alloc
<dw_line_info_table_struct
> ();
21520 table
->file_num
= 1;
21521 table
->line_num
= 1;
21522 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
21527 /* Lookup the "current" table into which we emit line info, so
21528 that we don't have to do it for every source line. */
21531 set_cur_line_info_table (section
*sec
)
21533 dw_line_info_table
*table
;
21535 if (sec
== text_section
)
21536 table
= text_section_line_info
;
21537 else if (sec
== cold_text_section
)
21539 table
= cold_text_section_line_info
;
21542 cold_text_section_line_info
= table
= new_line_info_table ();
21543 table
->end_label
= cold_end_label
;
21548 const char *end_label
;
21550 if (flag_reorder_blocks_and_partition
)
21552 if (in_cold_section_p
)
21553 end_label
= crtl
->subsections
.cold_section_end_label
;
21555 end_label
= crtl
->subsections
.hot_section_end_label
;
21559 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21560 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
21561 current_function_funcdef_no
);
21562 end_label
= ggc_strdup (label
);
21565 table
= new_line_info_table ();
21566 table
->end_label
= end_label
;
21568 vec_safe_push (separate_line_info
, table
);
21571 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21572 table
->is_stmt
= (cur_line_info_table
21573 ? cur_line_info_table
->is_stmt
21574 : DWARF_LINE_DEFAULT_IS_STMT_START
);
21575 cur_line_info_table
= table
;
21579 /* We need to reset the locations at the beginning of each
21580 function. We can't do this in the end_function hook, because the
21581 declarations that use the locations won't have been output when
21582 that hook is called. Also compute have_multiple_function_sections here. */
21585 dwarf2out_begin_function (tree fun
)
21587 section
*sec
= function_section (fun
);
21589 if (sec
!= text_section
)
21590 have_multiple_function_sections
= true;
21592 if (flag_reorder_blocks_and_partition
&& !cold_text_section
)
21594 gcc_assert (current_function_decl
== fun
);
21595 cold_text_section
= unlikely_text_section ();
21596 switch_to_section (cold_text_section
);
21597 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
21598 switch_to_section (sec
);
21601 dwarf2out_note_section_used ();
21602 call_site_count
= 0;
21603 tail_call_site_count
= 0;
21605 set_cur_line_info_table (sec
);
21608 /* Helper function of dwarf2out_end_function, called only after emitting
21609 the very first function into assembly. Check if some .debug_loc range
21610 might end with a .LVL* label that could be equal to .Ltext0.
21611 In that case we must force using absolute addresses in .debug_loc ranges,
21612 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
21613 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
21615 Set have_multiple_function_sections to true in that case and
21616 terminate htab traversal. */
21619 find_empty_loc_ranges_at_text_label (void **slot
, void *)
21621 var_loc_list
*entry
;
21622 struct var_loc_node
*node
;
21624 entry
= (var_loc_list
*) *slot
;
21625 node
= entry
->first
;
21626 if (node
&& node
->next
&& node
->next
->label
)
21629 const char *label
= node
->next
->label
;
21630 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
21632 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
21634 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
21635 if (strcmp (label
, loclabel
) == 0)
21637 have_multiple_function_sections
= true;
21645 /* Hook called after emitting a function into assembly.
21646 This does something only for the very first function emitted. */
21649 dwarf2out_end_function (unsigned int)
21651 if (in_first_function_p
21652 && !have_multiple_function_sections
21653 && first_loclabel_num_not_at_text_label
21655 htab_traverse (decl_loc_table
, find_empty_loc_ranges_at_text_label
,
21657 in_first_function_p
= false;
21658 maybe_at_text_label_p
= false;
21661 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
21664 push_dw_line_info_entry (dw_line_info_table
*table
,
21665 enum dw_line_info_opcode opcode
, unsigned int val
)
21667 dw_line_info_entry e
;
21670 vec_safe_push (table
->entries
, e
);
21673 /* Output a label to mark the beginning of a source code line entry
21674 and record information relating to this source line, in
21675 'line_info_table' for later output of the .debug_line section. */
21676 /* ??? The discriminator parameter ought to be unsigned. */
21679 dwarf2out_source_line (unsigned int line
, const char *filename
,
21680 int discriminator
, bool is_stmt
)
21682 unsigned int file_num
;
21683 dw_line_info_table
*table
;
21685 if (debug_info_level
< DINFO_LEVEL_TERSE
|| line
== 0)
21688 /* The discriminator column was added in dwarf4. Simplify the below
21689 by simply removing it if we're not supposed to output it. */
21690 if (dwarf_version
< 4 && dwarf_strict
)
21693 table
= cur_line_info_table
;
21694 file_num
= maybe_emit_file (lookup_filename (filename
));
21696 /* ??? TODO: Elide duplicate line number entries. Traditionally,
21697 the debugger has used the second (possibly duplicate) line number
21698 at the beginning of the function to mark the end of the prologue.
21699 We could eliminate any other duplicates within the function. For
21700 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
21701 that second line number entry. */
21702 /* Recall that this end-of-prologue indication is *not* the same thing
21703 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
21704 to which the hook corresponds, follows the last insn that was
21705 emitted by gen_prologue. What we need is to precede the first insn
21706 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
21707 insn that corresponds to something the user wrote. These may be
21708 very different locations once scheduling is enabled. */
21710 if (0 && file_num
== table
->file_num
21711 && line
== table
->line_num
21712 && discriminator
== table
->discrim_num
21713 && is_stmt
== table
->is_stmt
)
21716 switch_to_section (current_function_section ());
21718 /* If requested, emit something human-readable. */
21719 if (flag_debug_asm
)
21720 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
, filename
, line
);
21722 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21724 /* Emit the .loc directive understood by GNU as. */
21725 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
21726 file_num, line, is_stmt, discriminator */
21727 fputs ("\t.loc ", asm_out_file
);
21728 fprint_ul (asm_out_file
, file_num
);
21729 putc (' ', asm_out_file
);
21730 fprint_ul (asm_out_file
, line
);
21731 putc (' ', asm_out_file
);
21732 putc ('0', asm_out_file
);
21734 if (is_stmt
!= table
->is_stmt
)
21736 fputs (" is_stmt ", asm_out_file
);
21737 putc (is_stmt
? '1' : '0', asm_out_file
);
21739 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
21741 gcc_assert (discriminator
> 0);
21742 fputs (" discriminator ", asm_out_file
);
21743 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
21745 putc ('\n', asm_out_file
);
21749 unsigned int label_num
= ++line_info_label_num
;
21751 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
21753 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
21754 if (file_num
!= table
->file_num
)
21755 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
21756 if (discriminator
!= table
->discrim_num
)
21757 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
21758 if (is_stmt
!= table
->is_stmt
)
21759 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
21760 push_dw_line_info_entry (table
, LI_set_line
, line
);
21763 table
->file_num
= file_num
;
21764 table
->line_num
= line
;
21765 table
->discrim_num
= discriminator
;
21766 table
->is_stmt
= is_stmt
;
21767 table
->in_use
= true;
21770 /* Record the beginning of a new source file. */
21773 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
21775 if (flag_eliminate_dwarf2_dups
)
21777 /* Record the beginning of the file for break_out_includes. */
21778 dw_die_ref bincl_die
;
21780 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die (), NULL
);
21781 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
21784 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21787 e
.code
= DW_MACINFO_start_file
;
21789 e
.info
= ggc_strdup (filename
);
21790 vec_safe_push (macinfo_table
, e
);
21794 /* Record the end of a source file. */
21797 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
21799 if (flag_eliminate_dwarf2_dups
)
21800 /* Record the end of the file for break_out_includes. */
21801 new_die (DW_TAG_GNU_EINCL
, comp_unit_die (), NULL
);
21803 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21806 e
.code
= DW_MACINFO_end_file
;
21809 vec_safe_push (macinfo_table
, e
);
21813 /* Called from debug_define in toplev.c. The `buffer' parameter contains
21814 the tail part of the directive line, i.e. the part which is past the
21815 initial whitespace, #, whitespace, directive-name, whitespace part. */
21818 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
21819 const char *buffer ATTRIBUTE_UNUSED
)
21821 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21824 /* Insert a dummy first entry to be able to optimize the whole
21825 predefined macro block using DW_MACRO_GNU_transparent_include. */
21826 if (macinfo_table
->is_empty () && lineno
<= 1)
21831 vec_safe_push (macinfo_table
, e
);
21833 e
.code
= DW_MACINFO_define
;
21835 e
.info
= ggc_strdup (buffer
);
21836 vec_safe_push (macinfo_table
, e
);
21840 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
21841 the tail part of the directive line, i.e. the part which is past the
21842 initial whitespace, #, whitespace, directive-name, whitespace part. */
21845 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
21846 const char *buffer ATTRIBUTE_UNUSED
)
21848 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21851 /* Insert a dummy first entry to be able to optimize the whole
21852 predefined macro block using DW_MACRO_GNU_transparent_include. */
21853 if (macinfo_table
->is_empty () && lineno
<= 1)
21858 vec_safe_push (macinfo_table
, e
);
21860 e
.code
= DW_MACINFO_undef
;
21862 e
.info
= ggc_strdup (buffer
);
21863 vec_safe_push (macinfo_table
, e
);
21867 /* Helpers to manipulate hash table of CUs. */
21869 struct macinfo_entry_hasher
: typed_noop_remove
<macinfo_entry
>
21871 typedef macinfo_entry value_type
;
21872 typedef macinfo_entry compare_type
;
21873 static inline hashval_t
hash (const value_type
*);
21874 static inline bool equal (const value_type
*, const compare_type
*);
21878 macinfo_entry_hasher::hash (const value_type
*entry
)
21880 return htab_hash_string (entry
->info
);
21884 macinfo_entry_hasher::equal (const value_type
*entry1
,
21885 const compare_type
*entry2
)
21887 return !strcmp (entry1
->info
, entry2
->info
);
21890 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
21892 /* Output a single .debug_macinfo entry. */
21895 output_macinfo_op (macinfo_entry
*ref
)
21899 struct indirect_string_node
*node
;
21900 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21901 struct dwarf_file_data
*fd
;
21905 case DW_MACINFO_start_file
:
21906 fd
= lookup_filename (ref
->info
);
21907 file_num
= maybe_emit_file (fd
);
21908 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
21909 dw2_asm_output_data_uleb128 (ref
->lineno
,
21910 "Included from line number %lu",
21911 (unsigned long) ref
->lineno
);
21912 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
21914 case DW_MACINFO_end_file
:
21915 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
21917 case DW_MACINFO_define
:
21918 case DW_MACINFO_undef
:
21919 len
= strlen (ref
->info
) + 1;
21921 && len
> DWARF_OFFSET_SIZE
21922 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
21923 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
21925 ref
->code
= ref
->code
== DW_MACINFO_define
21926 ? DW_MACRO_GNU_define_indirect
21927 : DW_MACRO_GNU_undef_indirect
;
21928 output_macinfo_op (ref
);
21931 dw2_asm_output_data (1, ref
->code
,
21932 ref
->code
== DW_MACINFO_define
21933 ? "Define macro" : "Undefine macro");
21934 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21935 (unsigned long) ref
->lineno
);
21936 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
21938 case DW_MACRO_GNU_define_indirect
:
21939 case DW_MACRO_GNU_undef_indirect
:
21940 node
= find_AT_string (ref
->info
);
21942 && ((node
->form
== DW_FORM_strp
)
21943 || (node
->form
== DW_FORM_GNU_str_index
)));
21944 dw2_asm_output_data (1, ref
->code
,
21945 ref
->code
== DW_MACRO_GNU_define_indirect
21946 ? "Define macro indirect"
21947 : "Undefine macro indirect");
21948 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21949 (unsigned long) ref
->lineno
);
21950 if (node
->form
== DW_FORM_strp
)
21951 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
21952 debug_str_section
, "The macro: \"%s\"",
21955 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
21958 case DW_MACRO_GNU_transparent_include
:
21959 dw2_asm_output_data (1, ref
->code
, "Transparent include");
21960 ASM_GENERATE_INTERNAL_LABEL (label
,
21961 DEBUG_MACRO_SECTION_LABEL
, ref
->lineno
);
21962 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
21965 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
21966 ASM_COMMENT_START
, (unsigned long) ref
->code
);
21971 /* Attempt to make a sequence of define/undef macinfo ops shareable with
21972 other compilation unit .debug_macinfo sections. IDX is the first
21973 index of a define/undef, return the number of ops that should be
21974 emitted in a comdat .debug_macinfo section and emit
21975 a DW_MACRO_GNU_transparent_include entry referencing it.
21976 If the define/undef entry should be emitted normally, return 0. */
21979 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
21980 macinfo_hash_type
**macinfo_htab
)
21982 macinfo_entry
*first
, *second
, *cur
, *inc
;
21983 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
21984 unsigned char checksum
[16];
21985 struct md5_ctx ctx
;
21986 char *grp_name
, *tail
;
21988 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
21989 macinfo_entry
**slot
;
21991 first
= &(*macinfo_table
)[idx
];
21992 second
= &(*macinfo_table
)[idx
+ 1];
21994 /* Optimize only if there are at least two consecutive define/undef ops,
21995 and either all of them are before first DW_MACINFO_start_file
21996 with lineno {0,1} (i.e. predefined macro block), or all of them are
21997 in some included header file. */
21998 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
22000 if (vec_safe_is_empty (files
))
22002 if (first
->lineno
> 1 || second
->lineno
> 1)
22005 else if (first
->lineno
== 0)
22008 /* Find the last define/undef entry that can be grouped together
22009 with first and at the same time compute md5 checksum of their
22010 codes, linenumbers and strings. */
22011 md5_init_ctx (&ctx
);
22012 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
22013 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
22015 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
22019 unsigned char code
= cur
->code
;
22020 md5_process_bytes (&code
, 1, &ctx
);
22021 checksum_uleb128 (cur
->lineno
, &ctx
);
22022 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
22024 md5_finish_ctx (&ctx
, checksum
);
22027 /* From the containing include filename (if any) pick up just
22028 usable characters from its basename. */
22029 if (vec_safe_is_empty (files
))
22032 base
= lbasename (files
->last ().info
);
22033 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
22034 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
22035 encoded_filename_len
++;
22036 /* Count . at the end. */
22037 if (encoded_filename_len
)
22038 encoded_filename_len
++;
22040 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
22041 linebuf_len
= strlen (linebuf
);
22043 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
22044 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
22046 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
22047 tail
= grp_name
+ 4;
22048 if (encoded_filename_len
)
22050 for (i
= 0; base
[i
]; i
++)
22051 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
22055 memcpy (tail
, linebuf
, linebuf_len
);
22056 tail
+= linebuf_len
;
22058 for (i
= 0; i
< 16; i
++)
22059 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
22061 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
22062 in the empty vector entry before the first define/undef. */
22063 inc
= &(*macinfo_table
)[idx
- 1];
22064 inc
->code
= DW_MACRO_GNU_transparent_include
;
22066 inc
->info
= ggc_strdup (grp_name
);
22067 if (!*macinfo_htab
)
22068 *macinfo_htab
= new macinfo_hash_type (10);
22069 /* Avoid emitting duplicates. */
22070 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
22075 /* If such an entry has been used before, just emit
22076 a DW_MACRO_GNU_transparent_include op. */
22078 output_macinfo_op (inc
);
22079 /* And clear all macinfo_entry in the range to avoid emitting them
22080 in the second pass. */
22081 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
22090 inc
->lineno
= (*macinfo_htab
)->elements ();
22091 output_macinfo_op (inc
);
22096 /* Save any strings needed by the macinfo table in the debug str
22097 table. All strings must be collected into the table by the time
22098 index_string is called. */
22101 save_macinfo_strings (void)
22105 macinfo_entry
*ref
;
22107 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
22111 /* Match the logic in output_macinfo_op to decide on
22112 indirect strings. */
22113 case DW_MACINFO_define
:
22114 case DW_MACINFO_undef
:
22115 len
= strlen (ref
->info
) + 1;
22117 && len
> DWARF_OFFSET_SIZE
22118 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22119 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
22120 set_indirect_string (find_AT_string (ref
->info
));
22122 case DW_MACRO_GNU_define_indirect
:
22123 case DW_MACRO_GNU_undef_indirect
:
22124 set_indirect_string (find_AT_string (ref
->info
));
22132 /* Output macinfo section(s). */
22135 output_macinfo (void)
22138 unsigned long length
= vec_safe_length (macinfo_table
);
22139 macinfo_entry
*ref
;
22140 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
22141 macinfo_hash_type
*macinfo_htab
= NULL
;
22146 /* output_macinfo* uses these interchangeably. */
22147 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_GNU_define
22148 && (int) DW_MACINFO_undef
== (int) DW_MACRO_GNU_undef
22149 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_GNU_start_file
22150 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_GNU_end_file
);
22152 /* For .debug_macro emit the section header. */
22155 dw2_asm_output_data (2, 4, "DWARF macro version number");
22156 if (DWARF_OFFSET_SIZE
== 8)
22157 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
22159 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
22160 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
22161 (!dwarf_split_debug_info
? debug_line_section_label
22162 : debug_skeleton_line_section_label
),
22163 debug_line_section
, NULL
);
22166 /* In the first loop, it emits the primary .debug_macinfo section
22167 and after each emitted op the macinfo_entry is cleared.
22168 If a longer range of define/undef ops can be optimized using
22169 DW_MACRO_GNU_transparent_include, the
22170 DW_MACRO_GNU_transparent_include op is emitted and kept in
22171 the vector before the first define/undef in the range and the
22172 whole range of define/undef ops is not emitted and kept. */
22173 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22177 case DW_MACINFO_start_file
:
22178 vec_safe_push (files
, *ref
);
22180 case DW_MACINFO_end_file
:
22181 if (!vec_safe_is_empty (files
))
22184 case DW_MACINFO_define
:
22185 case DW_MACINFO_undef
:
22187 && HAVE_COMDAT_GROUP
22188 && vec_safe_length (files
) != 1
22191 && (*macinfo_table
)[i
- 1].code
== 0)
22193 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
22202 /* A dummy entry may be inserted at the beginning to be able
22203 to optimize the whole block of predefined macros. */
22209 output_macinfo_op (ref
);
22217 delete macinfo_htab
;
22218 macinfo_htab
= NULL
;
22220 /* If any DW_MACRO_GNU_transparent_include were used, on those
22221 DW_MACRO_GNU_transparent_include entries terminate the
22222 current chain and switch to a new comdat .debug_macinfo
22223 section and emit the define/undef entries within it. */
22224 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22229 case DW_MACRO_GNU_transparent_include
:
22231 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
22232 tree comdat_key
= get_identifier (ref
->info
);
22233 /* Terminate the previous .debug_macinfo section. */
22234 dw2_asm_output_data (1, 0, "End compilation unit");
22235 targetm
.asm_out
.named_section (DEBUG_MACRO_SECTION
,
22237 | SECTION_LINKONCE
,
22239 ASM_GENERATE_INTERNAL_LABEL (label
,
22240 DEBUG_MACRO_SECTION_LABEL
,
22242 ASM_OUTPUT_LABEL (asm_out_file
, label
);
22245 dw2_asm_output_data (2, 4, "DWARF macro version number");
22246 if (DWARF_OFFSET_SIZE
== 8)
22247 dw2_asm_output_data (1, 1, "Flags: 64-bit");
22249 dw2_asm_output_data (1, 0, "Flags: 32-bit");
22252 case DW_MACINFO_define
:
22253 case DW_MACINFO_undef
:
22254 output_macinfo_op (ref
);
22259 gcc_unreachable ();
22263 /* Set up for Dwarf output at the start of compilation. */
22266 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
22268 /* Allocate the file_table. */
22269 file_table
= htab_create_ggc (50, file_table_hash
,
22270 file_table_eq
, NULL
);
22272 /* Allocate the decl_die_table. */
22273 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
22274 decl_die_table_eq
, NULL
);
22276 /* Allocate the decl_loc_table. */
22277 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
22278 decl_loc_table_eq
, NULL
);
22280 /* Allocate the cached_dw_loc_list_table. */
22281 cached_dw_loc_list_table
22282 = htab_create_ggc (10, cached_dw_loc_list_table_hash
,
22283 cached_dw_loc_list_table_eq
, NULL
);
22285 /* Allocate the initial hunk of the decl_scope_table. */
22286 vec_alloc (decl_scope_table
, 256);
22288 /* Allocate the initial hunk of the abbrev_die_table. */
22289 abbrev_die_table
= ggc_cleared_vec_alloc
<dw_die_ref
>
22290 (ABBREV_DIE_TABLE_INCREMENT
);
22291 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
22292 /* Zero-th entry is allocated, but unused. */
22293 abbrev_die_table_in_use
= 1;
22295 /* Allocate the pubtypes and pubnames vectors. */
22296 vec_alloc (pubname_table
, 32);
22297 vec_alloc (pubtype_table
, 32);
22299 vec_alloc (incomplete_types
, 64);
22301 vec_alloc (used_rtx_array
, 32);
22303 if (!dwarf_split_debug_info
)
22305 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
22306 SECTION_DEBUG
, NULL
);
22307 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22308 SECTION_DEBUG
, NULL
);
22309 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
22310 SECTION_DEBUG
, NULL
);
22314 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
22315 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22316 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
22317 SECTION_DEBUG
| SECTION_EXCLUDE
,
22319 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
22320 SECTION_DEBUG
, NULL
);
22321 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
22322 SECTION_DEBUG
, NULL
);
22323 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22324 SECTION_DEBUG
, NULL
);
22325 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
22326 DEBUG_SKELETON_ABBREV_SECTION_LABEL
, 0);
22328 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
22329 the main .o, but the skeleton_line goes into the split off dwo. */
22330 debug_skeleton_line_section
22331 = get_section (DEBUG_DWO_LINE_SECTION
,
22332 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22333 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
22334 DEBUG_SKELETON_LINE_SECTION_LABEL
, 0);
22335 debug_str_offsets_section
= get_section (DEBUG_STR_OFFSETS_SECTION
,
22336 SECTION_DEBUG
| SECTION_EXCLUDE
,
22338 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
22339 DEBUG_SKELETON_INFO_SECTION_LABEL
, 0);
22340 debug_loc_section
= get_section (DEBUG_DWO_LOC_SECTION
,
22341 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22342 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
22343 DEBUG_STR_DWO_SECTION_FLAGS
, NULL
);
22345 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
22346 SECTION_DEBUG
, NULL
);
22347 debug_macinfo_section
= get_section (dwarf_strict
22348 ? DEBUG_MACINFO_SECTION
22349 : DEBUG_MACRO_SECTION
,
22350 DEBUG_MACRO_SECTION_FLAGS
, NULL
);
22351 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
22352 SECTION_DEBUG
, NULL
);
22353 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
22354 SECTION_DEBUG
, NULL
);
22355 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
22356 SECTION_DEBUG
, NULL
);
22357 debug_str_section
= get_section (DEBUG_STR_SECTION
,
22358 DEBUG_STR_SECTION_FLAGS
, NULL
);
22359 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
22360 SECTION_DEBUG
, NULL
);
22361 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
22362 SECTION_DEBUG
, NULL
);
22364 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
22365 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
22366 DEBUG_ABBREV_SECTION_LABEL
, 0);
22367 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
22368 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
22369 COLD_TEXT_SECTION_LABEL
, 0);
22370 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
22372 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
22373 DEBUG_INFO_SECTION_LABEL
, 0);
22374 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
22375 DEBUG_LINE_SECTION_LABEL
, 0);
22376 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
22377 DEBUG_RANGES_SECTION_LABEL
, 0);
22378 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
22379 DEBUG_ADDR_SECTION_LABEL
, 0);
22380 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
22382 ? DEBUG_MACINFO_SECTION_LABEL
22383 : DEBUG_MACRO_SECTION_LABEL
, 0);
22384 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
, 0);
22386 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22387 vec_alloc (macinfo_table
, 64);
22389 switch_to_section (text_section
);
22390 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
22392 /* Make sure the line number table for .text always exists. */
22393 text_section_line_info
= new_line_info_table ();
22394 text_section_line_info
->end_label
= text_end_label
;
22397 /* Called before compile () starts outputtting functions, variables
22398 and toplevel asms into assembly. */
22401 dwarf2out_assembly_start (void)
22403 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
22404 && dwarf2out_do_cfi_asm ()
22405 && (!(flag_unwind_tables
|| flag_exceptions
)
22406 || targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
))
22407 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
22410 /* A helper function for dwarf2out_finish called through
22411 htab_traverse. Assign a string its index. All strings must be
22412 collected into the table by the time index_string is called,
22413 because the indexing code relies on htab_traverse to traverse nodes
22414 in the same order for each run. */
22417 index_string (void **h
, void *v
)
22419 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22420 unsigned int *index
= (unsigned int *) v
;
22422 find_string_form (node
);
22423 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22425 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
22426 node
->index
= *index
;
22432 /* A helper function for output_indirect_strings called through
22433 htab_traverse. Output the offset to a string and update the
22437 output_index_string_offset (void **h
, void *v
)
22439 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22440 unsigned int *offset
= (unsigned int *) v
;
22442 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22444 /* Assert that this node has been assigned an index. */
22445 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
22446 && node
->index
!= NOT_INDEXED
);
22447 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
22448 "indexed string 0x%x: %s", node
->index
, node
->str
);
22449 *offset
+= strlen (node
->str
) + 1;
22454 /* A helper function for dwarf2out_finish called through
22455 htab_traverse. Output the indexed string. */
22458 output_index_string (void **h
, void *v
)
22460 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22461 unsigned int *cur_idx
= (unsigned int *) v
;
22463 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22465 /* Assert that the strings are output in the same order as their
22466 indexes were assigned. */
22467 gcc_assert (*cur_idx
== node
->index
);
22468 assemble_string (node
->str
, strlen (node
->str
) + 1);
22474 /* A helper function for dwarf2out_finish called through
22475 htab_traverse. Emit one queued .debug_str string. */
22478 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
22480 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22482 node
->form
= find_string_form (node
);
22483 if (node
->form
== DW_FORM_strp
&& node
->refcount
> 0)
22485 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
22486 assemble_string (node
->str
, strlen (node
->str
) + 1);
22492 /* Output the indexed string table. */
22495 output_indirect_strings (void)
22497 switch_to_section (debug_str_section
);
22498 if (!dwarf_split_debug_info
)
22499 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
22502 unsigned int offset
= 0;
22503 unsigned int cur_idx
= 0;
22505 htab_traverse (skeleton_debug_str_hash
, output_indirect_string
, NULL
);
22507 switch_to_section (debug_str_offsets_section
);
22508 htab_traverse_noresize (debug_str_hash
,
22509 output_index_string_offset
,
22511 switch_to_section (debug_str_dwo_section
);
22512 htab_traverse_noresize (debug_str_hash
,
22513 output_index_string
,
22518 /* Callback for htab_traverse to assign an index to an entry in the
22519 table, and to write that entry to the .debug_addr section. */
22522 output_addr_table_entry (void **slot
, void *data
)
22524 addr_table_entry
*entry
= (addr_table_entry
*) *slot
;
22525 unsigned int *cur_index
= (unsigned int *)data
;
22527 if (entry
->refcount
== 0)
22529 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
22530 || entry
->index
== NOT_INDEXED
);
22534 gcc_assert (entry
->index
== *cur_index
);
22537 switch (entry
->kind
)
22540 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
22541 "0x%x", entry
->index
);
22543 case ate_kind_rtx_dtprel
:
22544 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
22545 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
22548 fputc ('\n', asm_out_file
);
22550 case ate_kind_label
:
22551 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
22552 "0x%x", entry
->index
);
22555 gcc_unreachable ();
22560 /* Produce the .debug_addr section. */
22563 output_addr_table (void)
22565 unsigned int index
= 0;
22566 if (addr_index_table
== NULL
|| htab_size (addr_index_table
) == 0)
22569 switch_to_section (debug_addr_section
);
22570 htab_traverse_noresize (addr_index_table
, output_addr_table_entry
, &index
);
22573 #if ENABLE_ASSERT_CHECKING
22574 /* Verify that all marks are clear. */
22577 verify_marks_clear (dw_die_ref die
)
22581 gcc_assert (! die
->die_mark
);
22582 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
22584 #endif /* ENABLE_ASSERT_CHECKING */
22586 /* Clear the marks for a die and its children.
22587 Be cool if the mark isn't set. */
22590 prune_unmark_dies (dw_die_ref die
)
22596 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
22599 /* Given DIE that we're marking as used, find any other dies
22600 it references as attributes and mark them as used. */
22603 prune_unused_types_walk_attribs (dw_die_ref die
)
22608 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22610 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
22612 /* A reference to another DIE.
22613 Make sure that it will get emitted.
22614 If it was broken out into a comdat group, don't follow it. */
22615 if (! AT_ref (a
)->comdat_type_p
22616 || a
->dw_attr
== DW_AT_specification
)
22617 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
22619 /* Set the string's refcount to 0 so that prune_unused_types_mark
22620 accounts properly for it. */
22621 if (AT_class (a
) == dw_val_class_str
)
22622 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
22626 /* Mark the generic parameters and arguments children DIEs of DIE. */
22629 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
22633 if (die
== NULL
|| die
->die_child
== NULL
)
22635 c
= die
->die_child
;
22638 if (is_template_parameter (c
))
22639 prune_unused_types_mark (c
, 1);
22641 } while (c
&& c
!= die
->die_child
);
22644 /* Mark DIE as being used. If DOKIDS is true, then walk down
22645 to DIE's children. */
22648 prune_unused_types_mark (dw_die_ref die
, int dokids
)
22652 if (die
->die_mark
== 0)
22654 /* We haven't done this node yet. Mark it as used. */
22656 /* If this is the DIE of a generic type instantiation,
22657 mark the children DIEs that describe its generic parms and
22659 prune_unused_types_mark_generic_parms_dies (die
);
22661 /* We also have to mark its parents as used.
22662 (But we don't want to mark our parent's kids due to this,
22663 unless it is a class.) */
22664 if (die
->die_parent
)
22665 prune_unused_types_mark (die
->die_parent
,
22666 class_scope_p (die
->die_parent
));
22668 /* Mark any referenced nodes. */
22669 prune_unused_types_walk_attribs (die
);
22671 /* If this node is a specification,
22672 also mark the definition, if it exists. */
22673 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
22674 prune_unused_types_mark (die
->die_definition
, 1);
22677 if (dokids
&& die
->die_mark
!= 2)
22679 /* We need to walk the children, but haven't done so yet.
22680 Remember that we've walked the kids. */
22683 /* If this is an array type, we need to make sure our
22684 kids get marked, even if they're types. If we're
22685 breaking out types into comdat sections, do this
22686 for all type definitions. */
22687 if (die
->die_tag
== DW_TAG_array_type
22688 || (use_debug_types
22689 && is_type_die (die
) && ! is_declaration_die (die
)))
22690 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
22692 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22696 /* For local classes, look if any static member functions were emitted
22697 and if so, mark them. */
22700 prune_unused_types_walk_local_classes (dw_die_ref die
)
22704 if (die
->die_mark
== 2)
22707 switch (die
->die_tag
)
22709 case DW_TAG_structure_type
:
22710 case DW_TAG_union_type
:
22711 case DW_TAG_class_type
:
22714 case DW_TAG_subprogram
:
22715 if (!get_AT_flag (die
, DW_AT_declaration
)
22716 || die
->die_definition
!= NULL
)
22717 prune_unused_types_mark (die
, 1);
22724 /* Mark children. */
22725 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
22728 /* Walk the tree DIE and mark types that we actually use. */
22731 prune_unused_types_walk (dw_die_ref die
)
22735 /* Don't do anything if this node is already marked and
22736 children have been marked as well. */
22737 if (die
->die_mark
== 2)
22740 switch (die
->die_tag
)
22742 case DW_TAG_structure_type
:
22743 case DW_TAG_union_type
:
22744 case DW_TAG_class_type
:
22745 if (die
->die_perennial_p
)
22748 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
22749 if (c
->die_tag
== DW_TAG_subprogram
)
22752 /* Finding used static member functions inside of classes
22753 is needed just for local classes, because for other classes
22754 static member function DIEs with DW_AT_specification
22755 are emitted outside of the DW_TAG_*_type. If we ever change
22756 it, we'd need to call this even for non-local classes. */
22758 prune_unused_types_walk_local_classes (die
);
22760 /* It's a type node --- don't mark it. */
22763 case DW_TAG_const_type
:
22764 case DW_TAG_packed_type
:
22765 case DW_TAG_pointer_type
:
22766 case DW_TAG_reference_type
:
22767 case DW_TAG_rvalue_reference_type
:
22768 case DW_TAG_volatile_type
:
22769 case DW_TAG_typedef
:
22770 case DW_TAG_array_type
:
22771 case DW_TAG_interface_type
:
22772 case DW_TAG_friend
:
22773 case DW_TAG_variant_part
:
22774 case DW_TAG_enumeration_type
:
22775 case DW_TAG_subroutine_type
:
22776 case DW_TAG_string_type
:
22777 case DW_TAG_set_type
:
22778 case DW_TAG_subrange_type
:
22779 case DW_TAG_ptr_to_member_type
:
22780 case DW_TAG_file_type
:
22781 if (die
->die_perennial_p
)
22784 /* It's a type node --- don't mark it. */
22788 /* Mark everything else. */
22792 if (die
->die_mark
== 0)
22796 /* Now, mark any dies referenced from here. */
22797 prune_unused_types_walk_attribs (die
);
22802 /* Mark children. */
22803 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22806 /* Increment the string counts on strings referred to from DIE's
22810 prune_unused_types_update_strings (dw_die_ref die
)
22815 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22816 if (AT_class (a
) == dw_val_class_str
)
22818 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
22820 /* Avoid unnecessarily putting strings that are used less than
22821 twice in the hash table. */
22823 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
22826 slot
= htab_find_slot_with_hash (debug_str_hash
, s
->str
,
22827 htab_hash_string (s
->str
),
22829 gcc_assert (*slot
== NULL
);
22835 /* Remove from the tree DIE any dies that aren't marked. */
22838 prune_unused_types_prune (dw_die_ref die
)
22842 gcc_assert (die
->die_mark
);
22843 prune_unused_types_update_strings (die
);
22845 if (! die
->die_child
)
22848 c
= die
->die_child
;
22850 dw_die_ref prev
= c
;
22851 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
22852 if (c
== die
->die_child
)
22854 /* No marked children between 'prev' and the end of the list. */
22856 /* No marked children at all. */
22857 die
->die_child
= NULL
;
22860 prev
->die_sib
= c
->die_sib
;
22861 die
->die_child
= prev
;
22866 if (c
!= prev
->die_sib
)
22868 prune_unused_types_prune (c
);
22869 } while (c
!= die
->die_child
);
22872 /* Remove dies representing declarations that we never use. */
22875 prune_unused_types (void)
22878 limbo_die_node
*node
;
22879 comdat_type_node
*ctnode
;
22881 dw_die_ref base_type
;
22883 #if ENABLE_ASSERT_CHECKING
22884 /* All the marks should already be clear. */
22885 verify_marks_clear (comp_unit_die ());
22886 for (node
= limbo_die_list
; node
; node
= node
->next
)
22887 verify_marks_clear (node
->die
);
22888 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22889 verify_marks_clear (ctnode
->root_die
);
22890 #endif /* ENABLE_ASSERT_CHECKING */
22892 /* Mark types that are used in global variables. */
22893 premark_types_used_by_global_vars ();
22895 /* Set the mark on nodes that are actually used. */
22896 prune_unused_types_walk (comp_unit_die ());
22897 for (node
= limbo_die_list
; node
; node
= node
->next
)
22898 prune_unused_types_walk (node
->die
);
22899 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22901 prune_unused_types_walk (ctnode
->root_die
);
22902 prune_unused_types_mark (ctnode
->type_die
, 1);
22905 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
22906 are unusual in that they are pubnames that are the children of pubtypes.
22907 They should only be marked via their parent DW_TAG_enumeration_type die,
22908 not as roots in themselves. */
22909 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
22910 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
22911 prune_unused_types_mark (pub
->die
, 1);
22912 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
22913 prune_unused_types_mark (base_type
, 1);
22915 if (debug_str_hash
)
22916 htab_empty (debug_str_hash
);
22917 if (skeleton_debug_str_hash
)
22918 htab_empty (skeleton_debug_str_hash
);
22919 prune_unused_types_prune (comp_unit_die ());
22920 for (node
= limbo_die_list
; node
; node
= node
->next
)
22921 prune_unused_types_prune (node
->die
);
22922 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22923 prune_unused_types_prune (ctnode
->root_die
);
22925 /* Leave the marks clear. */
22926 prune_unmark_dies (comp_unit_die ());
22927 for (node
= limbo_die_list
; node
; node
= node
->next
)
22928 prune_unmark_dies (node
->die
);
22929 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22930 prune_unmark_dies (ctnode
->root_die
);
22933 /* Set the parameter to true if there are any relative pathnames in
22936 file_table_relative_p (void ** slot
, void *param
)
22938 bool *p
= (bool *) param
;
22939 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
22940 if (!IS_ABSOLUTE_PATH (d
->filename
))
22948 /* Helpers to manipulate hash table of comdat type units. */
22950 struct comdat_type_hasher
: typed_noop_remove
<comdat_type_node
>
22952 typedef comdat_type_node value_type
;
22953 typedef comdat_type_node compare_type
;
22954 static inline hashval_t
hash (const value_type
*);
22955 static inline bool equal (const value_type
*, const compare_type
*);
22959 comdat_type_hasher::hash (const value_type
*type_node
)
22962 memcpy (&h
, type_node
->signature
, sizeof (h
));
22967 comdat_type_hasher::equal (const value_type
*type_node_1
,
22968 const compare_type
*type_node_2
)
22970 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
22971 DWARF_TYPE_SIGNATURE_SIZE
));
22974 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
22975 to the location it would have been added, should we know its
22976 DECL_ASSEMBLER_NAME when we added other attributes. This will
22977 probably improve compactness of debug info, removing equivalent
22978 abbrevs, and hide any differences caused by deferring the
22979 computation of the assembler name, triggered by e.g. PCH. */
22982 move_linkage_attr (dw_die_ref die
)
22984 unsigned ix
= vec_safe_length (die
->die_attr
);
22985 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
22987 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
22988 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
22992 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
22994 if (prev
->dw_attr
== DW_AT_decl_line
|| prev
->dw_attr
== DW_AT_name
)
22998 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
23000 die
->die_attr
->pop ();
23001 die
->die_attr
->quick_insert (ix
, linkage
);
23005 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
23006 referenced from typed stack ops and count how often they are used. */
23009 mark_base_types (dw_loc_descr_ref loc
)
23011 dw_die_ref base_type
= NULL
;
23013 for (; loc
; loc
= loc
->dw_loc_next
)
23015 switch (loc
->dw_loc_opc
)
23017 case DW_OP_GNU_regval_type
:
23018 case DW_OP_GNU_deref_type
:
23019 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
23021 case DW_OP_GNU_convert
:
23022 case DW_OP_GNU_reinterpret
:
23023 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
23026 case DW_OP_GNU_const_type
:
23027 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23029 case DW_OP_GNU_entry_value
:
23030 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
23035 gcc_assert (base_type
->die_parent
== comp_unit_die ());
23036 if (base_type
->die_mark
)
23037 base_type
->die_mark
++;
23040 base_types
.safe_push (base_type
);
23041 base_type
->die_mark
= 1;
23046 /* Comparison function for sorting marked base types. */
23049 base_type_cmp (const void *x
, const void *y
)
23051 dw_die_ref dx
= *(const dw_die_ref
*) x
;
23052 dw_die_ref dy
= *(const dw_die_ref
*) y
;
23053 unsigned int byte_size1
, byte_size2
;
23054 unsigned int encoding1
, encoding2
;
23055 if (dx
->die_mark
> dy
->die_mark
)
23057 if (dx
->die_mark
< dy
->die_mark
)
23059 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
23060 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
23061 if (byte_size1
< byte_size2
)
23063 if (byte_size1
> byte_size2
)
23065 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
23066 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
23067 if (encoding1
< encoding2
)
23069 if (encoding1
> encoding2
)
23074 /* Move base types marked by mark_base_types as early as possible
23075 in the CU, sorted by decreasing usage count both to make the
23076 uleb128 references as small as possible and to make sure they
23077 will have die_offset already computed by calc_die_sizes when
23078 sizes of typed stack loc ops is computed. */
23081 move_marked_base_types (void)
23084 dw_die_ref base_type
, die
, c
;
23086 if (base_types
.is_empty ())
23089 /* Sort by decreasing usage count, they will be added again in that
23091 base_types
.qsort (base_type_cmp
);
23092 die
= comp_unit_die ();
23093 c
= die
->die_child
;
23096 dw_die_ref prev
= c
;
23098 while (c
->die_mark
)
23100 remove_child_with_prev (c
, prev
);
23101 /* As base types got marked, there must be at least
23102 one node other than DW_TAG_base_type. */
23103 gcc_assert (c
!= c
->die_sib
);
23107 while (c
!= die
->die_child
);
23108 gcc_assert (die
->die_child
);
23109 c
= die
->die_child
;
23110 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
23112 base_type
->die_mark
= 0;
23113 base_type
->die_sib
= c
->die_sib
;
23114 c
->die_sib
= base_type
;
23119 /* Helper function for resolve_addr, attempt to resolve
23120 one CONST_STRING, return non-zero if not successful. Similarly verify that
23121 SYMBOL_REFs refer to variables emitted in the current CU. */
23124 resolve_one_addr (rtx
*addr
, void *data ATTRIBUTE_UNUSED
)
23128 if (GET_CODE (rtl
) == CONST_STRING
)
23130 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
23131 tree t
= build_string (len
, XSTR (rtl
, 0));
23132 tree tlen
= size_int (len
- 1);
23134 = build_array_type (char_type_node
, build_index_type (tlen
));
23135 rtl
= lookup_constant_def (t
);
23136 if (!rtl
|| !MEM_P (rtl
))
23138 rtl
= XEXP (rtl
, 0);
23139 if (GET_CODE (rtl
) == SYMBOL_REF
23140 && SYMBOL_REF_DECL (rtl
)
23141 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
23143 vec_safe_push (used_rtx_array
, rtl
);
23148 if (GET_CODE (rtl
) == SYMBOL_REF
23149 && SYMBOL_REF_DECL (rtl
))
23151 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
23153 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
23156 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
23160 if (GET_CODE (rtl
) == CONST
23161 && for_each_rtx (&XEXP (rtl
, 0), resolve_one_addr
, NULL
))
23167 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
23168 if possible, and create DW_TAG_dwarf_procedure that can be referenced
23169 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
23172 string_cst_pool_decl (tree t
)
23174 rtx rtl
= output_constant_def (t
, 1);
23175 unsigned char *array
;
23176 dw_loc_descr_ref l
;
23181 if (!rtl
|| !MEM_P (rtl
))
23183 rtl
= XEXP (rtl
, 0);
23184 if (GET_CODE (rtl
) != SYMBOL_REF
23185 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
23188 decl
= SYMBOL_REF_DECL (rtl
);
23189 if (!lookup_decl_die (decl
))
23191 len
= TREE_STRING_LENGTH (t
);
23192 vec_safe_push (used_rtx_array
, rtl
);
23193 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
23194 array
= ggc_vec_alloc
<unsigned char> (len
);
23195 memcpy (array
, TREE_STRING_POINTER (t
), len
);
23196 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
23197 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
23198 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
23199 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
23200 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
23201 add_AT_loc (ref
, DW_AT_location
, l
);
23202 equate_decl_number_to_die (decl
, ref
);
23207 /* Helper function of resolve_addr_in_expr. LOC is
23208 a DW_OP_addr followed by DW_OP_stack_value, either at the start
23209 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
23210 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
23211 with DW_OP_GNU_implicit_pointer if possible
23212 and return true, if unsuccessful, return false. */
23215 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
23217 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
23218 HOST_WIDE_INT offset
= 0;
23219 dw_die_ref ref
= NULL
;
23222 if (GET_CODE (rtl
) == CONST
23223 && GET_CODE (XEXP (rtl
, 0)) == PLUS
23224 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
23226 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
23227 rtl
= XEXP (XEXP (rtl
, 0), 0);
23229 if (GET_CODE (rtl
) == CONST_STRING
)
23231 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
23232 tree t
= build_string (len
, XSTR (rtl
, 0));
23233 tree tlen
= size_int (len
- 1);
23236 = build_array_type (char_type_node
, build_index_type (tlen
));
23237 rtl
= string_cst_pool_decl (t
);
23241 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
23243 decl
= SYMBOL_REF_DECL (rtl
);
23244 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
23246 ref
= lookup_decl_die (decl
);
23247 if (ref
&& (get_AT (ref
, DW_AT_location
)
23248 || get_AT (ref
, DW_AT_const_value
)))
23250 loc
->dw_loc_opc
= DW_OP_GNU_implicit_pointer
;
23251 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23252 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
23253 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23254 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23255 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23256 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
23264 /* Helper function for resolve_addr, handle one location
23265 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23266 the location list couldn't be resolved. */
23269 resolve_addr_in_expr (dw_loc_descr_ref loc
)
23271 dw_loc_descr_ref keep
= NULL
;
23272 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
23273 switch (loc
->dw_loc_opc
)
23276 if (resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
23279 || prev
->dw_loc_opc
== DW_OP_piece
23280 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
23281 && loc
->dw_loc_next
23282 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
23284 && optimize_one_addr_into_implicit_ptr (loc
))
23289 case DW_OP_GNU_addr_index
:
23290 case DW_OP_GNU_const_index
:
23291 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
23292 || (loc
->dw_loc_opc
== DW_OP_GNU_const_index
&& loc
->dtprel
))
23293 && resolve_one_addr (&loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
,
23297 case DW_OP_const4u
:
23298 case DW_OP_const8u
:
23300 && resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
23303 case DW_OP_plus_uconst
:
23304 if (size_of_loc_descr (loc
)
23305 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
23307 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
23309 dw_loc_descr_ref repl
23310 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
23311 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
23312 add_loc_descr (&repl
, loc
->dw_loc_next
);
23316 case DW_OP_implicit_value
:
23317 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
23318 && resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
, NULL
))
23321 case DW_OP_GNU_implicit_pointer
:
23322 case DW_OP_GNU_parameter_ref
:
23323 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
23326 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
23329 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23330 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23331 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23334 case DW_OP_GNU_const_type
:
23335 case DW_OP_GNU_regval_type
:
23336 case DW_OP_GNU_deref_type
:
23337 case DW_OP_GNU_convert
:
23338 case DW_OP_GNU_reinterpret
:
23339 while (loc
->dw_loc_next
23340 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
)
23342 dw_die_ref base1
, base2
;
23343 unsigned enc1
, enc2
, size1
, size2
;
23344 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23345 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23346 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
23347 else if (loc
->dw_loc_oprnd1
.val_class
23348 == dw_val_class_unsigned_const
)
23351 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23352 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
23353 == dw_val_class_unsigned_const
)
23355 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23356 gcc_assert (base1
->die_tag
== DW_TAG_base_type
23357 && base2
->die_tag
== DW_TAG_base_type
);
23358 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
23359 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
23360 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
23361 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
23363 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
23364 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
23368 /* Optimize away next DW_OP_GNU_convert after
23369 adjusting LOC's base type die reference. */
23370 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23371 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23372 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
23374 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
23375 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23378 /* Don't change integer DW_OP_GNU_convert after e.g. floating
23379 point typed stack entry. */
23380 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
23381 keep
= loc
->dw_loc_next
;
23391 /* Helper function of resolve_addr. DIE had DW_AT_location of
23392 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
23393 and DW_OP_addr couldn't be resolved. resolve_addr has already
23394 removed the DW_AT_location attribute. This function attempts to
23395 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
23396 to it or DW_AT_const_value attribute, if possible. */
23399 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
23401 if (TREE_CODE (decl
) != VAR_DECL
23402 || lookup_decl_die (decl
) != die
23403 || DECL_EXTERNAL (decl
)
23404 || !TREE_STATIC (decl
)
23405 || DECL_INITIAL (decl
) == NULL_TREE
23406 || DECL_P (DECL_INITIAL (decl
))
23407 || get_AT (die
, DW_AT_const_value
))
23410 tree init
= DECL_INITIAL (decl
);
23411 HOST_WIDE_INT offset
= 0;
23412 /* For variables that have been optimized away and thus
23413 don't have a memory location, see if we can emit
23414 DW_AT_const_value instead. */
23415 if (tree_add_const_value_attribute (die
, init
))
23419 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
23420 and ADDR_EXPR refers to a decl that has DW_AT_location or
23421 DW_AT_const_value (but isn't addressable, otherwise
23422 resolving the original DW_OP_addr wouldn't fail), see if
23423 we can add DW_OP_GNU_implicit_pointer. */
23425 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
23426 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
23428 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
23429 init
= TREE_OPERAND (init
, 0);
23432 if (TREE_CODE (init
) != ADDR_EXPR
)
23434 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
23435 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
23436 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
23437 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
23438 && TREE_OPERAND (init
, 0) != decl
))
23441 dw_loc_descr_ref l
;
23443 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
23445 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
23448 decl
= SYMBOL_REF_DECL (rtl
);
23451 decl
= TREE_OPERAND (init
, 0);
23452 ref
= lookup_decl_die (decl
);
23454 || (!get_AT (ref
, DW_AT_location
)
23455 && !get_AT (ref
, DW_AT_const_value
)))
23457 l
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
23458 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23459 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23460 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23461 add_AT_loc (die
, DW_AT_location
, l
);
23465 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23466 an address in .rodata section if the string literal is emitted there,
23467 or remove the containing location list or replace DW_AT_const_value
23468 with DW_AT_location and empty location expression, if it isn't found
23469 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23470 to something that has been emitted in the current CU. */
23473 resolve_addr (dw_die_ref die
)
23477 dw_loc_list_ref
*curr
, *start
, loc
;
23480 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23481 switch (AT_class (a
))
23483 case dw_val_class_loc_list
:
23484 start
= curr
= AT_loc_list_ptr (a
);
23487 /* The same list can be referenced more than once. See if we have
23488 already recorded the result from a previous pass. */
23490 *curr
= loc
->dw_loc_next
;
23491 else if (!loc
->resolved_addr
)
23493 /* As things stand, we do not expect or allow one die to
23494 reference a suffix of another die's location list chain.
23495 References must be identical or completely separate.
23496 There is therefore no need to cache the result of this
23497 pass on any list other than the first; doing so
23498 would lead to unnecessary writes. */
23501 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
23502 if (!resolve_addr_in_expr ((*curr
)->expr
))
23504 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
23505 dw_loc_descr_ref l
= (*curr
)->expr
;
23507 if (next
&& (*curr
)->ll_symbol
)
23509 gcc_assert (!next
->ll_symbol
);
23510 next
->ll_symbol
= (*curr
)->ll_symbol
;
23512 if (dwarf_split_debug_info
)
23513 remove_loc_list_addr_table_entries (l
);
23518 mark_base_types ((*curr
)->expr
);
23519 curr
= &(*curr
)->dw_loc_next
;
23523 loc
->resolved_addr
= 1;
23527 loc
->dw_loc_next
= *start
;
23532 remove_AT (die
, a
->dw_attr
);
23536 case dw_val_class_loc
:
23538 dw_loc_descr_ref l
= AT_loc (a
);
23539 /* For -gdwarf-2 don't attempt to optimize
23540 DW_AT_data_member_location containing
23541 DW_OP_plus_uconst - older consumers might
23542 rely on it being that op instead of a more complex,
23543 but shorter, location description. */
23544 if ((dwarf_version
> 2
23545 || a
->dw_attr
!= DW_AT_data_member_location
23547 || l
->dw_loc_opc
!= DW_OP_plus_uconst
23548 || l
->dw_loc_next
!= NULL
)
23549 && !resolve_addr_in_expr (l
))
23551 if (dwarf_split_debug_info
)
23552 remove_loc_list_addr_table_entries (l
);
23554 && l
->dw_loc_next
== NULL
23555 && l
->dw_loc_opc
== DW_OP_addr
23556 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
23557 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
23558 && a
->dw_attr
== DW_AT_location
)
23560 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
23561 remove_AT (die
, a
->dw_attr
);
23563 optimize_location_into_implicit_ptr (die
, decl
);
23566 remove_AT (die
, a
->dw_attr
);
23570 mark_base_types (l
);
23573 case dw_val_class_addr
:
23574 if (a
->dw_attr
== DW_AT_const_value
23575 && resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
, NULL
))
23577 if (AT_index (a
) != NOT_INDEXED
)
23578 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23579 remove_AT (die
, a
->dw_attr
);
23582 if (die
->die_tag
== DW_TAG_GNU_call_site
23583 && a
->dw_attr
== DW_AT_abstract_origin
)
23585 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
23586 dw_die_ref tdie
= lookup_decl_die (tdecl
);
23588 && DECL_EXTERNAL (tdecl
)
23589 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
)
23591 force_decl_die (tdecl
);
23592 tdie
= lookup_decl_die (tdecl
);
23596 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
23597 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
23598 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
23602 if (AT_index (a
) != NOT_INDEXED
)
23603 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23604 remove_AT (die
, a
->dw_attr
);
23613 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
23616 /* Helper routines for optimize_location_lists.
23617 This pass tries to share identical local lists in .debug_loc
23620 /* Iteratively hash operands of LOC opcode. */
23623 hash_loc_operands (dw_loc_descr_ref loc
, hashval_t hash
)
23625 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
23626 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
23628 switch (loc
->dw_loc_opc
)
23630 case DW_OP_const4u
:
23631 case DW_OP_const8u
:
23635 case DW_OP_const1u
:
23636 case DW_OP_const1s
:
23637 case DW_OP_const2u
:
23638 case DW_OP_const2s
:
23639 case DW_OP_const4s
:
23640 case DW_OP_const8s
:
23644 case DW_OP_plus_uconst
:
23680 case DW_OP_deref_size
:
23681 case DW_OP_xderef_size
:
23682 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23689 gcc_assert (val1
->val_class
== dw_val_class_loc
);
23690 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
23691 hash
= iterative_hash_object (offset
, hash
);
23694 case DW_OP_implicit_value
:
23695 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
23696 switch (val2
->val_class
)
23698 case dw_val_class_const
:
23699 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23701 case dw_val_class_vec
:
23703 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23704 unsigned int len
= val2
->v
.val_vec
.length
;
23706 hash
= iterative_hash_object (elt_size
, hash
);
23707 hash
= iterative_hash_object (len
, hash
);
23708 hash
= iterative_hash (val2
->v
.val_vec
.array
,
23709 len
* elt_size
, hash
);
23712 case dw_val_class_const_double
:
23713 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
23714 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
23716 case dw_val_class_wide_int
:
23717 hash
= iterative_hash_object (*val2
->v
.val_wide
, hash
);
23719 case dw_val_class_addr
:
23720 hash
= iterative_hash_rtx (val2
->v
.val_addr
, hash
);
23723 gcc_unreachable ();
23727 case DW_OP_bit_piece
:
23728 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23729 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23735 unsigned char dtprel
= 0xd1;
23736 hash
= iterative_hash_object (dtprel
, hash
);
23738 hash
= iterative_hash_rtx (val1
->v
.val_addr
, hash
);
23740 case DW_OP_GNU_addr_index
:
23741 case DW_OP_GNU_const_index
:
23745 unsigned char dtprel
= 0xd1;
23746 hash
= iterative_hash_object (dtprel
, hash
);
23748 hash
= iterative_hash_rtx (val1
->val_entry
->addr
.rtl
, hash
);
23751 case DW_OP_GNU_implicit_pointer
:
23752 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23754 case DW_OP_GNU_entry_value
:
23755 hash
= hash_loc_operands (val1
->v
.val_loc
, hash
);
23757 case DW_OP_GNU_regval_type
:
23758 case DW_OP_GNU_deref_type
:
23760 unsigned int byte_size
23761 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23762 unsigned int encoding
23763 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
23764 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23765 hash
= iterative_hash_object (byte_size
, hash
);
23766 hash
= iterative_hash_object (encoding
, hash
);
23769 case DW_OP_GNU_convert
:
23770 case DW_OP_GNU_reinterpret
:
23771 if (val1
->val_class
== dw_val_class_unsigned_const
)
23773 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
23777 case DW_OP_GNU_const_type
:
23779 unsigned int byte_size
23780 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23781 unsigned int encoding
23782 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
23783 hash
= iterative_hash_object (byte_size
, hash
);
23784 hash
= iterative_hash_object (encoding
, hash
);
23785 if (loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
23787 hash
= iterative_hash_object (val2
->val_class
, hash
);
23788 switch (val2
->val_class
)
23790 case dw_val_class_const
:
23791 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23793 case dw_val_class_vec
:
23795 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23796 unsigned int len
= val2
->v
.val_vec
.length
;
23798 hash
= iterative_hash_object (elt_size
, hash
);
23799 hash
= iterative_hash_object (len
, hash
);
23800 hash
= iterative_hash (val2
->v
.val_vec
.array
,
23801 len
* elt_size
, hash
);
23804 case dw_val_class_const_double
:
23805 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
23806 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
23808 case dw_val_class_wide_int
:
23809 hash
= iterative_hash_object (*val2
->v
.val_wide
, hash
);
23812 gcc_unreachable ();
23818 /* Other codes have no operands. */
23824 /* Iteratively hash the whole DWARF location expression LOC. */
23826 static inline hashval_t
23827 hash_locs (dw_loc_descr_ref loc
, hashval_t hash
)
23829 dw_loc_descr_ref l
;
23830 bool sizes_computed
= false;
23831 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
23832 size_of_locs (loc
);
23834 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
23836 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
23837 hash
= iterative_hash_object (opc
, hash
);
23838 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
23840 size_of_locs (loc
);
23841 sizes_computed
= true;
23843 hash
= hash_loc_operands (l
, hash
);
23848 /* Compute hash of the whole location list LIST_HEAD. */
23851 hash_loc_list (dw_loc_list_ref list_head
)
23853 dw_loc_list_ref curr
= list_head
;
23854 hashval_t hash
= 0;
23856 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
23858 hash
= iterative_hash (curr
->begin
, strlen (curr
->begin
) + 1, hash
);
23859 hash
= iterative_hash (curr
->end
, strlen (curr
->end
) + 1, hash
);
23861 hash
= iterative_hash (curr
->section
, strlen (curr
->section
) + 1,
23863 hash
= hash_locs (curr
->expr
, hash
);
23865 list_head
->hash
= hash
;
23868 /* Return true if X and Y opcodes have the same operands. */
23871 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
23873 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
23874 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
23875 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
23876 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
23878 switch (x
->dw_loc_opc
)
23880 case DW_OP_const4u
:
23881 case DW_OP_const8u
:
23885 case DW_OP_const1u
:
23886 case DW_OP_const1s
:
23887 case DW_OP_const2u
:
23888 case DW_OP_const2s
:
23889 case DW_OP_const4s
:
23890 case DW_OP_const8s
:
23894 case DW_OP_plus_uconst
:
23930 case DW_OP_deref_size
:
23931 case DW_OP_xderef_size
:
23932 return valx1
->v
.val_int
== valy1
->v
.val_int
;
23935 /* If splitting debug info, the use of DW_OP_GNU_addr_index
23936 can cause irrelevant differences in dw_loc_addr. */
23937 gcc_assert (valx1
->val_class
== dw_val_class_loc
23938 && valy1
->val_class
== dw_val_class_loc
23939 && (dwarf_split_debug_info
23940 || x
->dw_loc_addr
== y
->dw_loc_addr
));
23941 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
23942 case DW_OP_implicit_value
:
23943 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
23944 || valx2
->val_class
!= valy2
->val_class
)
23946 switch (valx2
->val_class
)
23948 case dw_val_class_const
:
23949 return valx2
->v
.val_int
== valy2
->v
.val_int
;
23950 case dw_val_class_vec
:
23951 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
23952 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
23953 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
23954 valx2
->v
.val_vec
.elt_size
23955 * valx2
->v
.val_vec
.length
) == 0;
23956 case dw_val_class_const_double
:
23957 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
23958 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
23959 case dw_val_class_wide_int
:
23960 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
23961 case dw_val_class_addr
:
23962 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
23964 gcc_unreachable ();
23967 case DW_OP_bit_piece
:
23968 return valx1
->v
.val_int
== valy1
->v
.val_int
23969 && valx2
->v
.val_int
== valy2
->v
.val_int
;
23972 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
23973 case DW_OP_GNU_addr_index
:
23974 case DW_OP_GNU_const_index
:
23976 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
23977 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
23978 return rtx_equal_p (ax1
, ay1
);
23980 case DW_OP_GNU_implicit_pointer
:
23981 return valx1
->val_class
== dw_val_class_die_ref
23982 && valx1
->val_class
== valy1
->val_class
23983 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
23984 && valx2
->v
.val_int
== valy2
->v
.val_int
;
23985 case DW_OP_GNU_entry_value
:
23986 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
23987 case DW_OP_GNU_const_type
:
23988 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
23989 || valx2
->val_class
!= valy2
->val_class
)
23991 switch (valx2
->val_class
)
23993 case dw_val_class_const
:
23994 return valx2
->v
.val_int
== valy2
->v
.val_int
;
23995 case dw_val_class_vec
:
23996 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
23997 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
23998 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
23999 valx2
->v
.val_vec
.elt_size
24000 * valx2
->v
.val_vec
.length
) == 0;
24001 case dw_val_class_const_double
:
24002 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
24003 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
24004 case dw_val_class_wide_int
:
24005 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
24007 gcc_unreachable ();
24009 case DW_OP_GNU_regval_type
:
24010 case DW_OP_GNU_deref_type
:
24011 return valx1
->v
.val_int
== valy1
->v
.val_int
24012 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
24013 case DW_OP_GNU_convert
:
24014 case DW_OP_GNU_reinterpret
:
24015 if (valx1
->val_class
!= valy1
->val_class
)
24017 if (valx1
->val_class
== dw_val_class_unsigned_const
)
24018 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
24019 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
24020 case DW_OP_GNU_parameter_ref
:
24021 return valx1
->val_class
== dw_val_class_die_ref
24022 && valx1
->val_class
== valy1
->val_class
24023 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
24025 /* Other codes have no operands. */
24030 /* Return true if DWARF location expressions X and Y are the same. */
24033 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
24035 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
24036 if (x
->dw_loc_opc
!= y
->dw_loc_opc
24037 || x
->dtprel
!= y
->dtprel
24038 || !compare_loc_operands (x
, y
))
24040 return x
== NULL
&& y
== NULL
;
24043 /* Hashtable helpers. */
24045 struct loc_list_hasher
: typed_noop_remove
<dw_loc_list_struct
>
24047 typedef dw_loc_list_struct value_type
;
24048 typedef dw_loc_list_struct compare_type
;
24049 static inline hashval_t
hash (const value_type
*);
24050 static inline bool equal (const value_type
*, const compare_type
*);
24053 /* Return precomputed hash of location list X. */
24056 loc_list_hasher::hash (const value_type
*x
)
24061 /* Return true if location lists A and B are the same. */
24064 loc_list_hasher::equal (const value_type
*a
, const compare_type
*b
)
24068 if (a
->hash
!= b
->hash
)
24070 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
24071 if (strcmp (a
->begin
, b
->begin
) != 0
24072 || strcmp (a
->end
, b
->end
) != 0
24073 || (a
->section
== NULL
) != (b
->section
== NULL
)
24074 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
24075 || !compare_locs (a
->expr
, b
->expr
))
24077 return a
== NULL
&& b
== NULL
;
24080 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
24083 /* Recursively optimize location lists referenced from DIE
24084 children and share them whenever possible. */
24087 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
24092 dw_loc_list_struct
**slot
;
24094 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
24095 if (AT_class (a
) == dw_val_class_loc_list
)
24097 dw_loc_list_ref list
= AT_loc_list (a
);
24098 /* TODO: perform some optimizations here, before hashing
24099 it and storing into the hash table. */
24100 hash_loc_list (list
);
24101 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
24105 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
24108 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
24112 /* Recursively assign each location list a unique index into the debug_addr
24116 index_location_lists (dw_die_ref die
)
24122 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
24123 if (AT_class (a
) == dw_val_class_loc_list
)
24125 dw_loc_list_ref list
= AT_loc_list (a
);
24126 dw_loc_list_ref curr
;
24127 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
24129 /* Don't index an entry that has already been indexed
24130 or won't be output. */
24131 if (curr
->begin_entry
!= NULL
24132 || (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
))
24136 = add_addr_table_entry (xstrdup (curr
->begin
),
24141 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
24144 /* Optimize location lists referenced from DIE
24145 children and share them whenever possible. */
24148 optimize_location_lists (dw_die_ref die
)
24150 loc_list_hash_type
htab (500);
24151 optimize_location_lists_1 (die
, &htab
);
24154 /* Output stuff that dwarf requires at the end of every file,
24155 and generate the DWARF-2 debugging info. */
24158 dwarf2out_finish (const char *filename
)
24160 limbo_die_node
*node
, *next_node
;
24161 comdat_type_node
*ctnode
;
24163 dw_die_ref main_comp_unit_die
;
24165 /* PCH might result in DW_AT_producer string being restored from the
24166 header compilation, so always fill it with empty string initially
24167 and overwrite only here. */
24168 dw_attr_ref producer
= get_AT (comp_unit_die (), DW_AT_producer
);
24169 producer_string
= gen_producer_string ();
24170 producer
->dw_attr_val
.v
.val_str
->refcount
--;
24171 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
24173 gen_scheduled_generic_parms_dies ();
24174 gen_remaining_tmpl_value_param_die_attribute ();
24176 /* Add the name for the main input file now. We delayed this from
24177 dwarf2out_init to avoid complications with PCH. */
24178 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
24179 if (!IS_ABSOLUTE_PATH (filename
) || targetm
.force_at_comp_dir
)
24180 add_comp_dir_attribute (comp_unit_die ());
24181 else if (get_AT (comp_unit_die (), DW_AT_comp_dir
) == NULL
)
24184 htab_traverse (file_table
, file_table_relative_p
, &p
);
24186 add_comp_dir_attribute (comp_unit_die ());
24189 if (deferred_locations_list
)
24190 for (i
= 0; i
< deferred_locations_list
->length (); i
++)
24192 add_location_or_const_value_attribute (
24193 (*deferred_locations_list
)[i
].die
,
24194 (*deferred_locations_list
)[i
].variable
,
24199 /* Traverse the limbo die list, and add parent/child links. The only
24200 dies without parents that should be here are concrete instances of
24201 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
24202 For concrete instances, we can get the parent die from the abstract
24204 for (node
= limbo_die_list
; node
; node
= next_node
)
24206 dw_die_ref die
= node
->die
;
24207 next_node
= node
->next
;
24209 if (die
->die_parent
== NULL
)
24211 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
24213 if (origin
&& origin
->die_parent
)
24214 add_child_die (origin
->die_parent
, die
);
24215 else if (is_cu_die (die
))
24217 else if (seen_error ())
24218 /* It's OK to be confused by errors in the input. */
24219 add_child_die (comp_unit_die (), die
);
24222 /* In certain situations, the lexical block containing a
24223 nested function can be optimized away, which results
24224 in the nested function die being orphaned. Likewise
24225 with the return type of that nested function. Force
24226 this to be a child of the containing function.
24228 It may happen that even the containing function got fully
24229 inlined and optimized out. In that case we are lost and
24230 assign the empty child. This should not be big issue as
24231 the function is likely unreachable too. */
24232 gcc_assert (node
->created_for
);
24234 if (DECL_P (node
->created_for
))
24235 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
24236 else if (TYPE_P (node
->created_for
))
24237 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
24239 origin
= comp_unit_die ();
24241 add_child_die (origin
, die
);
24246 limbo_die_list
= NULL
;
24248 #if ENABLE_ASSERT_CHECKING
24250 dw_die_ref die
= comp_unit_die (), c
;
24251 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
24254 resolve_addr (comp_unit_die ());
24255 move_marked_base_types ();
24257 for (node
= deferred_asm_name
; node
; node
= node
->next
)
24259 tree decl
= node
->created_for
;
24260 /* When generating LTO bytecode we can not generate new assembler
24261 names at this point and all important decls got theirs via
24263 if ((!flag_generate_lto
|| DECL_ASSEMBLER_NAME_SET_P (decl
))
24264 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
24266 add_linkage_attr (node
->die
, decl
);
24267 move_linkage_attr (node
->die
);
24271 deferred_asm_name
= NULL
;
24273 /* Walk through the list of incomplete types again, trying once more to
24274 emit full debugging info for them. */
24275 retry_incomplete_types ();
24277 if (flag_eliminate_unused_debug_types
)
24278 prune_unused_types ();
24280 /* Generate separate COMDAT sections for type DIEs. */
24281 if (use_debug_types
)
24283 break_out_comdat_types (comp_unit_die ());
24285 /* Each new type_unit DIE was added to the limbo die list when created.
24286 Since these have all been added to comdat_type_list, clear the
24288 limbo_die_list
= NULL
;
24290 /* For each new comdat type unit, copy declarations for incomplete
24291 types to make the new unit self-contained (i.e., no direct
24292 references to the main compile unit). */
24293 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24294 copy_decls_for_unworthy_types (ctnode
->root_die
);
24295 copy_decls_for_unworthy_types (comp_unit_die ());
24297 /* In the process of copying declarations from one unit to another,
24298 we may have left some declarations behind that are no longer
24299 referenced. Prune them. */
24300 prune_unused_types ();
24303 /* Generate separate CUs for each of the include files we've seen.
24304 They will go into limbo_die_list. */
24305 if (flag_eliminate_dwarf2_dups
)
24306 break_out_includes (comp_unit_die ());
24308 /* Traverse the DIE's and add add sibling attributes to those DIE's
24309 that have children. */
24310 add_sibling_attributes (comp_unit_die ());
24311 for (node
= limbo_die_list
; node
; node
= node
->next
)
24312 add_sibling_attributes (node
->die
);
24313 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24314 add_sibling_attributes (ctnode
->root_die
);
24316 /* When splitting DWARF info, we put some attributes in the
24317 skeleton compile_unit DIE that remains in the .o, while
24318 most attributes go in the DWO compile_unit_die. */
24319 if (dwarf_split_debug_info
)
24320 main_comp_unit_die
= gen_compile_unit_die (NULL
);
24322 main_comp_unit_die
= comp_unit_die ();
24324 /* Output a terminator label for the .text section. */
24325 switch_to_section (text_section
);
24326 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
24327 if (cold_text_section
)
24329 switch_to_section (cold_text_section
);
24330 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
24333 /* We can only use the low/high_pc attributes if all of the code was
24335 if (!have_multiple_function_sections
24336 || (dwarf_version
< 3 && dwarf_strict
))
24338 /* Don't add if the CU has no associated code. */
24339 if (text_section_used
)
24340 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
24341 text_end_label
, true);
24347 bool range_list_added
= false;
24349 if (text_section_used
)
24350 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
24351 text_end_label
, &range_list_added
, true);
24352 if (cold_text_section_used
)
24353 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
24354 cold_end_label
, &range_list_added
, true);
24356 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
24358 if (DECL_IGNORED_P (fde
->decl
))
24360 if (!fde
->in_std_section
)
24361 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
24362 fde
->dw_fde_end
, &range_list_added
,
24364 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
24365 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
24366 fde
->dw_fde_second_end
, &range_list_added
,
24370 if (range_list_added
)
24372 /* We need to give .debug_loc and .debug_ranges an appropriate
24373 "base address". Use zero so that these addresses become
24374 absolute. Historically, we've emitted the unexpected
24375 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24376 Emit both to give time for other tools to adapt. */
24377 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
24378 if (! dwarf_strict
&& dwarf_version
< 4)
24379 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
24385 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24386 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
24387 debug_line_section_label
);
24390 add_AT_macptr (comp_unit_die (),
24391 dwarf_strict
? DW_AT_macro_info
: DW_AT_GNU_macros
,
24392 macinfo_section_label
);
24394 if (dwarf_split_debug_info
&& addr_index_table
!= NULL
)
24396 /* optimize_location_lists calculates the size of the lists,
24397 so index them first, and assign indices to the entries.
24398 Although optimize_location_lists will remove entries from
24399 the table, it only does so for duplicates, and therefore
24400 only reduces ref_counts to 1. */
24401 unsigned int index
= 0;
24402 index_location_lists (comp_unit_die ());
24403 htab_traverse_noresize (addr_index_table
,
24404 index_addr_table_entry
, &index
);
24406 if (have_location_lists
)
24407 optimize_location_lists (comp_unit_die ());
24409 save_macinfo_strings ();
24411 if (dwarf_split_debug_info
)
24413 unsigned int index
= 0;
24415 /* Add attributes common to skeleton compile_units and
24416 type_units. Because these attributes include strings, it
24417 must be done before freezing the string table. Top-level
24418 skeleton die attrs are added when the skeleton type unit is
24419 created, so ensure it is created by this point. */
24420 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
24421 (void) get_skeleton_type_unit ();
24422 htab_traverse_noresize (debug_str_hash
, index_string
, &index
);
24425 /* Output all of the compilation units. We put the main one last so that
24426 the offsets are available to output_pubnames. */
24427 for (node
= limbo_die_list
; node
; node
= node
->next
)
24428 output_comp_unit (node
->die
, 0);
24430 hash_table
<comdat_type_hasher
> comdat_type_table (100);
24431 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24433 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
24435 /* Don't output duplicate types. */
24436 if (*slot
!= HTAB_EMPTY_ENTRY
)
24439 /* Add a pointer to the line table for the main compilation unit
24440 so that the debugger can make sense of DW_AT_decl_file
24442 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24443 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
24444 (!dwarf_split_debug_info
24445 ? debug_line_section_label
24446 : debug_skeleton_line_section_label
));
24448 output_comdat_type_unit (ctnode
);
24452 /* The AT_pubnames attribute needs to go in all skeleton dies, including
24453 both the main_cu and all skeleton TUs. Making this call unconditional
24454 would end up either adding a second copy of the AT_pubnames attribute, or
24455 requiring a special case in add_top_level_skeleton_die_attrs. */
24456 if (!dwarf_split_debug_info
)
24457 add_AT_pubnames (comp_unit_die ());
24459 if (dwarf_split_debug_info
)
24462 unsigned char checksum
[16];
24463 struct md5_ctx ctx
;
24465 /* Compute a checksum of the comp_unit to use as the dwo_id. */
24466 md5_init_ctx (&ctx
);
24468 die_checksum (comp_unit_die (), &ctx
, &mark
);
24469 unmark_all_dies (comp_unit_die ());
24470 md5_finish_ctx (&ctx
, checksum
);
24472 /* Use the first 8 bytes of the checksum as the dwo_id,
24473 and add it to both comp-unit DIEs. */
24474 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
24475 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
24477 /* Add the base offset of the ranges table to the skeleton
24479 if (ranges_table_in_use
)
24480 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
24481 ranges_section_label
);
24483 switch_to_section (debug_addr_section
);
24484 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
24485 output_addr_table ();
24488 /* Output the main compilation unit if non-empty or if .debug_macinfo
24489 or .debug_macro will be emitted. */
24490 output_comp_unit (comp_unit_die (), have_macinfo
);
24492 if (dwarf_split_debug_info
&& info_section_emitted
)
24493 output_skeleton_debug_sections (main_comp_unit_die
);
24495 /* Output the abbreviation table. */
24496 if (abbrev_die_table_in_use
!= 1)
24498 switch_to_section (debug_abbrev_section
);
24499 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
24500 output_abbrev_section ();
24503 /* Output location list section if necessary. */
24504 if (have_location_lists
)
24506 /* Output the location lists info. */
24507 switch_to_section (debug_loc_section
);
24508 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
24509 output_location_lists (comp_unit_die ());
24512 output_pubtables ();
24514 /* Output the address range information if a CU (.debug_info section)
24515 was emitted. We output an empty table even if we had no functions
24516 to put in it. This because the consumer has no way to tell the
24517 difference between an empty table that we omitted and failure to
24518 generate a table that would have contained data. */
24519 if (info_section_emitted
)
24521 unsigned long aranges_length
= size_of_aranges ();
24523 switch_to_section (debug_aranges_section
);
24524 output_aranges (aranges_length
);
24527 /* Output ranges section if necessary. */
24528 if (ranges_table_in_use
)
24530 switch_to_section (debug_ranges_section
);
24531 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
24535 /* Have to end the macro section. */
24538 switch_to_section (debug_macinfo_section
);
24539 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
24541 dw2_asm_output_data (1, 0, "End compilation unit");
24544 /* Output the source line correspondence table. We must do this
24545 even if there is no line information. Otherwise, on an empty
24546 translation unit, we will generate a present, but empty,
24547 .debug_info section. IRIX 6.5 `nm' will then complain when
24548 examining the file. This is done late so that any filenames
24549 used by the debug_info section are marked as 'used'. */
24550 switch_to_section (debug_line_section
);
24551 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
24552 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
24553 output_line_info (false);
24555 if (dwarf_split_debug_info
&& info_section_emitted
)
24557 switch_to_section (debug_skeleton_line_section
);
24558 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
24559 output_line_info (true);
24562 /* If we emitted any indirect strings, output the string table too. */
24563 if (debug_str_hash
|| skeleton_debug_str_hash
)
24564 output_indirect_strings ();
24567 #include "gt-dwarf2out.h"