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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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_alloc_cleared_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
;
6811 cu_hash_type cu_hash_table
;
6815 dw_die_ref prev
= c
;
6817 while (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
6818 || (unit
&& is_comdat_die (c
)))
6820 dw_die_ref next
= c
->die_sib
;
6822 /* This DIE is for a secondary CU; remove it from the main one. */
6823 remove_child_with_prev (c
, prev
);
6825 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
6826 unit
= push_new_compile_unit (unit
, c
);
6827 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
6828 unit
= pop_compile_unit (unit
);
6830 add_child_die (unit
, c
);
6832 if (c
== die
->die_child
)
6835 } while (c
!= die
->die_child
);
6838 /* We can only use this in debugging, since the frontend doesn't check
6839 to make sure that we leave every include file we enter. */
6843 assign_symbol_names (die
);
6844 cu_hash_table
.create (10);
6845 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
6851 compute_section_prefix (node
->die
);
6852 is_dupl
= check_duplicate_cu (node
->die
, cu_hash_table
,
6853 &comdat_symbol_number
);
6854 assign_symbol_names (node
->die
);
6856 *pnode
= node
->next
;
6859 pnode
= &node
->next
;
6860 record_comdat_symbol_number (node
->die
, cu_hash_table
,
6861 comdat_symbol_number
);
6864 cu_hash_table
.dispose ();
6867 /* Return non-zero if this DIE is a declaration. */
6870 is_declaration_die (dw_die_ref die
)
6875 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6876 if (a
->dw_attr
== DW_AT_declaration
)
6882 /* Return non-zero if this DIE is nested inside a subprogram. */
6885 is_nested_in_subprogram (dw_die_ref die
)
6887 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
6891 return local_scope_p (decl
);
6894 /* Return non-zero if this DIE contains a defining declaration of a
6898 contains_subprogram_definition (dw_die_ref die
)
6902 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
6904 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
6908 /* Return non-zero if this is a type DIE that should be moved to a
6909 COMDAT .debug_types section. */
6912 should_move_die_to_comdat (dw_die_ref die
)
6914 switch (die
->die_tag
)
6916 case DW_TAG_class_type
:
6917 case DW_TAG_structure_type
:
6918 case DW_TAG_enumeration_type
:
6919 case DW_TAG_union_type
:
6920 /* Don't move declarations, inlined instances, types nested in a
6921 subprogram, or types that contain subprogram definitions. */
6922 if (is_declaration_die (die
)
6923 || get_AT (die
, DW_AT_abstract_origin
)
6924 || is_nested_in_subprogram (die
)
6925 || contains_subprogram_definition (die
))
6928 case DW_TAG_array_type
:
6929 case DW_TAG_interface_type
:
6930 case DW_TAG_pointer_type
:
6931 case DW_TAG_reference_type
:
6932 case DW_TAG_rvalue_reference_type
:
6933 case DW_TAG_string_type
:
6934 case DW_TAG_subroutine_type
:
6935 case DW_TAG_ptr_to_member_type
:
6936 case DW_TAG_set_type
:
6937 case DW_TAG_subrange_type
:
6938 case DW_TAG_base_type
:
6939 case DW_TAG_const_type
:
6940 case DW_TAG_file_type
:
6941 case DW_TAG_packed_type
:
6942 case DW_TAG_volatile_type
:
6943 case DW_TAG_typedef
:
6949 /* Make a clone of DIE. */
6952 clone_die (dw_die_ref die
)
6958 clone
= ggc_alloc_cleared_die_node ();
6959 clone
->die_tag
= die
->die_tag
;
6961 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6962 add_dwarf_attr (clone
, a
);
6967 /* Make a clone of the tree rooted at DIE. */
6970 clone_tree (dw_die_ref die
)
6973 dw_die_ref clone
= clone_die (die
);
6975 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
6980 /* Make a clone of DIE as a declaration. */
6983 clone_as_declaration (dw_die_ref die
)
6990 /* If the DIE is already a declaration, just clone it. */
6991 if (is_declaration_die (die
))
6992 return clone_die (die
);
6994 /* If the DIE is a specification, just clone its declaration DIE. */
6995 decl
= get_AT_ref (die
, DW_AT_specification
);
6998 clone
= clone_die (decl
);
6999 if (die
->comdat_type_p
)
7000 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7004 clone
= ggc_alloc_cleared_die_node ();
7005 clone
->die_tag
= die
->die_tag
;
7007 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7009 /* We don't want to copy over all attributes.
7010 For example we don't want DW_AT_byte_size because otherwise we will no
7011 longer have a declaration and GDB will treat it as a definition. */
7015 case DW_AT_abstract_origin
:
7016 case DW_AT_artificial
:
7017 case DW_AT_containing_type
:
7018 case DW_AT_external
:
7021 case DW_AT_virtuality
:
7022 case DW_AT_linkage_name
:
7023 case DW_AT_MIPS_linkage_name
:
7024 add_dwarf_attr (clone
, a
);
7026 case DW_AT_byte_size
:
7032 if (die
->comdat_type_p
)
7033 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7035 add_AT_flag (clone
, DW_AT_declaration
, 1);
7040 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7042 struct decl_table_entry
7048 /* Helpers to manipulate hash table of copied declarations. */
7050 /* Hashtable helpers. */
7052 struct decl_table_entry_hasher
: typed_free_remove
<decl_table_entry
>
7054 typedef decl_table_entry value_type
;
7055 typedef die_struct compare_type
;
7056 static inline hashval_t
hash (const value_type
*);
7057 static inline bool equal (const value_type
*, const compare_type
*);
7061 decl_table_entry_hasher::hash (const value_type
*entry
)
7063 return htab_hash_pointer (entry
->orig
);
7067 decl_table_entry_hasher::equal (const value_type
*entry1
,
7068 const compare_type
*entry2
)
7070 return entry1
->orig
== entry2
;
7073 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
7075 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7076 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7077 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7078 to check if the ancestor has already been copied into UNIT. */
7081 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
, decl_hash_type decl_table
)
7083 dw_die_ref parent
= die
->die_parent
;
7084 dw_die_ref new_parent
= unit
;
7086 decl_table_entry
**slot
= NULL
;
7087 struct decl_table_entry
*entry
= NULL
;
7089 if (decl_table
.is_created ())
7091 /* Check if the entry has already been copied to UNIT. */
7092 slot
= decl_table
.find_slot_with_hash (die
, htab_hash_pointer (die
),
7094 if (*slot
!= HTAB_EMPTY_ENTRY
)
7100 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7101 entry
= XCNEW (struct decl_table_entry
);
7109 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
7112 if (!is_unit_die (parent
))
7113 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
7116 copy
= clone_as_declaration (die
);
7117 add_child_die (new_parent
, copy
);
7119 if (decl_table
.is_created ())
7121 /* Record the pointer to the copy. */
7127 /* Copy the declaration context to the new type unit DIE. This includes
7128 any surrounding namespace or type declarations. If the DIE has an
7129 AT_specification attribute, it also includes attributes and children
7130 attached to the specification, and returns a pointer to the original
7131 parent of the declaration DIE. Returns NULL otherwise. */
7134 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
7137 dw_die_ref new_decl
;
7138 dw_die_ref orig_parent
= NULL
;
7140 decl
= get_AT_ref (die
, DW_AT_specification
);
7149 /* The original DIE will be changed to a declaration, and must
7150 be moved to be a child of the original declaration DIE. */
7151 orig_parent
= decl
->die_parent
;
7153 /* Copy the type node pointer from the new DIE to the original
7154 declaration DIE so we can forward references later. */
7155 decl
->comdat_type_p
= true;
7156 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
7158 remove_AT (die
, DW_AT_specification
);
7160 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
7162 if (a
->dw_attr
!= DW_AT_name
7163 && a
->dw_attr
!= DW_AT_declaration
7164 && a
->dw_attr
!= DW_AT_external
)
7165 add_dwarf_attr (die
, a
);
7168 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
7171 if (decl
->die_parent
!= NULL
7172 && !is_unit_die (decl
->die_parent
))
7174 new_decl
= copy_ancestor_tree (unit
, decl
, decl_hash_type ());
7175 if (new_decl
!= NULL
)
7177 remove_AT (new_decl
, DW_AT_signature
);
7178 add_AT_specification (die
, new_decl
);
7185 /* Generate the skeleton ancestor tree for the given NODE, then clone
7186 the DIE and add the clone into the tree. */
7189 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
7191 if (node
->new_die
!= NULL
)
7194 node
->new_die
= clone_as_declaration (node
->old_die
);
7196 if (node
->parent
!= NULL
)
7198 generate_skeleton_ancestor_tree (node
->parent
);
7199 add_child_die (node
->parent
->new_die
, node
->new_die
);
7203 /* Generate a skeleton tree of DIEs containing any declarations that are
7204 found in the original tree. We traverse the tree looking for declaration
7205 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7208 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
7210 skeleton_chain_node node
;
7213 dw_die_ref prev
= NULL
;
7214 dw_die_ref next
= NULL
;
7216 node
.parent
= parent
;
7218 first
= c
= parent
->old_die
->die_child
;
7222 if (prev
== NULL
|| prev
->die_sib
== c
)
7225 next
= (c
== first
? NULL
: c
->die_sib
);
7227 node
.new_die
= NULL
;
7228 if (is_declaration_die (c
))
7230 if (is_template_instantiation (c
))
7232 /* Instantiated templates do not need to be cloned into the
7233 type unit. Just move the DIE and its children back to
7234 the skeleton tree (in the main CU). */
7235 remove_child_with_prev (c
, prev
);
7236 add_child_die (parent
->new_die
, c
);
7241 /* Clone the existing DIE, move the original to the skeleton
7242 tree (which is in the main CU), and put the clone, with
7243 all the original's children, where the original came from
7244 (which is about to be moved to the type unit). */
7245 dw_die_ref clone
= clone_die (c
);
7246 move_all_children (c
, clone
);
7248 /* If the original has a DW_AT_object_pointer attribute,
7249 it would now point to a child DIE just moved to the
7250 cloned tree, so we need to remove that attribute from
7252 remove_AT (c
, DW_AT_object_pointer
);
7254 replace_child (c
, clone
, prev
);
7255 generate_skeleton_ancestor_tree (parent
);
7256 add_child_die (parent
->new_die
, c
);
7261 generate_skeleton_bottom_up (&node
);
7262 } while (next
!= NULL
);
7265 /* Wrapper function for generate_skeleton_bottom_up. */
7268 generate_skeleton (dw_die_ref die
)
7270 skeleton_chain_node node
;
7273 node
.new_die
= NULL
;
7276 /* If this type definition is nested inside another type,
7277 and is not an instantiation of a template, always leave
7278 at least a declaration in its place. */
7279 if (die
->die_parent
!= NULL
7280 && is_type_die (die
->die_parent
)
7281 && !is_template_instantiation (die
))
7282 node
.new_die
= clone_as_declaration (die
);
7284 generate_skeleton_bottom_up (&node
);
7285 return node
.new_die
;
7288 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7289 declaration. The original DIE is moved to a new compile unit so that
7290 existing references to it follow it to the new location. If any of the
7291 original DIE's descendants is a declaration, we need to replace the
7292 original DIE with a skeleton tree and move the declarations back into the
7296 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
7299 dw_die_ref skeleton
, orig_parent
;
7301 /* Copy the declaration context to the type unit DIE. If the returned
7302 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7304 orig_parent
= copy_declaration_context (unit
, child
);
7306 skeleton
= generate_skeleton (child
);
7307 if (skeleton
== NULL
)
7308 remove_child_with_prev (child
, prev
);
7311 skeleton
->comdat_type_p
= true;
7312 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
7314 /* If the original DIE was a specification, we need to put
7315 the skeleton under the parent DIE of the declaration.
7316 This leaves the original declaration in the tree, but
7317 it will be pruned later since there are no longer any
7318 references to it. */
7319 if (orig_parent
!= NULL
)
7321 remove_child_with_prev (child
, prev
);
7322 add_child_die (orig_parent
, skeleton
);
7325 replace_child (child
, skeleton
, prev
);
7331 /* Traverse the DIE and set up additional .debug_types sections for each
7332 type worthy of being placed in a COMDAT section. */
7335 break_out_comdat_types (dw_die_ref die
)
7339 dw_die_ref prev
= NULL
;
7340 dw_die_ref next
= NULL
;
7341 dw_die_ref unit
= NULL
;
7343 first
= c
= die
->die_child
;
7347 if (prev
== NULL
|| prev
->die_sib
== c
)
7350 next
= (c
== first
? NULL
: c
->die_sib
);
7351 if (should_move_die_to_comdat (c
))
7353 dw_die_ref replacement
;
7354 comdat_type_node_ref type_node
;
7356 /* Break out nested types into their own type units. */
7357 break_out_comdat_types (c
);
7359 /* Create a new type unit DIE as the root for the new tree, and
7360 add it to the list of comdat types. */
7361 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
7362 add_AT_unsigned (unit
, DW_AT_language
,
7363 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
7364 type_node
= ggc_alloc_cleared_comdat_type_node ();
7365 type_node
->root_die
= unit
;
7366 type_node
->next
= comdat_type_list
;
7367 comdat_type_list
= type_node
;
7369 /* Generate the type signature. */
7370 generate_type_signature (c
, type_node
);
7372 /* Copy the declaration context, attributes, and children of the
7373 declaration into the new type unit DIE, then remove this DIE
7374 from the main CU (or replace it with a skeleton if necessary). */
7375 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
7376 type_node
->skeleton_die
= replacement
;
7378 /* Add the DIE to the new compunit. */
7379 add_child_die (unit
, c
);
7381 if (replacement
!= NULL
)
7384 else if (c
->die_tag
== DW_TAG_namespace
7385 || c
->die_tag
== DW_TAG_class_type
7386 || c
->die_tag
== DW_TAG_structure_type
7387 || c
->die_tag
== DW_TAG_union_type
)
7389 /* Look for nested types that can be broken out. */
7390 break_out_comdat_types (c
);
7392 } while (next
!= NULL
);
7395 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
7396 Enter all the cloned children into the hash table decl_table. */
7399 clone_tree_partial (dw_die_ref die
, decl_hash_type decl_table
)
7403 struct decl_table_entry
*entry
;
7404 decl_table_entry
**slot
;
7406 if (die
->die_tag
== DW_TAG_subprogram
)
7407 clone
= clone_as_declaration (die
);
7409 clone
= clone_die (die
);
7411 slot
= decl_table
.find_slot_with_hash (die
,
7412 htab_hash_pointer (die
), INSERT
);
7414 /* Assert that DIE isn't in the hash table yet. If it would be there
7415 before, the ancestors would be necessarily there as well, therefore
7416 clone_tree_partial wouldn't be called. */
7417 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
7419 entry
= XCNEW (struct decl_table_entry
);
7421 entry
->copy
= clone
;
7424 if (die
->die_tag
!= DW_TAG_subprogram
)
7425 FOR_EACH_CHILD (die
, c
,
7426 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
7431 /* Walk the DIE and its children, looking for references to incomplete
7432 or trivial types that are unmarked (i.e., that are not in the current
7436 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type decl_table
)
7442 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7444 if (AT_class (a
) == dw_val_class_die_ref
)
7446 dw_die_ref targ
= AT_ref (a
);
7447 decl_table_entry
**slot
;
7448 struct decl_table_entry
*entry
;
7450 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
7453 slot
= decl_table
.find_slot_with_hash (targ
, 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
)
7533 decl_hash_type decl_table
;
7536 decl_table
.create (10);
7537 copy_decls_walk (unit
, unit
, decl_table
);
7538 decl_table
.dispose ();
7542 /* Traverse the DIE and add a sibling attribute if it may have the
7543 effect of speeding up access to siblings. To save some space,
7544 avoid generating sibling attributes for DIE's without children. */
7547 add_sibling_attributes (dw_die_ref die
)
7551 if (! die
->die_child
)
7554 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
7555 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
7557 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
7560 /* Output all location lists for the DIE and its children. */
7563 output_location_lists (dw_die_ref die
)
7569 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7570 if (AT_class (a
) == dw_val_class_loc_list
)
7571 output_loc_list (AT_loc_list (a
));
7573 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
7576 /* We want to limit the number of external references, because they are
7577 larger than local references: a relocation takes multiple words, and
7578 even a sig8 reference is always eight bytes, whereas a local reference
7579 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
7580 So if we encounter multiple external references to the same type DIE, we
7581 make a local typedef stub for it and redirect all references there.
7583 This is the element of the hash table for keeping track of these
7593 /* Hashtable helpers. */
7595 struct external_ref_hasher
: typed_free_remove
<external_ref
>
7597 typedef external_ref value_type
;
7598 typedef external_ref compare_type
;
7599 static inline hashval_t
hash (const value_type
*);
7600 static inline bool equal (const value_type
*, const compare_type
*);
7604 external_ref_hasher::hash (const value_type
*r
)
7606 dw_die_ref die
= r
->type
;
7609 /* We can't use the address of the DIE for hashing, because
7610 that will make the order of the stub DIEs non-deterministic. */
7611 if (! die
->comdat_type_p
)
7612 /* We have a symbol; use it to compute a hash. */
7613 h
= htab_hash_string (die
->die_id
.die_symbol
);
7616 /* We have a type signature; use a subset of the bits as the hash.
7617 The 8-byte signature is at least as large as hashval_t. */
7618 comdat_type_node_ref type_node
= die
->die_id
.die_type_node
;
7619 memcpy (&h
, type_node
->signature
, sizeof (h
));
7625 external_ref_hasher::equal (const value_type
*r1
, const compare_type
*r2
)
7627 return r1
->type
== r2
->type
;
7630 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
7632 /* Return a pointer to the external_ref for references to DIE. */
7634 static struct external_ref
*
7635 lookup_external_ref (external_ref_hash_type map
, dw_die_ref die
)
7637 struct external_ref ref
, *ref_p
;
7638 external_ref
**slot
;
7641 slot
= map
.find_slot (&ref
, INSERT
);
7642 if (*slot
!= HTAB_EMPTY_ENTRY
)
7645 ref_p
= XCNEW (struct external_ref
);
7651 /* Subroutine of optimize_external_refs, below.
7653 If we see a type skeleton, record it as our stub. If we see external
7654 references, remember how many we've seen. */
7657 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type map
)
7662 struct external_ref
*ref_p
;
7664 if (is_type_die (die
)
7665 && (c
= get_AT_ref (die
, DW_AT_signature
)))
7667 /* This is a local skeleton; use it for local references. */
7668 ref_p
= lookup_external_ref (map
, c
);
7672 /* Scan the DIE references, and remember any that refer to DIEs from
7673 other CUs (i.e. those which are not marked). */
7674 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7675 if (AT_class (a
) == dw_val_class_die_ref
7676 && (c
= AT_ref (a
))->die_mark
== 0
7679 ref_p
= lookup_external_ref (map
, c
);
7683 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
7686 /* htab_traverse callback function for optimize_external_refs, below. SLOT
7687 points to an external_ref, DATA is the CU we're processing. If we don't
7688 already have a local stub, and we have multiple refs, build a stub. */
7691 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
7693 struct external_ref
*ref_p
= *slot
;
7695 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
7697 /* We have multiple references to this type, so build a small stub.
7698 Both of these forms are a bit dodgy from the perspective of the
7699 DWARF standard, since technically they should have names. */
7700 dw_die_ref cu
= data
;
7701 dw_die_ref type
= ref_p
->type
;
7702 dw_die_ref stub
= NULL
;
7704 if (type
->comdat_type_p
)
7706 /* If we refer to this type via sig8, use AT_signature. */
7707 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
7708 add_AT_die_ref (stub
, DW_AT_signature
, type
);
7712 /* Otherwise, use a typedef with no name. */
7713 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
7714 add_AT_die_ref (stub
, DW_AT_type
, type
);
7723 /* DIE is a unit; look through all the DIE references to see if there are
7724 any external references to types, and if so, create local stubs for
7725 them which will be applied in build_abbrev_table. This is useful because
7726 references to local DIEs are smaller. */
7728 static external_ref_hash_type
7729 optimize_external_refs (dw_die_ref die
)
7731 external_ref_hash_type map
;
7733 optimize_external_refs_1 (die
, map
);
7734 map
.traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
7738 /* The format of each DIE (and its attribute value pairs) is encoded in an
7739 abbreviation table. This routine builds the abbreviation table and assigns
7740 a unique abbreviation id for each abbreviation entry. The children of each
7741 die are visited recursively. */
7744 build_abbrev_table (dw_die_ref die
, external_ref_hash_type extern_map
)
7746 unsigned long abbrev_id
;
7747 unsigned int n_alloc
;
7752 /* Scan the DIE references, and replace any that refer to
7753 DIEs from other CUs (i.e. those which are not marked) with
7754 the local stubs we built in optimize_external_refs. */
7755 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7756 if (AT_class (a
) == dw_val_class_die_ref
7757 && (c
= AT_ref (a
))->die_mark
== 0)
7759 struct external_ref
*ref_p
;
7760 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
7762 ref_p
= lookup_external_ref (extern_map
, c
);
7763 if (ref_p
->stub
&& ref_p
->stub
!= die
)
7764 change_AT_die_ref (a
, ref_p
->stub
);
7766 /* We aren't changing this reference, so mark it external. */
7767 set_AT_ref_external (a
, 1);
7770 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
7772 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
7773 dw_attr_ref die_a
, abbrev_a
;
7777 if (abbrev
->die_tag
!= die
->die_tag
)
7779 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
7782 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
7785 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
7787 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
7788 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
7789 || (value_format (abbrev_a
) != value_format (die_a
)))
7799 if (abbrev_id
>= abbrev_die_table_in_use
)
7801 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
7803 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
7804 abbrev_die_table
= GGC_RESIZEVEC (dw_die_ref
, abbrev_die_table
,
7807 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
7808 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
7809 abbrev_die_table_allocated
= n_alloc
;
7812 ++abbrev_die_table_in_use
;
7813 abbrev_die_table
[abbrev_id
] = die
;
7816 die
->die_abbrev
= abbrev_id
;
7817 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
7820 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7823 constant_size (unsigned HOST_WIDE_INT value
)
7830 log
= floor_log2 (value
);
7833 log
= 1 << (floor_log2 (log
) + 1);
7838 /* Return the size of a DIE as it is represented in the
7839 .debug_info section. */
7841 static unsigned long
7842 size_of_die (dw_die_ref die
)
7844 unsigned long size
= 0;
7847 enum dwarf_form form
;
7849 size
+= size_of_uleb128 (die
->die_abbrev
);
7850 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7852 switch (AT_class (a
))
7854 case dw_val_class_addr
:
7855 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7857 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7858 size
+= size_of_uleb128 (AT_index (a
));
7861 size
+= DWARF2_ADDR_SIZE
;
7863 case dw_val_class_offset
:
7864 size
+= DWARF_OFFSET_SIZE
;
7866 case dw_val_class_loc
:
7868 unsigned long lsize
= size_of_locs (AT_loc (a
));
7871 if (dwarf_version
>= 4)
7872 size
+= size_of_uleb128 (lsize
);
7874 size
+= constant_size (lsize
);
7878 case dw_val_class_loc_list
:
7879 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7881 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7882 size
+= size_of_uleb128 (AT_index (a
));
7885 size
+= DWARF_OFFSET_SIZE
;
7887 case dw_val_class_range_list
:
7888 size
+= DWARF_OFFSET_SIZE
;
7890 case dw_val_class_const
:
7891 size
+= size_of_sleb128 (AT_int (a
));
7893 case dw_val_class_unsigned_const
:
7895 int csize
= constant_size (AT_unsigned (a
));
7896 if (dwarf_version
== 3
7897 && a
->dw_attr
== DW_AT_data_member_location
7899 size
+= size_of_uleb128 (AT_unsigned (a
));
7904 case dw_val_class_const_double
:
7905 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
7906 if (HOST_BITS_PER_WIDE_INT
>= 64)
7909 case dw_val_class_wide_int
:
7910 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
7911 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7912 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
7916 case dw_val_class_vec
:
7917 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
7918 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
7919 + a
->dw_attr_val
.v
.val_vec
.length
7920 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
7922 case dw_val_class_flag
:
7923 if (dwarf_version
>= 4)
7924 /* Currently all add_AT_flag calls pass in 1 as last argument,
7925 so DW_FORM_flag_present can be used. If that ever changes,
7926 we'll need to use DW_FORM_flag and have some optimization
7927 in build_abbrev_table that will change those to
7928 DW_FORM_flag_present if it is set to 1 in all DIEs using
7929 the same abbrev entry. */
7930 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
7934 case dw_val_class_die_ref
:
7935 if (AT_ref_external (a
))
7937 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
7938 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
7939 is sized by target address length, whereas in DWARF3
7940 it's always sized as an offset. */
7941 if (use_debug_types
)
7942 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
7943 else if (dwarf_version
== 2)
7944 size
+= DWARF2_ADDR_SIZE
;
7946 size
+= DWARF_OFFSET_SIZE
;
7949 size
+= DWARF_OFFSET_SIZE
;
7951 case dw_val_class_fde_ref
:
7952 size
+= DWARF_OFFSET_SIZE
;
7954 case dw_val_class_lbl_id
:
7955 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7957 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7958 size
+= size_of_uleb128 (AT_index (a
));
7961 size
+= DWARF2_ADDR_SIZE
;
7963 case dw_val_class_lineptr
:
7964 case dw_val_class_macptr
:
7965 size
+= DWARF_OFFSET_SIZE
;
7967 case dw_val_class_str
:
7968 form
= AT_string_form (a
);
7969 if (form
== DW_FORM_strp
)
7970 size
+= DWARF_OFFSET_SIZE
;
7971 else if (form
== DW_FORM_GNU_str_index
)
7972 size
+= size_of_uleb128 (AT_index (a
));
7974 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
7976 case dw_val_class_file
:
7977 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
7979 case dw_val_class_data8
:
7982 case dw_val_class_vms_delta
:
7983 size
+= DWARF_OFFSET_SIZE
;
7985 case dw_val_class_high_pc
:
7986 size
+= DWARF2_ADDR_SIZE
;
7996 /* Size the debugging information associated with a given DIE. Visits the
7997 DIE's children recursively. Updates the global variable next_die_offset, on
7998 each time through. Uses the current value of next_die_offset to update the
7999 die_offset field in each DIE. */
8002 calc_die_sizes (dw_die_ref die
)
8006 gcc_assert (die
->die_offset
== 0
8007 || (unsigned long int) die
->die_offset
== next_die_offset
);
8008 die
->die_offset
= next_die_offset
;
8009 next_die_offset
+= size_of_die (die
);
8011 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
8013 if (die
->die_child
!= NULL
)
8014 /* Count the null byte used to terminate sibling lists. */
8015 next_die_offset
+= 1;
8018 /* Size just the base type children at the start of the CU.
8019 This is needed because build_abbrev needs to size locs
8020 and sizing of type based stack ops needs to know die_offset
8021 values for the base types. */
8024 calc_base_type_die_sizes (void)
8026 unsigned long die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8028 dw_die_ref base_type
;
8029 #if ENABLE_ASSERT_CHECKING
8030 dw_die_ref prev
= comp_unit_die ()->die_child
;
8033 die_offset
+= size_of_die (comp_unit_die ());
8034 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
8036 #if ENABLE_ASSERT_CHECKING
8037 gcc_assert (base_type
->die_offset
== 0
8038 && prev
->die_sib
== base_type
8039 && base_type
->die_child
== NULL
8040 && base_type
->die_abbrev
);
8043 base_type
->die_offset
= die_offset
;
8044 die_offset
+= size_of_die (base_type
);
8048 /* Set the marks for a die and its children. We do this so
8049 that we know whether or not a reference needs to use FORM_ref_addr; only
8050 DIEs in the same CU will be marked. We used to clear out the offset
8051 and use that as the flag, but ran into ordering problems. */
8054 mark_dies (dw_die_ref die
)
8058 gcc_assert (!die
->die_mark
);
8061 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
8064 /* Clear the marks for a die and its children. */
8067 unmark_dies (dw_die_ref die
)
8071 if (! use_debug_types
)
8072 gcc_assert (die
->die_mark
);
8075 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
8078 /* Clear the marks for a die, its children and referred dies. */
8081 unmark_all_dies (dw_die_ref die
)
8091 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
8093 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8094 if (AT_class (a
) == dw_val_class_die_ref
)
8095 unmark_all_dies (AT_ref (a
));
8098 /* Calculate if the entry should appear in the final output file. It may be
8099 from a pruned a type. */
8102 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
8104 /* By limiting gnu pubnames to definitions only, gold can generate a
8105 gdb index without entries for declarations, which don't include
8106 enough information to be useful. */
8107 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
8110 if (table
== pubname_table
)
8112 /* Enumerator names are part of the pubname table, but the
8113 parent DW_TAG_enumeration_type die may have been pruned.
8114 Don't output them if that is the case. */
8115 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
8116 (p
->die
->die_parent
== NULL
8117 || !p
->die
->die_parent
->die_perennial_p
))
8120 /* Everything else in the pubname table is included. */
8124 /* The pubtypes table shouldn't include types that have been
8126 return (p
->die
->die_offset
!= 0
8127 || !flag_eliminate_unused_debug_types
);
8130 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8131 generated for the compilation unit. */
8133 static unsigned long
8134 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
8139 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
8141 size
= DWARF_PUBNAMES_HEADER_SIZE
;
8142 FOR_EACH_VEC_ELT (*names
, i
, p
)
8143 if (include_pubname_in_output (names
, p
))
8144 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
8146 size
+= DWARF_OFFSET_SIZE
;
8150 /* Return the size of the information in the .debug_aranges section. */
8152 static unsigned long
8153 size_of_aranges (void)
8157 size
= DWARF_ARANGES_HEADER_SIZE
;
8159 /* Count the address/length pair for this compilation unit. */
8160 if (text_section_used
)
8161 size
+= 2 * DWARF2_ADDR_SIZE
;
8162 if (cold_text_section_used
)
8163 size
+= 2 * DWARF2_ADDR_SIZE
;
8164 if (have_multiple_function_sections
)
8169 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
8171 if (DECL_IGNORED_P (fde
->decl
))
8173 if (!fde
->in_std_section
)
8174 size
+= 2 * DWARF2_ADDR_SIZE
;
8175 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
8176 size
+= 2 * DWARF2_ADDR_SIZE
;
8180 /* Count the two zero words used to terminated the address range table. */
8181 size
+= 2 * DWARF2_ADDR_SIZE
;
8185 /* Select the encoding of an attribute value. */
8187 static enum dwarf_form
8188 value_format (dw_attr_ref a
)
8190 switch (AT_class (a
))
8192 case dw_val_class_addr
:
8193 /* Only very few attributes allow DW_FORM_addr. */
8198 case DW_AT_entry_pc
:
8199 case DW_AT_trampoline
:
8200 return (AT_index (a
) == NOT_INDEXED
8201 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8205 switch (DWARF2_ADDR_SIZE
)
8208 return DW_FORM_data1
;
8210 return DW_FORM_data2
;
8212 return DW_FORM_data4
;
8214 return DW_FORM_data8
;
8218 case dw_val_class_range_list
:
8219 case dw_val_class_loc_list
:
8220 if (dwarf_version
>= 4)
8221 return DW_FORM_sec_offset
;
8223 case dw_val_class_vms_delta
:
8224 case dw_val_class_offset
:
8225 switch (DWARF_OFFSET_SIZE
)
8228 return DW_FORM_data4
;
8230 return DW_FORM_data8
;
8234 case dw_val_class_loc
:
8235 if (dwarf_version
>= 4)
8236 return DW_FORM_exprloc
;
8237 switch (constant_size (size_of_locs (AT_loc (a
))))
8240 return DW_FORM_block1
;
8242 return DW_FORM_block2
;
8244 return DW_FORM_block4
;
8248 case dw_val_class_const
:
8249 return DW_FORM_sdata
;
8250 case dw_val_class_unsigned_const
:
8251 switch (constant_size (AT_unsigned (a
)))
8254 return DW_FORM_data1
;
8256 return DW_FORM_data2
;
8258 /* In DWARF3 DW_AT_data_member_location with
8259 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8260 constant, so we need to use DW_FORM_udata if we need
8261 a large constant. */
8262 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8263 return DW_FORM_udata
;
8264 return DW_FORM_data4
;
8266 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8267 return DW_FORM_udata
;
8268 return DW_FORM_data8
;
8272 case dw_val_class_const_double
:
8273 switch (HOST_BITS_PER_WIDE_INT
)
8276 return DW_FORM_data2
;
8278 return DW_FORM_data4
;
8280 return DW_FORM_data8
;
8283 return DW_FORM_block1
;
8285 case dw_val_class_wide_int
:
8286 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
8289 return DW_FORM_data1
;
8291 return DW_FORM_data2
;
8293 return DW_FORM_data4
;
8295 return DW_FORM_data8
;
8297 return DW_FORM_block1
;
8299 case dw_val_class_vec
:
8300 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
8301 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
8304 return DW_FORM_block1
;
8306 return DW_FORM_block2
;
8308 return DW_FORM_block4
;
8312 case dw_val_class_flag
:
8313 if (dwarf_version
>= 4)
8315 /* Currently all add_AT_flag calls pass in 1 as last argument,
8316 so DW_FORM_flag_present can be used. If that ever changes,
8317 we'll need to use DW_FORM_flag and have some optimization
8318 in build_abbrev_table that will change those to
8319 DW_FORM_flag_present if it is set to 1 in all DIEs using
8320 the same abbrev entry. */
8321 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
8322 return DW_FORM_flag_present
;
8324 return DW_FORM_flag
;
8325 case dw_val_class_die_ref
:
8326 if (AT_ref_external (a
))
8327 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
8330 case dw_val_class_fde_ref
:
8331 return DW_FORM_data
;
8332 case dw_val_class_lbl_id
:
8333 return (AT_index (a
) == NOT_INDEXED
8334 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8335 case dw_val_class_lineptr
:
8336 case dw_val_class_macptr
:
8337 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
8338 case dw_val_class_str
:
8339 return AT_string_form (a
);
8340 case dw_val_class_file
:
8341 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
8344 return DW_FORM_data1
;
8346 return DW_FORM_data2
;
8348 return DW_FORM_data4
;
8353 case dw_val_class_data8
:
8354 return DW_FORM_data8
;
8356 case dw_val_class_high_pc
:
8357 switch (DWARF2_ADDR_SIZE
)
8360 return DW_FORM_data1
;
8362 return DW_FORM_data2
;
8364 return DW_FORM_data4
;
8366 return DW_FORM_data8
;
8376 /* Output the encoding of an attribute value. */
8379 output_value_format (dw_attr_ref a
)
8381 enum dwarf_form form
= value_format (a
);
8383 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
8386 /* Given a die and id, produce the appropriate abbreviations. */
8389 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
8394 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
8395 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
8396 dwarf_tag_name (abbrev
->die_tag
));
8398 if (abbrev
->die_child
!= NULL
)
8399 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
8401 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
8403 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
8405 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
8406 dwarf_attr_name (a_attr
->dw_attr
));
8407 output_value_format (a_attr
);
8410 dw2_asm_output_data (1, 0, NULL
);
8411 dw2_asm_output_data (1, 0, NULL
);
8415 /* Output the .debug_abbrev section which defines the DIE abbreviation
8419 output_abbrev_section (void)
8421 unsigned long abbrev_id
;
8423 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
8424 output_die_abbrevs (abbrev_id
, abbrev_die_table
[abbrev_id
]);
8426 /* Terminate the table. */
8427 dw2_asm_output_data (1, 0, NULL
);
8430 /* Output a symbol we can use to refer to this DIE from another CU. */
8433 output_die_symbol (dw_die_ref die
)
8435 const char *sym
= die
->die_id
.die_symbol
;
8437 gcc_assert (!die
->comdat_type_p
);
8442 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
8443 /* We make these global, not weak; if the target doesn't support
8444 .linkonce, it doesn't support combining the sections, so debugging
8446 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
8448 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
8451 /* Return a new location list, given the begin and end range, and the
8454 static inline dw_loc_list_ref
8455 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
8456 const char *section
)
8458 dw_loc_list_ref retlist
= ggc_alloc_cleared_dw_loc_list_node ();
8460 retlist
->begin
= begin
;
8461 retlist
->begin_entry
= NULL
;
8463 retlist
->expr
= expr
;
8464 retlist
->section
= section
;
8469 /* Generate a new internal symbol for this location list node, if it
8470 hasn't got one yet. */
8473 gen_llsym (dw_loc_list_ref list
)
8475 gcc_assert (!list
->ll_symbol
);
8476 list
->ll_symbol
= gen_internal_sym ("LLST");
8479 /* Output the location list given to us. */
8482 output_loc_list (dw_loc_list_ref list_head
)
8484 dw_loc_list_ref curr
= list_head
;
8486 if (list_head
->emitted
)
8488 list_head
->emitted
= true;
8490 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
8492 /* Walk the location list, and output each range + expression. */
8493 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
8496 /* Don't output an entry that starts and ends at the same address. */
8497 if (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
)
8499 size
= size_of_locs (curr
->expr
);
8500 /* If the expression is too large, drop it on the floor. We could
8501 perhaps put it into DW_TAG_dwarf_procedure and refer to that
8502 in the expression, but >= 64KB expressions for a single value
8503 in a single range are unlikely very useful. */
8506 if (dwarf_split_debug_info
)
8508 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
8509 "Location list start/length entry (%s)",
8510 list_head
->ll_symbol
);
8511 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
8512 "Location list range start index (%s)",
8514 /* The length field is 4 bytes. If we ever need to support
8515 an 8-byte length, we can add a new DW_LLE code or fall back
8516 to DW_LLE_GNU_start_end_entry. */
8517 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
8518 "Location list range length (%s)",
8519 list_head
->ll_symbol
);
8521 else if (!have_multiple_function_sections
)
8523 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
8524 "Location list begin address (%s)",
8525 list_head
->ll_symbol
);
8526 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
8527 "Location list end address (%s)",
8528 list_head
->ll_symbol
);
8532 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
8533 "Location list begin address (%s)",
8534 list_head
->ll_symbol
);
8535 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
8536 "Location list end address (%s)",
8537 list_head
->ll_symbol
);
8540 /* Output the block length for this list of location operations. */
8541 gcc_assert (size
<= 0xffff);
8542 dw2_asm_output_data (2, size
, "%s", "Location expression size");
8544 output_loc_sequence (curr
->expr
, -1);
8547 if (dwarf_split_debug_info
)
8548 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
8549 "Location list terminator (%s)",
8550 list_head
->ll_symbol
);
8553 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8554 "Location list terminator begin (%s)",
8555 list_head
->ll_symbol
);
8556 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8557 "Location list terminator end (%s)",
8558 list_head
->ll_symbol
);
8562 /* Output a range_list offset into the debug_range section. Emit a
8563 relocated reference if val_entry is NULL, otherwise, emit an
8564 indirect reference. */
8567 output_range_list_offset (dw_attr_ref a
)
8569 const char *name
= dwarf_attr_name (a
->dw_attr
);
8571 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
8573 char *p
= strchr (ranges_section_label
, '\0');
8574 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
, a
->dw_attr_val
.v
.val_offset
);
8575 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
8576 debug_ranges_section
, "%s", name
);
8580 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8581 "%s (offset from %s)", name
, ranges_section_label
);
8584 /* Output the offset into the debug_loc section. */
8587 output_loc_list_offset (dw_attr_ref a
)
8589 char *sym
= AT_loc_list (a
)->ll_symbol
;
8592 if (dwarf_split_debug_info
)
8593 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
8594 "%s", dwarf_attr_name (a
->dw_attr
));
8596 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
8597 "%s", dwarf_attr_name (a
->dw_attr
));
8600 /* Output an attribute's index or value appropriately. */
8603 output_attr_index_or_value (dw_attr_ref a
)
8605 const char *name
= dwarf_attr_name (a
->dw_attr
);
8607 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8609 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
8612 switch (AT_class (a
))
8614 case dw_val_class_addr
:
8615 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
8617 case dw_val_class_high_pc
:
8618 case dw_val_class_lbl_id
:
8619 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
8621 case dw_val_class_loc_list
:
8622 output_loc_list_offset (a
);
8629 /* Output a type signature. */
8632 output_signature (const char *sig
, const char *name
)
8636 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
8637 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
8640 /* Output the DIE and its attributes. Called recursively to generate
8641 the definitions of each child DIE. */
8644 output_die (dw_die_ref die
)
8651 /* If someone in another CU might refer to us, set up a symbol for
8652 them to point to. */
8653 if (! die
->comdat_type_p
&& die
->die_id
.die_symbol
)
8654 output_die_symbol (die
);
8656 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
8657 (unsigned long)die
->die_offset
,
8658 dwarf_tag_name (die
->die_tag
));
8660 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8662 const char *name
= dwarf_attr_name (a
->dw_attr
);
8664 switch (AT_class (a
))
8666 case dw_val_class_addr
:
8667 output_attr_index_or_value (a
);
8670 case dw_val_class_offset
:
8671 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8675 case dw_val_class_range_list
:
8676 output_range_list_offset (a
);
8679 case dw_val_class_loc
:
8680 size
= size_of_locs (AT_loc (a
));
8682 /* Output the block length for this list of location operations. */
8683 if (dwarf_version
>= 4)
8684 dw2_asm_output_data_uleb128 (size
, "%s", name
);
8686 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
8688 output_loc_sequence (AT_loc (a
), -1);
8691 case dw_val_class_const
:
8692 /* ??? It would be slightly more efficient to use a scheme like is
8693 used for unsigned constants below, but gdb 4.x does not sign
8694 extend. Gdb 5.x does sign extend. */
8695 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
8698 case dw_val_class_unsigned_const
:
8700 int csize
= constant_size (AT_unsigned (a
));
8701 if (dwarf_version
== 3
8702 && a
->dw_attr
== DW_AT_data_member_location
8704 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
8706 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
8710 case dw_val_class_const_double
:
8712 unsigned HOST_WIDE_INT first
, second
;
8714 if (HOST_BITS_PER_WIDE_INT
>= 64)
8715 dw2_asm_output_data (1,
8716 HOST_BITS_PER_DOUBLE_INT
8717 / HOST_BITS_PER_CHAR
,
8720 if (WORDS_BIG_ENDIAN
)
8722 first
= a
->dw_attr_val
.v
.val_double
.high
;
8723 second
= a
->dw_attr_val
.v
.val_double
.low
;
8727 first
= a
->dw_attr_val
.v
.val_double
.low
;
8728 second
= a
->dw_attr_val
.v
.val_double
.high
;
8731 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8733 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8738 case dw_val_class_wide_int
:
8741 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
8742 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
8743 if (len
* HOST_BITS_PER_WIDE_INT
> 64)
8744 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
) * l
,
8747 if (WORDS_BIG_ENDIAN
)
8748 for (i
= len
- 1; i
>= 0; --i
)
8750 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
8755 for (i
= 0; i
< len
; ++i
)
8757 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
8764 case dw_val_class_vec
:
8766 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
8767 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
8771 dw2_asm_output_data (constant_size (len
* elt_size
),
8772 len
* elt_size
, "%s", name
);
8773 if (elt_size
> sizeof (HOST_WIDE_INT
))
8778 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
8781 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
8782 "fp or vector constant word %u", i
);
8786 case dw_val_class_flag
:
8787 if (dwarf_version
>= 4)
8789 /* Currently all add_AT_flag calls pass in 1 as last argument,
8790 so DW_FORM_flag_present can be used. If that ever changes,
8791 we'll need to use DW_FORM_flag and have some optimization
8792 in build_abbrev_table that will change those to
8793 DW_FORM_flag_present if it is set to 1 in all DIEs using
8794 the same abbrev entry. */
8795 gcc_assert (AT_flag (a
) == 1);
8797 fprintf (asm_out_file
, "\t\t\t%s %s\n",
8798 ASM_COMMENT_START
, name
);
8801 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
8804 case dw_val_class_loc_list
:
8805 output_attr_index_or_value (a
);
8808 case dw_val_class_die_ref
:
8809 if (AT_ref_external (a
))
8811 if (AT_ref (a
)->comdat_type_p
)
8813 comdat_type_node_ref type_node
=
8814 AT_ref (a
)->die_id
.die_type_node
;
8816 gcc_assert (type_node
);
8817 output_signature (type_node
->signature
, name
);
8821 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
8825 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8826 length, whereas in DWARF3 it's always sized as an
8828 if (dwarf_version
== 2)
8829 size
= DWARF2_ADDR_SIZE
;
8831 size
= DWARF_OFFSET_SIZE
;
8832 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
8838 gcc_assert (AT_ref (a
)->die_offset
);
8839 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
8844 case dw_val_class_fde_ref
:
8848 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
8849 a
->dw_attr_val
.v
.val_fde_index
* 2);
8850 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
8855 case dw_val_class_vms_delta
:
8856 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
8857 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
8861 case dw_val_class_lbl_id
:
8862 output_attr_index_or_value (a
);
8865 case dw_val_class_lineptr
:
8866 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8867 debug_line_section
, "%s", name
);
8870 case dw_val_class_macptr
:
8871 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8872 debug_macinfo_section
, "%s", name
);
8875 case dw_val_class_str
:
8876 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
8877 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
8878 a
->dw_attr_val
.v
.val_str
->label
,
8880 "%s: \"%s\"", name
, AT_string (a
));
8881 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_GNU_str_index
)
8882 dw2_asm_output_data_uleb128 (AT_index (a
),
8883 "%s: \"%s\"", name
, AT_string (a
));
8885 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
8888 case dw_val_class_file
:
8890 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
8892 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
8893 a
->dw_attr_val
.v
.val_file
->filename
);
8897 case dw_val_class_data8
:
8901 for (i
= 0; i
< 8; i
++)
8902 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
8903 i
== 0 ? "%s" : NULL
, name
);
8907 case dw_val_class_high_pc
:
8908 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
8909 get_AT_low_pc (die
), "DW_AT_high_pc");
8917 FOR_EACH_CHILD (die
, c
, output_die (c
));
8919 /* Add null byte to terminate sibling list. */
8920 if (die
->die_child
!= NULL
)
8921 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
8922 (unsigned long) die
->die_offset
);
8925 /* Output the compilation unit that appears at the beginning of the
8926 .debug_info section, and precedes the DIE descriptions. */
8929 output_compilation_unit_header (void)
8931 int ver
= dwarf_version
;
8933 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8934 dw2_asm_output_data (4, 0xffffffff,
8935 "Initial length escape value indicating 64-bit DWARF extension");
8936 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
8937 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
8938 "Length of Compilation Unit Info");
8939 dw2_asm_output_data (2, ver
, "DWARF version number");
8940 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
8941 debug_abbrev_section
,
8942 "Offset Into Abbrev. Section");
8943 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
8946 /* Output the compilation unit DIE and its children. */
8949 output_comp_unit (dw_die_ref die
, int output_if_empty
)
8951 const char *secname
, *oldsym
;
8953 external_ref_hash_type extern_map
;
8955 /* Unless we are outputting main CU, we may throw away empty ones. */
8956 if (!output_if_empty
&& die
->die_child
== NULL
)
8959 /* Even if there are no children of this DIE, we must output the information
8960 about the compilation unit. Otherwise, on an empty translation unit, we
8961 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8962 will then complain when examining the file. First mark all the DIEs in
8963 this CU so we know which get local refs. */
8966 extern_map
= optimize_external_refs (die
);
8968 build_abbrev_table (die
, extern_map
);
8970 extern_map
.dispose ();
8972 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8973 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8974 calc_die_sizes (die
);
8976 oldsym
= die
->die_id
.die_symbol
;
8979 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
8981 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
8983 die
->die_id
.die_symbol
= NULL
;
8984 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
8988 switch_to_section (debug_info_section
);
8989 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
8990 info_section_emitted
= true;
8993 /* Output debugging information. */
8994 output_compilation_unit_header ();
8997 /* Leave the marks on the main CU, so we can check them in
9002 die
->die_id
.die_symbol
= oldsym
;
9006 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
9007 and .debug_pubtypes. This is configured per-target, but can be
9008 overridden by the -gpubnames or -gno-pubnames options. */
9011 want_pubnames (void)
9013 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9015 if (debug_generate_pub_sections
!= -1)
9016 return debug_generate_pub_sections
;
9017 return targetm
.want_debug_pub_sections
;
9020 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
9023 add_AT_pubnames (dw_die_ref die
)
9025 if (want_pubnames ())
9026 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
9029 /* Add a string attribute value to a skeleton DIE. */
9032 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
9036 struct indirect_string_node
*node
;
9038 if (! skeleton_debug_str_hash
)
9039 skeleton_debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
9040 debug_str_eq
, NULL
);
9042 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
9043 find_string_form (node
);
9044 if (node
->form
== DW_FORM_GNU_str_index
)
9045 node
->form
= DW_FORM_strp
;
9047 attr
.dw_attr
= attr_kind
;
9048 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
9049 attr
.dw_attr_val
.val_entry
= NULL
;
9050 attr
.dw_attr_val
.v
.val_str
= node
;
9051 add_dwarf_attr (die
, &attr
);
9054 /* Helper function to generate top-level dies for skeleton debug_info and
9058 add_top_level_skeleton_die_attrs (dw_die_ref die
)
9060 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
9061 const char *comp_dir
= comp_dir_string ();
9063 add_skeleton_AT_string (die
, DW_AT_GNU_dwo_name
, dwo_file_name
);
9064 if (comp_dir
!= NULL
)
9065 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
9066 add_AT_pubnames (die
);
9067 add_AT_lineptr (die
, DW_AT_GNU_addr_base
, debug_addr_section_label
);
9070 /* Return the single type-unit die for skeleton type units. */
9073 get_skeleton_type_unit (void)
9075 /* For dwarf_split_debug_sections with use_type info, all type units in the
9076 skeleton sections have identical dies (but different headers). This
9077 single die will be output many times. */
9079 static dw_die_ref skeleton_type_unit
= NULL
;
9081 if (skeleton_type_unit
== NULL
)
9083 skeleton_type_unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
9084 add_top_level_skeleton_die_attrs (skeleton_type_unit
);
9085 skeleton_type_unit
->die_abbrev
= SKELETON_TYPE_DIE_ABBREV
;
9087 return skeleton_type_unit
;
9090 /* Output skeleton debug sections that point to the dwo file. */
9093 output_skeleton_debug_sections (dw_die_ref comp_unit
)
9095 /* These attributes will be found in the full debug_info section. */
9096 remove_AT (comp_unit
, DW_AT_producer
);
9097 remove_AT (comp_unit
, DW_AT_language
);
9099 switch_to_section (debug_skeleton_info_section
);
9100 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
9102 /* Produce the skeleton compilation-unit header. This one differs enough from
9103 a normal CU header that it's better not to call output_compilation_unit
9105 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9106 dw2_asm_output_data (4, 0xffffffff,
9107 "Initial length escape value indicating 64-bit DWARF extension");
9109 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9110 DWARF_COMPILE_UNIT_HEADER_SIZE
9111 - DWARF_INITIAL_LENGTH_SIZE
9112 + size_of_die (comp_unit
),
9113 "Length of Compilation Unit Info");
9114 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
9115 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
9116 debug_abbrev_section
,
9117 "Offset Into Abbrev. Section");
9118 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
9120 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
9121 output_die (comp_unit
);
9123 /* Build the skeleton debug_abbrev section. */
9124 switch_to_section (debug_skeleton_abbrev_section
);
9125 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
9127 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
9128 if (use_debug_types
)
9129 output_die_abbrevs (SKELETON_TYPE_DIE_ABBREV
, get_skeleton_type_unit ());
9131 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
9134 /* Output a comdat type unit DIE and its children. */
9137 output_comdat_type_unit (comdat_type_node
*node
)
9139 const char *secname
;
9142 #if defined (OBJECT_FORMAT_ELF)
9145 external_ref_hash_type extern_map
;
9147 /* First mark all the DIEs in this CU so we know which get local refs. */
9148 mark_dies (node
->root_die
);
9150 extern_map
= optimize_external_refs (node
->root_die
);
9152 build_abbrev_table (node
->root_die
, extern_map
);
9154 extern_map
.dispose ();
9156 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9157 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
9158 calc_die_sizes (node
->root_die
);
9160 #if defined (OBJECT_FORMAT_ELF)
9161 if (!dwarf_split_debug_info
)
9162 secname
= ".debug_types";
9164 secname
= ".debug_types.dwo";
9166 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9167 sprintf (tmp
, "wt.");
9168 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9169 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9170 comdat_key
= get_identifier (tmp
);
9171 targetm
.asm_out
.named_section (secname
,
9172 SECTION_DEBUG
| SECTION_LINKONCE
,
9175 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9176 sprintf (tmp
, ".gnu.linkonce.wt.");
9177 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9178 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9180 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
9183 /* Output debugging information. */
9184 output_compilation_unit_header ();
9185 output_signature (node
->signature
, "Type Signature");
9186 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
9187 "Offset to Type DIE");
9188 output_die (node
->root_die
);
9190 unmark_dies (node
->root_die
);
9192 #if defined (OBJECT_FORMAT_ELF)
9193 if (dwarf_split_debug_info
)
9195 /* Produce the skeleton type-unit header. */
9196 const char *secname
= ".debug_types";
9198 targetm
.asm_out
.named_section (secname
,
9199 SECTION_DEBUG
| SECTION_LINKONCE
,
9201 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9202 dw2_asm_output_data (4, 0xffffffff,
9203 "Initial length escape value indicating 64-bit DWARF extension");
9205 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9206 DWARF_COMPILE_UNIT_HEADER_SIZE
9207 - DWARF_INITIAL_LENGTH_SIZE
9208 + size_of_die (get_skeleton_type_unit ())
9209 + DWARF_TYPE_SIGNATURE_SIZE
+ DWARF_OFFSET_SIZE
,
9210 "Length of Type Unit Info");
9211 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
9212 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
9213 debug_skeleton_abbrev_section_label
,
9214 debug_abbrev_section
,
9215 "Offset Into Abbrev. Section");
9216 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
9217 output_signature (node
->signature
, "Type Signature");
9218 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, "Offset to Type DIE");
9220 output_die (get_skeleton_type_unit ());
9225 /* Return the DWARF2/3 pubname associated with a decl. */
9228 dwarf2_name (tree decl
, int scope
)
9230 if (DECL_NAMELESS (decl
))
9232 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
9235 /* Add a new entry to .debug_pubnames if appropriate. */
9238 add_pubname_string (const char *str
, dw_die_ref die
)
9243 e
.name
= xstrdup (str
);
9244 vec_safe_push (pubname_table
, e
);
9248 add_pubname (tree decl
, dw_die_ref die
)
9250 if (!want_pubnames ())
9253 /* Don't add items to the table when we expect that the consumer will have
9254 just read the enclosing die. For example, if the consumer is looking at a
9255 class_member, it will either be inside the class already, or will have just
9256 looked up the class to find the member. Either way, searching the class is
9257 faster than searching the index. */
9258 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
9259 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9261 const char *name
= dwarf2_name (decl
, 1);
9264 add_pubname_string (name
, die
);
9268 /* Add an enumerator to the pubnames section. */
9271 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
9275 gcc_assert (scope_name
);
9276 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
9278 vec_safe_push (pubname_table
, e
);
9281 /* Add a new entry to .debug_pubtypes if appropriate. */
9284 add_pubtype (tree decl
, dw_die_ref die
)
9288 if (!want_pubnames ())
9291 if ((TREE_PUBLIC (decl
)
9292 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9293 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
9296 const char *scope_name
= "";
9297 const char *sep
= is_cxx () ? "::" : ".";
9300 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
9301 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
9303 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
9304 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
9305 scope_name
= concat (scope_name
, sep
, NULL
);
9311 name
= type_tag (decl
);
9313 name
= lang_hooks
.dwarf_name (decl
, 1);
9315 /* If we don't have a name for the type, there's no point in adding
9317 if (name
!= NULL
&& name
[0] != '\0')
9320 e
.name
= concat (scope_name
, name
, NULL
);
9321 vec_safe_push (pubtype_table
, e
);
9324 /* Although it might be more consistent to add the pubinfo for the
9325 enumerators as their dies are created, they should only be added if the
9326 enum type meets the criteria above. So rather than re-check the parent
9327 enum type whenever an enumerator die is created, just output them all
9328 here. This isn't protected by the name conditional because anonymous
9329 enums don't have names. */
9330 if (die
->die_tag
== DW_TAG_enumeration_type
)
9334 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
9339 /* Output a single entry in the pubnames table. */
9342 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
9344 dw_die_ref die
= entry
->die
;
9345 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
9347 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
9349 if (debug_generate_pub_sections
== 2)
9351 /* This logic follows gdb's method for determining the value of the flag
9353 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
9354 switch (die
->die_tag
)
9356 case DW_TAG_typedef
:
9357 case DW_TAG_base_type
:
9358 case DW_TAG_subrange_type
:
9359 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9360 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9362 case DW_TAG_enumerator
:
9363 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9364 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9365 if (!is_cxx () && !is_java ())
9366 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9368 case DW_TAG_subprogram
:
9369 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9370 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
9372 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9374 case DW_TAG_constant
:
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_variable
:
9380 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9381 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9382 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9384 case DW_TAG_namespace
:
9385 case DW_TAG_imported_declaration
:
9386 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9388 case DW_TAG_class_type
:
9389 case DW_TAG_interface_type
:
9390 case DW_TAG_structure_type
:
9391 case DW_TAG_union_type
:
9392 case DW_TAG_enumeration_type
:
9393 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9394 if (!is_cxx () && !is_java ())
9395 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9398 /* An unusual tag. Leave the flag-byte empty. */
9401 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
9405 dw2_asm_output_nstring (entry
->name
, -1, "external name");
9409 /* Output the public names table used to speed up access to externally
9410 visible names; or the public types table used to find type definitions. */
9413 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9416 unsigned long pubnames_length
= size_of_pubnames (names
);
9419 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9420 dw2_asm_output_data (4, 0xffffffff,
9421 "Initial length escape value indicating 64-bit DWARF extension");
9422 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
, "Pub Info Length");
9424 /* Version number for pubnames/pubtypes is independent of dwarf version. */
9425 dw2_asm_output_data (2, 2, "DWARF Version");
9427 if (dwarf_split_debug_info
)
9428 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9429 debug_skeleton_info_section
,
9430 "Offset of Compilation Unit Info");
9432 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9434 "Offset of Compilation Unit Info");
9435 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
9436 "Compilation Unit Length");
9438 FOR_EACH_VEC_ELT (*names
, i
, pub
)
9440 if (include_pubname_in_output (names
, pub
))
9442 dw_offset die_offset
= pub
->die
->die_offset
;
9444 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9445 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
9446 gcc_assert (pub
->die
->die_mark
);
9448 /* If we're putting types in their own .debug_types sections,
9449 the .debug_pubtypes table will still point to the compile
9450 unit (not the type unit), so we want to use the offset of
9451 the skeleton DIE (if there is one). */
9452 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
9454 comdat_type_node_ref type_node
= pub
->die
->die_id
.die_type_node
;
9456 if (type_node
!= NULL
)
9457 die_offset
= (type_node
->skeleton_die
!= NULL
9458 ? type_node
->skeleton_die
->die_offset
9459 : comp_unit_die ()->die_offset
);
9462 output_pubname (die_offset
, pub
);
9466 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
9469 /* Output public names and types tables if necessary. */
9472 output_pubtables (void)
9474 if (!want_pubnames () || !info_section_emitted
)
9477 switch_to_section (debug_pubnames_section
);
9478 output_pubnames (pubname_table
);
9479 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
9480 It shouldn't hurt to emit it always, since pure DWARF2 consumers
9481 simply won't look for the section. */
9482 switch_to_section (debug_pubtypes_section
);
9483 output_pubnames (pubtype_table
);
9487 /* Output the information that goes into the .debug_aranges table.
9488 Namely, define the beginning and ending address range of the
9489 text section generated for this compilation unit. */
9492 output_aranges (unsigned long aranges_length
)
9496 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9497 dw2_asm_output_data (4, 0xffffffff,
9498 "Initial length escape value indicating 64-bit DWARF extension");
9499 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
9500 "Length of Address Ranges Info");
9501 /* Version number for aranges is still 2, even in DWARF3. */
9502 dw2_asm_output_data (2, 2, "DWARF Version");
9503 if (dwarf_split_debug_info
)
9504 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9505 debug_skeleton_info_section
,
9506 "Offset of Compilation Unit Info");
9508 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9510 "Offset of Compilation Unit Info");
9511 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
9512 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9514 /* We need to align to twice the pointer size here. */
9515 if (DWARF_ARANGES_PAD_SIZE
)
9517 /* Pad using a 2 byte words so that padding is correct for any
9519 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9520 2 * DWARF2_ADDR_SIZE
);
9521 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
9522 dw2_asm_output_data (2, 0, NULL
);
9525 /* It is necessary not to output these entries if the sections were
9526 not used; if the sections were not used, the length will be 0 and
9527 the address may end up as 0 if the section is discarded by ld
9528 --gc-sections, leaving an invalid (0, 0) entry that can be
9529 confused with the terminator. */
9530 if (text_section_used
)
9532 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
9533 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
9534 text_section_label
, "Length");
9536 if (cold_text_section_used
)
9538 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
9540 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
9541 cold_text_section_label
, "Length");
9544 if (have_multiple_function_sections
)
9549 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9551 if (DECL_IGNORED_P (fde
->decl
))
9553 if (!fde
->in_std_section
)
9555 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
9557 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
9558 fde
->dw_fde_begin
, "Length");
9560 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9562 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
9564 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
9565 fde
->dw_fde_second_begin
, "Length");
9570 /* Output the terminator words. */
9571 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9572 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9575 /* Add a new entry to .debug_ranges. Return the offset at which it
9579 add_ranges_num (int num
)
9581 unsigned int in_use
= ranges_table_in_use
;
9583 if (in_use
== ranges_table_allocated
)
9585 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
9586 ranges_table
= GGC_RESIZEVEC (struct dw_ranges_struct
, ranges_table
,
9587 ranges_table_allocated
);
9588 memset (ranges_table
+ ranges_table_in_use
, 0,
9589 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
9592 ranges_table
[in_use
].num
= num
;
9593 ranges_table_in_use
= in_use
+ 1;
9595 return in_use
* 2 * DWARF2_ADDR_SIZE
;
9598 /* Add a new entry to .debug_ranges corresponding to a block, or a
9599 range terminator if BLOCK is NULL. */
9602 add_ranges (const_tree block
)
9604 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0);
9607 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
9608 When using dwarf_split_debug_info, address attributes in dies destined
9609 for the final executable should be direct references--setting the
9610 parameter force_direct ensures this behavior. */
9613 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
9614 bool *added
, bool force_direct
)
9616 unsigned int in_use
= ranges_by_label_in_use
;
9617 unsigned int offset
;
9619 if (in_use
== ranges_by_label_allocated
)
9621 ranges_by_label_allocated
+= RANGES_TABLE_INCREMENT
;
9622 ranges_by_label
= GGC_RESIZEVEC (struct dw_ranges_by_label_struct
,
9624 ranges_by_label_allocated
);
9625 memset (ranges_by_label
+ ranges_by_label_in_use
, 0,
9626 RANGES_TABLE_INCREMENT
9627 * sizeof (struct dw_ranges_by_label_struct
));
9630 ranges_by_label
[in_use
].begin
= begin
;
9631 ranges_by_label
[in_use
].end
= end
;
9632 ranges_by_label_in_use
= in_use
+ 1;
9634 offset
= add_ranges_num (-(int)in_use
- 1);
9637 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
9643 output_ranges (void)
9646 static const char *const start_fmt
= "Offset %#x";
9647 const char *fmt
= start_fmt
;
9649 for (i
= 0; i
< ranges_table_in_use
; i
++)
9651 int block_num
= ranges_table
[i
].num
;
9655 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
9656 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
9658 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
9659 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
9661 /* If all code is in the text section, then the compilation
9662 unit base address defaults to DW_AT_low_pc, which is the
9663 base of the text section. */
9664 if (!have_multiple_function_sections
)
9666 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
9668 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9669 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
9670 text_section_label
, NULL
);
9673 /* Otherwise, the compilation unit base address is zero,
9674 which allows us to use absolute addresses, and not worry
9675 about whether the target supports cross-section
9679 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
9680 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9681 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
9687 /* Negative block_num stands for an index into ranges_by_label. */
9688 else if (block_num
< 0)
9690 int lab_idx
= - block_num
- 1;
9692 if (!have_multiple_function_sections
)
9696 /* If we ever use add_ranges_by_labels () for a single
9697 function section, all we have to do is to take out
9699 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9700 ranges_by_label
[lab_idx
].begin
,
9702 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9703 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9704 ranges_by_label
[lab_idx
].end
,
9705 text_section_label
, NULL
);
9710 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9711 ranges_by_label
[lab_idx
].begin
,
9712 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9713 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9714 ranges_by_label
[lab_idx
].end
,
9720 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9721 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9727 /* Data structure containing information about input files. */
9730 const char *path
; /* Complete file name. */
9731 const char *fname
; /* File name part. */
9732 int length
; /* Length of entire string. */
9733 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
9734 int dir_idx
; /* Index in directory table. */
9737 /* Data structure containing information about directories with source
9741 const char *path
; /* Path including directory name. */
9742 int length
; /* Path length. */
9743 int prefix
; /* Index of directory entry which is a prefix. */
9744 int count
; /* Number of files in this directory. */
9745 int dir_idx
; /* Index of directory used as base. */
9748 /* Callback function for file_info comparison. We sort by looking at
9749 the directories in the path. */
9752 file_info_cmp (const void *p1
, const void *p2
)
9754 const struct file_info
*const s1
= (const struct file_info
*) p1
;
9755 const struct file_info
*const s2
= (const struct file_info
*) p2
;
9756 const unsigned char *cp1
;
9757 const unsigned char *cp2
;
9759 /* Take care of file names without directories. We need to make sure that
9760 we return consistent values to qsort since some will get confused if
9761 we return the same value when identical operands are passed in opposite
9762 orders. So if neither has a directory, return 0 and otherwise return
9763 1 or -1 depending on which one has the directory. */
9764 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
9765 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
9767 cp1
= (const unsigned char *) s1
->path
;
9768 cp2
= (const unsigned char *) s2
->path
;
9774 /* Reached the end of the first path? If so, handle like above. */
9775 if ((cp1
== (const unsigned char *) s1
->fname
)
9776 || (cp2
== (const unsigned char *) s2
->fname
))
9777 return ((cp2
== (const unsigned char *) s2
->fname
)
9778 - (cp1
== (const unsigned char *) s1
->fname
));
9780 /* Character of current path component the same? */
9781 else if (*cp1
!= *cp2
)
9786 struct file_name_acquire_data
9788 struct file_info
*files
;
9793 /* Traversal function for the hash table. */
9796 file_name_acquire (void ** slot
, void *data
)
9798 struct file_name_acquire_data
*fnad
= (struct file_name_acquire_data
*) data
;
9799 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
9800 struct file_info
*fi
;
9803 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
9805 if (! d
->emitted_number
)
9808 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
9810 fi
= fnad
->files
+ fnad
->used_files
++;
9812 /* Skip all leading "./". */
9814 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
9817 /* Create a new array entry. */
9819 fi
->length
= strlen (f
);
9822 /* Search for the file name part. */
9823 f
= strrchr (f
, DIR_SEPARATOR
);
9824 #if defined (DIR_SEPARATOR_2)
9826 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
9830 if (f
== NULL
|| f
< g
)
9836 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
9840 /* Output the directory table and the file name table. We try to minimize
9841 the total amount of memory needed. A heuristic is used to avoid large
9842 slowdowns with many input files. */
9845 output_file_names (void)
9847 struct file_name_acquire_data fnad
;
9849 struct file_info
*files
;
9850 struct dir_info
*dirs
;
9858 if (!last_emitted_file
)
9860 dw2_asm_output_data (1, 0, "End directory table");
9861 dw2_asm_output_data (1, 0, "End file name table");
9865 numfiles
= last_emitted_file
->emitted_number
;
9867 /* Allocate the various arrays we need. */
9868 files
= XALLOCAVEC (struct file_info
, numfiles
);
9869 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
9872 fnad
.used_files
= 0;
9873 fnad
.max_files
= numfiles
;
9874 htab_traverse (file_table
, file_name_acquire
, &fnad
);
9875 gcc_assert (fnad
.used_files
== fnad
.max_files
);
9877 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
9879 /* Find all the different directories used. */
9880 dirs
[0].path
= files
[0].path
;
9881 dirs
[0].length
= files
[0].fname
- files
[0].path
;
9882 dirs
[0].prefix
= -1;
9884 dirs
[0].dir_idx
= 0;
9885 files
[0].dir_idx
= 0;
9888 for (i
= 1; i
< numfiles
; i
++)
9889 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
9890 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
9891 dirs
[ndirs
- 1].length
) == 0)
9893 /* Same directory as last entry. */
9894 files
[i
].dir_idx
= ndirs
- 1;
9895 ++dirs
[ndirs
- 1].count
;
9901 /* This is a new directory. */
9902 dirs
[ndirs
].path
= files
[i
].path
;
9903 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
9904 dirs
[ndirs
].count
= 1;
9905 dirs
[ndirs
].dir_idx
= ndirs
;
9906 files
[i
].dir_idx
= ndirs
;
9908 /* Search for a prefix. */
9909 dirs
[ndirs
].prefix
= -1;
9910 for (j
= 0; j
< ndirs
; j
++)
9911 if (dirs
[j
].length
< dirs
[ndirs
].length
9912 && dirs
[j
].length
> 1
9913 && (dirs
[ndirs
].prefix
== -1
9914 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
9915 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
9916 dirs
[ndirs
].prefix
= j
;
9921 /* Now to the actual work. We have to find a subset of the directories which
9922 allow expressing the file name using references to the directory table
9923 with the least amount of characters. We do not do an exhaustive search
9924 where we would have to check out every combination of every single
9925 possible prefix. Instead we use a heuristic which provides nearly optimal
9926 results in most cases and never is much off. */
9927 saved
= XALLOCAVEC (int, ndirs
);
9928 savehere
= XALLOCAVEC (int, ndirs
);
9930 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
9931 for (i
= 0; i
< ndirs
; i
++)
9936 /* We can always save some space for the current directory. But this
9937 does not mean it will be enough to justify adding the directory. */
9938 savehere
[i
] = dirs
[i
].length
;
9939 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
9941 for (j
= i
+ 1; j
< ndirs
; j
++)
9944 if (saved
[j
] < dirs
[i
].length
)
9946 /* Determine whether the dirs[i] path is a prefix of the
9951 while (k
!= -1 && k
!= (int) i
)
9956 /* Yes it is. We can possibly save some memory by
9957 writing the filenames in dirs[j] relative to
9959 savehere
[j
] = dirs
[i
].length
;
9960 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
9965 /* Check whether we can save enough to justify adding the dirs[i]
9967 if (total
> dirs
[i
].length
+ 1)
9969 /* It's worthwhile adding. */
9970 for (j
= i
; j
< ndirs
; j
++)
9971 if (savehere
[j
] > 0)
9973 /* Remember how much we saved for this directory so far. */
9974 saved
[j
] = savehere
[j
];
9976 /* Remember the prefix directory. */
9977 dirs
[j
].dir_idx
= i
;
9982 /* Emit the directory name table. */
9983 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
9984 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
9985 dw2_asm_output_nstring (dirs
[i
].path
,
9987 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
9988 "Directory Entry: %#x", i
+ idx_offset
);
9990 dw2_asm_output_data (1, 0, "End directory table");
9992 /* We have to emit them in the order of emitted_number since that's
9993 used in the debug info generation. To do this efficiently we
9994 generate a back-mapping of the indices first. */
9995 backmap
= XALLOCAVEC (int, numfiles
);
9996 for (i
= 0; i
< numfiles
; i
++)
9997 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
9999 /* Now write all the file names. */
10000 for (i
= 0; i
< numfiles
; i
++)
10002 int file_idx
= backmap
[i
];
10003 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
10005 #ifdef VMS_DEBUGGING_INFO
10006 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
10008 /* Setting these fields can lead to debugger miscomparisons,
10009 but VMS Debug requires them to be set correctly. */
10014 int maxfilelen
= strlen (files
[file_idx
].path
)
10015 + dirs
[dir_idx
].length
10016 + MAX_VMS_VERSION_LEN
+ 1;
10017 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
10019 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
10020 snprintf (filebuf
, maxfilelen
, "%s;%d",
10021 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
10023 dw2_asm_output_nstring
10024 (filebuf
, -1, "File Entry: %#x", (unsigned) i
+ 1);
10026 /* Include directory index. */
10027 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
10029 /* Modification time. */
10030 dw2_asm_output_data_uleb128
10031 ((vms_file_stats_name (files
[file_idx
].path
, &cdt
, 0, 0, 0) == 0)
10035 /* File length in bytes. */
10036 dw2_asm_output_data_uleb128
10037 ((vms_file_stats_name (files
[file_idx
].path
, 0, &siz
, 0, 0) == 0)
10041 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
10042 "File Entry: %#x", (unsigned) i
+ 1);
10044 /* Include directory index. */
10045 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
10047 /* Modification time. */
10048 dw2_asm_output_data_uleb128 (0, NULL
);
10050 /* File length in bytes. */
10051 dw2_asm_output_data_uleb128 (0, NULL
);
10052 #endif /* VMS_DEBUGGING_INFO */
10055 dw2_asm_output_data (1, 0, "End file name table");
10059 /* Output one line number table into the .debug_line section. */
10062 output_one_line_info_table (dw_line_info_table
*table
)
10064 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10065 unsigned int current_line
= 1;
10066 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
10067 dw_line_info_entry
*ent
;
10070 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
10072 switch (ent
->opcode
)
10074 case LI_set_address
:
10075 /* ??? Unfortunately, we have little choice here currently, and
10076 must always use the most general form. GCC does not know the
10077 address delta itself, so we can't use DW_LNS_advance_pc. Many
10078 ports do have length attributes which will give an upper bound
10079 on the address range. We could perhaps use length attributes
10080 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
10081 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
10083 /* This can handle any delta. This takes
10084 4+DWARF2_ADDR_SIZE bytes. */
10085 dw2_asm_output_data (1, 0, "set address %s", line_label
);
10086 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10087 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10088 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
10092 if (ent
->val
== current_line
)
10094 /* We still need to start a new row, so output a copy insn. */
10095 dw2_asm_output_data (1, DW_LNS_copy
,
10096 "copy line %u", current_line
);
10100 int line_offset
= ent
->val
- current_line
;
10101 int line_delta
= line_offset
- DWARF_LINE_BASE
;
10103 current_line
= ent
->val
;
10104 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
10106 /* This can handle deltas from -10 to 234, using the current
10107 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
10108 This takes 1 byte. */
10109 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
10110 "line %u", current_line
);
10114 /* This can handle any delta. This takes at least 4 bytes,
10115 depending on the value being encoded. */
10116 dw2_asm_output_data (1, DW_LNS_advance_line
,
10117 "advance to line %u", current_line
);
10118 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
10119 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
10125 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
10126 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
10129 case LI_set_column
:
10130 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
10131 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
10134 case LI_negate_stmt
:
10135 current_is_stmt
= !current_is_stmt
;
10136 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
10137 "is_stmt %d", current_is_stmt
);
10140 case LI_set_prologue_end
:
10141 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
10142 "set prologue end");
10145 case LI_set_epilogue_begin
:
10146 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
10147 "set epilogue begin");
10150 case LI_set_discriminator
:
10151 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
10152 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
10153 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
10154 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
10159 /* Emit debug info for the address of the end of the table. */
10160 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
10161 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10162 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10163 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
10165 dw2_asm_output_data (1, 0, "end sequence");
10166 dw2_asm_output_data_uleb128 (1, NULL
);
10167 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
10170 /* Output the source line number correspondence information. This
10171 information goes into the .debug_line section. */
10174 output_line_info (bool prologue_only
)
10176 char l1
[20], l2
[20], p1
[20], p2
[20];
10177 int ver
= dwarf_version
;
10178 bool saw_one
= false;
10181 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
10182 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
10183 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
10184 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
10186 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10187 dw2_asm_output_data (4, 0xffffffff,
10188 "Initial length escape value indicating 64-bit DWARF extension");
10189 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
10190 "Length of Source Line Info");
10191 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
10193 dw2_asm_output_data (2, ver
, "DWARF Version");
10194 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
10195 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
10197 /* Define the architecture-dependent minimum instruction length (in bytes).
10198 In this implementation of DWARF, this field is used for information
10199 purposes only. Since GCC generates assembly language, we have no
10200 a priori knowledge of how many instruction bytes are generated for each
10201 source line, and therefore can use only the DW_LNE_set_address and
10202 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
10203 this as '1', which is "correct enough" for all architectures,
10204 and don't let the target override. */
10205 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
10208 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
10209 "Maximum Operations Per Instruction");
10210 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
10211 "Default is_stmt_start flag");
10212 dw2_asm_output_data (1, DWARF_LINE_BASE
,
10213 "Line Base Value (Special Opcodes)");
10214 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
10215 "Line Range Value (Special Opcodes)");
10216 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
10217 "Special Opcode Base");
10219 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
10224 case DW_LNS_advance_pc
:
10225 case DW_LNS_advance_line
:
10226 case DW_LNS_set_file
:
10227 case DW_LNS_set_column
:
10228 case DW_LNS_fixed_advance_pc
:
10229 case DW_LNS_set_isa
:
10237 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
10241 /* Write out the information about the files we use. */
10242 output_file_names ();
10243 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
10246 /* Output the marker for the end of the line number info. */
10247 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10251 if (separate_line_info
)
10253 dw_line_info_table
*table
;
10256 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
10259 output_one_line_info_table (table
);
10263 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
10265 output_one_line_info_table (cold_text_section_line_info
);
10269 /* ??? Some Darwin linkers crash on a .debug_line section with no
10270 sequences. Further, merely a DW_LNE_end_sequence entry is not
10271 sufficient -- the address column must also be initialized.
10272 Make sure to output at least one set_address/end_sequence pair,
10273 choosing .text since that section is always present. */
10274 if (text_section_line_info
->in_use
|| !saw_one
)
10275 output_one_line_info_table (text_section_line_info
);
10277 /* Output the marker for the end of the line number info. */
10278 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10281 /* Given a pointer to a tree node for some base type, return a pointer to
10282 a DIE that describes the given type.
10284 This routine must only be called for GCC type nodes that correspond to
10285 Dwarf base (fundamental) types. */
10288 base_type_die (tree type
)
10290 dw_die_ref base_type_result
;
10291 enum dwarf_type encoding
;
10293 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
10296 /* If this is a subtype that should not be emitted as a subrange type,
10297 use the base type. See subrange_type_for_debug_p. */
10298 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
10299 type
= TREE_TYPE (type
);
10301 switch (TREE_CODE (type
))
10304 if ((dwarf_version
>= 4 || !dwarf_strict
)
10305 && TYPE_NAME (type
)
10306 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10307 && DECL_IS_BUILTIN (TYPE_NAME (type
))
10308 && DECL_NAME (TYPE_NAME (type
)))
10310 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
10311 if (strcmp (name
, "char16_t") == 0
10312 || strcmp (name
, "char32_t") == 0)
10314 encoding
= DW_ATE_UTF
;
10318 if (TYPE_STRING_FLAG (type
))
10320 if (TYPE_UNSIGNED (type
))
10321 encoding
= DW_ATE_unsigned_char
;
10323 encoding
= DW_ATE_signed_char
;
10325 else if (TYPE_UNSIGNED (type
))
10326 encoding
= DW_ATE_unsigned
;
10328 encoding
= DW_ATE_signed
;
10332 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
10334 if (dwarf_version
>= 3 || !dwarf_strict
)
10335 encoding
= DW_ATE_decimal_float
;
10337 encoding
= DW_ATE_lo_user
;
10340 encoding
= DW_ATE_float
;
10343 case FIXED_POINT_TYPE
:
10344 if (!(dwarf_version
>= 3 || !dwarf_strict
))
10345 encoding
= DW_ATE_lo_user
;
10346 else if (TYPE_UNSIGNED (type
))
10347 encoding
= DW_ATE_unsigned_fixed
;
10349 encoding
= DW_ATE_signed_fixed
;
10352 /* Dwarf2 doesn't know anything about complex ints, so use
10353 a user defined type for it. */
10355 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
10356 encoding
= DW_ATE_complex_float
;
10358 encoding
= DW_ATE_lo_user
;
10362 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10363 encoding
= DW_ATE_boolean
;
10367 /* No other TREE_CODEs are Dwarf fundamental types. */
10368 gcc_unreachable ();
10371 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die (), type
);
10373 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
10374 int_size_in_bytes (type
));
10375 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
10376 add_pubtype (type
, base_type_result
);
10378 return base_type_result
;
10381 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
10382 named 'auto' in its type: return true for it, false otherwise. */
10385 is_cxx_auto (tree type
)
10389 tree name
= TYPE_IDENTIFIER (type
);
10390 if (name
== get_identifier ("auto")
10391 || name
== get_identifier ("decltype(auto)"))
10397 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10398 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10401 is_base_type (tree type
)
10403 switch (TREE_CODE (type
))
10409 case FIXED_POINT_TYPE
:
10417 case QUAL_UNION_TYPE
:
10418 case ENUMERAL_TYPE
:
10419 case FUNCTION_TYPE
:
10422 case REFERENCE_TYPE
:
10430 if (is_cxx_auto (type
))
10432 gcc_unreachable ();
10438 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10439 node, return the size in bits for the type if it is a constant, or else
10440 return the alignment for the type if the type's size is not constant, or
10441 else return BITS_PER_WORD if the type actually turns out to be an
10442 ERROR_MARK node. */
10444 static inline unsigned HOST_WIDE_INT
10445 simple_type_size_in_bits (const_tree type
)
10447 if (TREE_CODE (type
) == ERROR_MARK
)
10448 return BITS_PER_WORD
;
10449 else if (TYPE_SIZE (type
) == NULL_TREE
)
10451 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
10452 return tree_to_uhwi (TYPE_SIZE (type
));
10454 return TYPE_ALIGN (type
);
10457 /* Similarly, but return an offset_int instead of UHWI. */
10459 static inline offset_int
10460 offset_int_type_size_in_bits (const_tree type
)
10462 if (TREE_CODE (type
) == ERROR_MARK
)
10463 return BITS_PER_WORD
;
10464 else if (TYPE_SIZE (type
) == NULL_TREE
)
10466 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
10467 return wi::to_offset (TYPE_SIZE (type
));
10469 return TYPE_ALIGN (type
);
10472 /* Given a pointer to a tree node for a subrange type, return a pointer
10473 to a DIE that describes the given type. */
10476 subrange_type_die (tree type
, tree low
, tree high
, dw_die_ref context_die
)
10478 dw_die_ref subrange_die
;
10479 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
10481 if (context_die
== NULL
)
10482 context_die
= comp_unit_die ();
10484 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
10486 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
10488 /* The size of the subrange type and its base type do not match,
10489 so we need to generate a size attribute for the subrange type. */
10490 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
10494 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
);
10496 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
);
10498 return subrange_die
;
10501 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10502 entry that chains various modifiers in front of the given type. */
10505 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
10506 dw_die_ref context_die
)
10508 enum tree_code code
= TREE_CODE (type
);
10509 dw_die_ref mod_type_die
;
10510 dw_die_ref sub_die
= NULL
;
10511 tree item_type
= NULL
;
10512 tree qualified_type
;
10513 tree name
, low
, high
;
10514 dw_die_ref mod_scope
;
10516 if (code
== ERROR_MARK
)
10519 /* See if we already have the appropriately qualified variant of
10522 = get_qualified_type (type
,
10523 ((is_const_type
? TYPE_QUAL_CONST
: 0)
10524 | (is_volatile_type
? TYPE_QUAL_VOLATILE
: 0)));
10526 if (qualified_type
== sizetype
10527 && TYPE_NAME (qualified_type
)
10528 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
10530 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
10532 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
10533 && TYPE_PRECISION (t
)
10534 == TYPE_PRECISION (qualified_type
)
10535 && TYPE_UNSIGNED (t
)
10536 == TYPE_UNSIGNED (qualified_type
));
10537 qualified_type
= t
;
10540 /* If we do, then we can just use its DIE, if it exists. */
10541 if (qualified_type
)
10543 mod_type_die
= lookup_type_die (qualified_type
);
10545 return mod_type_die
;
10548 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
10550 /* Handle C typedef types. */
10551 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
10552 && !DECL_ARTIFICIAL (name
))
10554 tree dtype
= TREE_TYPE (name
);
10556 if (qualified_type
== dtype
)
10558 /* For a named type, use the typedef. */
10559 gen_type_die (qualified_type
, context_die
);
10560 return lookup_type_die (qualified_type
);
10562 else if (is_const_type
< TYPE_READONLY (dtype
)
10563 || is_volatile_type
< TYPE_VOLATILE (dtype
)
10564 || (is_const_type
<= TYPE_READONLY (dtype
)
10565 && is_volatile_type
<= TYPE_VOLATILE (dtype
)
10566 && DECL_ORIGINAL_TYPE (name
) != type
))
10567 /* cv-unqualified version of named type. Just use the unnamed
10568 type to which it refers. */
10569 return modified_type_die (DECL_ORIGINAL_TYPE (name
),
10570 is_const_type
, is_volatile_type
,
10572 /* Else cv-qualified version of named type; fall through. */
10575 mod_scope
= scope_die_for (type
, context_die
);
10578 /* If both is_const_type and is_volatile_type, prefer the path
10579 which leads to a qualified type. */
10580 && (!is_volatile_type
10581 || get_qualified_type (type
, TYPE_QUAL_CONST
) == NULL_TREE
10582 || get_qualified_type (type
, TYPE_QUAL_VOLATILE
) != NULL_TREE
))
10584 mod_type_die
= new_die (DW_TAG_const_type
, mod_scope
, type
);
10585 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
10587 else if (is_volatile_type
)
10589 mod_type_die
= new_die (DW_TAG_volatile_type
, mod_scope
, type
);
10590 sub_die
= modified_type_die (type
, is_const_type
, 0, context_die
);
10592 else if (code
== POINTER_TYPE
)
10594 mod_type_die
= new_die (DW_TAG_pointer_type
, mod_scope
, type
);
10595 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10596 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10597 item_type
= TREE_TYPE (type
);
10598 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10599 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10600 TYPE_ADDR_SPACE (item_type
));
10602 else if (code
== REFERENCE_TYPE
)
10604 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
10605 mod_type_die
= new_die (DW_TAG_rvalue_reference_type
, mod_scope
,
10608 mod_type_die
= new_die (DW_TAG_reference_type
, mod_scope
, type
);
10609 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10610 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10611 item_type
= TREE_TYPE (type
);
10612 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10613 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10614 TYPE_ADDR_SPACE (item_type
));
10616 else if (code
== INTEGER_TYPE
10617 && TREE_TYPE (type
) != NULL_TREE
10618 && subrange_type_for_debug_p (type
, &low
, &high
))
10620 mod_type_die
= subrange_type_die (type
, low
, high
, context_die
);
10621 item_type
= TREE_TYPE (type
);
10623 else if (is_base_type (type
))
10624 mod_type_die
= base_type_die (type
);
10627 gen_type_die (type
, context_die
);
10629 /* We have to get the type_main_variant here (and pass that to the
10630 `lookup_type_die' routine) because the ..._TYPE node we have
10631 might simply be a *copy* of some original type node (where the
10632 copy was created to help us keep track of typedef names) and
10633 that copy might have a different TYPE_UID from the original
10635 if (TREE_CODE (type
) != VECTOR_TYPE
)
10636 return lookup_type_die (type_main_variant (type
));
10638 /* Vectors have the debugging information in the type,
10639 not the main variant. */
10640 return lookup_type_die (type
);
10643 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10644 don't output a DW_TAG_typedef, since there isn't one in the
10645 user's program; just attach a DW_AT_name to the type.
10646 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
10647 if the base type already has the same name. */
10649 && ((TREE_CODE (name
) != TYPE_DECL
10650 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
10651 || (!is_const_type
&& !is_volatile_type
)))
10652 || (TREE_CODE (name
) == TYPE_DECL
10653 && TREE_TYPE (name
) == qualified_type
10654 && DECL_NAME (name
))))
10656 if (TREE_CODE (name
) == TYPE_DECL
)
10657 /* Could just call add_name_and_src_coords_attributes here,
10658 but since this is a builtin type it doesn't have any
10659 useful source coordinates anyway. */
10660 name
= DECL_NAME (name
);
10661 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
10663 /* This probably indicates a bug. */
10664 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
10666 name
= TYPE_IDENTIFIER (type
);
10667 add_name_attribute (mod_type_die
,
10668 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
10671 if (qualified_type
)
10672 equate_type_number_to_die (qualified_type
, mod_type_die
);
10675 /* We must do this after the equate_type_number_to_die call, in case
10676 this is a recursive type. This ensures that the modified_type_die
10677 recursion will terminate even if the type is recursive. Recursive
10678 types are possible in Ada. */
10679 sub_die
= modified_type_die (item_type
,
10680 TYPE_READONLY (item_type
),
10681 TYPE_VOLATILE (item_type
),
10684 if (sub_die
!= NULL
)
10685 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
10687 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
10688 if (TYPE_ARTIFICIAL (type
))
10689 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
10691 return mod_type_die
;
10694 /* Generate DIEs for the generic parameters of T.
10695 T must be either a generic type or a generic function.
10696 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10699 gen_generic_params_dies (tree t
)
10703 dw_die_ref die
= NULL
;
10706 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
10710 die
= lookup_type_die (t
);
10711 else if (DECL_P (t
))
10712 die
= lookup_decl_die (t
);
10716 parms
= lang_hooks
.get_innermost_generic_parms (t
);
10718 /* T has no generic parameter. It means T is neither a generic type
10719 or function. End of story. */
10722 parms_num
= TREE_VEC_LENGTH (parms
);
10723 args
= lang_hooks
.get_innermost_generic_args (t
);
10724 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
10725 non_default
= int_cst_value (TREE_CHAIN (args
));
10727 non_default
= TREE_VEC_LENGTH (args
);
10728 for (i
= 0; i
< parms_num
; i
++)
10730 tree parm
, arg
, arg_pack_elems
;
10731 dw_die_ref parm_die
;
10733 parm
= TREE_VEC_ELT (parms
, i
);
10734 arg
= TREE_VEC_ELT (args
, i
);
10735 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
10736 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
10738 if (parm
&& TREE_VALUE (parm
) && arg
)
10740 /* If PARM represents a template parameter pack,
10741 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10742 by DW_TAG_template_*_parameter DIEs for the argument
10743 pack elements of ARG. Note that ARG would then be
10744 an argument pack. */
10745 if (arg_pack_elems
)
10746 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
10750 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
10751 true /* emit name */, die
);
10752 if (i
>= non_default
)
10753 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
10758 /* Create and return a DIE for PARM which should be
10759 the representation of a generic type parameter.
10760 For instance, in the C++ front end, PARM would be a template parameter.
10761 ARG is the argument to PARM.
10762 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10764 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10765 as a child node. */
10768 generic_parameter_die (tree parm
, tree arg
,
10770 dw_die_ref parent_die
)
10772 dw_die_ref tmpl_die
= NULL
;
10773 const char *name
= NULL
;
10775 if (!parm
|| !DECL_NAME (parm
) || !arg
)
10778 /* We support non-type generic parameters and arguments,
10779 type generic parameters and arguments, as well as
10780 generic generic parameters (a.k.a. template template parameters in C++)
10782 if (TREE_CODE (parm
) == PARM_DECL
)
10783 /* PARM is a nontype generic parameter */
10784 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
10785 else if (TREE_CODE (parm
) == TYPE_DECL
)
10786 /* PARM is a type generic parameter. */
10787 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
10788 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10789 /* PARM is a generic generic parameter.
10790 Its DIE is a GNU extension. It shall have a
10791 DW_AT_name attribute to represent the name of the template template
10792 parameter, and a DW_AT_GNU_template_name attribute to represent the
10793 name of the template template argument. */
10794 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
10797 gcc_unreachable ();
10803 /* If PARM is a generic parameter pack, it means we are
10804 emitting debug info for a template argument pack element.
10805 In other terms, ARG is a template argument pack element.
10806 In that case, we don't emit any DW_AT_name attribute for
10810 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
10812 add_AT_string (tmpl_die
, DW_AT_name
, name
);
10815 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10817 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10818 TMPL_DIE should have a child DW_AT_type attribute that is set
10819 to the type of the argument to PARM, which is ARG.
10820 If PARM is a type generic parameter, TMPL_DIE should have a
10821 child DW_AT_type that is set to ARG. */
10822 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
10823 add_type_attribute (tmpl_die
, tmpl_type
, 0,
10824 TREE_THIS_VOLATILE (tmpl_type
),
10829 /* So TMPL_DIE is a DIE representing a
10830 a generic generic template parameter, a.k.a template template
10831 parameter in C++ and arg is a template. */
10833 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10834 to the name of the argument. */
10835 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
10837 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
10840 if (TREE_CODE (parm
) == PARM_DECL
)
10841 /* So PARM is a non-type generic parameter.
10842 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10843 attribute of TMPL_DIE which value represents the value
10845 We must be careful here:
10846 The value of ARG might reference some function decls.
10847 We might currently be emitting debug info for a generic
10848 type and types are emitted before function decls, we don't
10849 know if the function decls referenced by ARG will actually be
10850 emitted after cgraph computations.
10851 So must defer the generation of the DW_AT_const_value to
10852 after cgraph is ready. */
10853 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
10859 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
10860 PARM_PACK must be a template parameter pack. The returned DIE
10861 will be child DIE of PARENT_DIE. */
10864 template_parameter_pack_die (tree parm_pack
,
10865 tree parm_pack_args
,
10866 dw_die_ref parent_die
)
10871 gcc_assert (parent_die
&& parm_pack
);
10873 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
10874 add_name_and_src_coords_attributes (die
, parm_pack
);
10875 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
10876 generic_parameter_die (parm_pack
,
10877 TREE_VEC_ELT (parm_pack_args
, j
),
10878 false /* Don't emit DW_AT_name */,
10883 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10884 an enumerated type. */
10887 type_is_enum (const_tree type
)
10889 return TREE_CODE (type
) == ENUMERAL_TYPE
;
10892 /* Return the DBX register number described by a given RTL node. */
10894 static unsigned int
10895 dbx_reg_number (const_rtx rtl
)
10897 unsigned regno
= REGNO (rtl
);
10899 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
10901 #ifdef LEAF_REG_REMAP
10902 if (crtl
->uses_only_leaf_regs
)
10904 int leaf_reg
= LEAF_REG_REMAP (regno
);
10905 if (leaf_reg
!= -1)
10906 regno
= (unsigned) leaf_reg
;
10910 regno
= DBX_REGISTER_NUMBER (regno
);
10911 gcc_assert (regno
!= INVALID_REGNUM
);
10915 /* Optionally add a DW_OP_piece term to a location description expression.
10916 DW_OP_piece is only added if the location description expression already
10917 doesn't end with DW_OP_piece. */
10920 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
10922 dw_loc_descr_ref loc
;
10924 if (*list_head
!= NULL
)
10926 /* Find the end of the chain. */
10927 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
10930 if (loc
->dw_loc_opc
!= DW_OP_piece
)
10931 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
10935 /* Return a location descriptor that designates a machine register or
10936 zero if there is none. */
10938 static dw_loc_descr_ref
10939 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
10943 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
10946 /* We only use "frame base" when we're sure we're talking about the
10947 post-prologue local stack frame. We do this by *not* running
10948 register elimination until this point, and recognizing the special
10949 argument pointer and soft frame pointer rtx's.
10950 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
10951 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
10952 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
10954 dw_loc_descr_ref result
= NULL
;
10956 if (dwarf_version
>= 4 || !dwarf_strict
)
10958 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
10961 add_loc_descr (&result
,
10962 new_loc_descr (DW_OP_stack_value
, 0, 0));
10967 regs
= targetm
.dwarf_register_span (rtl
);
10969 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1 || regs
)
10970 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
10973 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
10974 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
10976 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
10980 /* Return a location descriptor that designates a machine register for
10981 a given hard register number. */
10983 static dw_loc_descr_ref
10984 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
10986 dw_loc_descr_ref reg_loc_descr
;
10990 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
10992 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
10994 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10995 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10997 return reg_loc_descr
;
11000 /* Given an RTL of a register, return a location descriptor that
11001 designates a value that spans more than one register. */
11003 static dw_loc_descr_ref
11004 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
11005 enum var_init_status initialized
)
11008 dw_loc_descr_ref loc_result
= NULL
;
11010 /* Simple, contiguous registers. */
11011 if (regs
== NULL_RTX
)
11013 unsigned reg
= REGNO (rtl
);
11016 #ifdef LEAF_REG_REMAP
11017 if (crtl
->uses_only_leaf_regs
)
11019 int leaf_reg
= LEAF_REG_REMAP (reg
);
11020 if (leaf_reg
!= -1)
11021 reg
= (unsigned) leaf_reg
;
11025 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
11026 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
11028 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
11033 dw_loc_descr_ref t
;
11035 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
11036 VAR_INIT_STATUS_INITIALIZED
);
11037 add_loc_descr (&loc_result
, t
);
11038 add_loc_descr_op_piece (&loc_result
, size
);
11044 /* Now onto stupid register sets in non contiguous locations. */
11046 gcc_assert (GET_CODE (regs
) == PARALLEL
);
11048 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
11051 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
11053 dw_loc_descr_ref t
;
11055 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
11056 VAR_INIT_STATUS_INITIALIZED
);
11057 add_loc_descr (&loc_result
, t
);
11058 add_loc_descr_op_piece (&loc_result
, size
);
11061 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11062 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11066 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
11068 /* Return a location descriptor that designates a constant i,
11069 as a compound operation from constant (i >> shift), constant shift
11072 static dw_loc_descr_ref
11073 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11075 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
11076 add_loc_descr (&ret
, int_loc_descriptor (shift
));
11077 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
11081 /* Return a location descriptor that designates a constant. */
11083 static dw_loc_descr_ref
11084 int_loc_descriptor (HOST_WIDE_INT i
)
11086 enum dwarf_location_atom op
;
11088 /* Pick the smallest representation of a constant, rather than just
11089 defaulting to the LEB encoding. */
11092 int clz
= clz_hwi (i
);
11093 int ctz
= ctz_hwi (i
);
11095 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
11096 else if (i
<= 0xff)
11097 op
= DW_OP_const1u
;
11098 else if (i
<= 0xffff)
11099 op
= DW_OP_const2u
;
11100 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11101 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11102 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
11103 DW_OP_litX DW_OP_const1u Y 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
- 5);
11106 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11107 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11108 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
11109 while DW_OP_const4u is 5 bytes. */
11110 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11111 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11112 op
= DW_OP_const4u
;
11113 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11114 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11115 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
11116 while DW_OP_constu of constant >= 0x100000000 takes at least
11118 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11119 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11120 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
11121 >= HOST_BITS_PER_WIDE_INT
)
11122 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
11123 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
11124 while DW_OP_constu takes in this case at least 6 bytes. */
11125 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
11126 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11127 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11128 && size_of_uleb128 (i
) > 6)
11129 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
11130 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
11137 op
= DW_OP_const1s
;
11138 else if (i
>= -0x8000)
11139 op
= DW_OP_const2s
;
11140 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11142 if (size_of_int_loc_descriptor (i
) < 5)
11144 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11145 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11148 op
= DW_OP_const4s
;
11152 if (size_of_int_loc_descriptor (i
)
11153 < (unsigned long) 1 + size_of_sleb128 (i
))
11155 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11156 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11163 return new_loc_descr (op
, i
, 0);
11166 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
11167 without actually allocating it. */
11169 static unsigned long
11170 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11172 return size_of_int_loc_descriptor (i
>> shift
)
11173 + size_of_int_loc_descriptor (shift
)
11177 /* Return size_of_locs (int_loc_descriptor (i)) without
11178 actually allocating it. */
11180 static unsigned long
11181 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
11190 else if (i
<= 0xff)
11192 else if (i
<= 0xffff)
11196 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11197 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11198 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11200 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11201 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11202 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11204 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11206 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
11207 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11208 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11209 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11211 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11212 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
11213 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11215 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11216 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11218 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11227 else if (i
>= -0x8000)
11229 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11231 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11233 s
= size_of_int_loc_descriptor (-i
) + 1;
11241 unsigned long r
= 1 + size_of_sleb128 (i
);
11242 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11244 s
= size_of_int_loc_descriptor (-i
) + 1;
11253 /* Return loc description representing "address" of integer value.
11254 This can appear only as toplevel expression. */
11256 static dw_loc_descr_ref
11257 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
11260 dw_loc_descr_ref loc_result
= NULL
;
11262 if (!(dwarf_version
>= 4 || !dwarf_strict
))
11265 litsize
= size_of_int_loc_descriptor (i
);
11266 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11267 is more compact. For DW_OP_stack_value we need:
11268 litsize + 1 (DW_OP_stack_value)
11269 and for DW_OP_implicit_value:
11270 1 (DW_OP_implicit_value) + 1 (length) + size. */
11271 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
11273 loc_result
= int_loc_descriptor (i
);
11274 add_loc_descr (&loc_result
,
11275 new_loc_descr (DW_OP_stack_value
, 0, 0));
11279 loc_result
= new_loc_descr (DW_OP_implicit_value
,
11281 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
11282 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
11286 /* Return a location descriptor that designates a base+offset location. */
11288 static dw_loc_descr_ref
11289 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
11290 enum var_init_status initialized
)
11292 unsigned int regno
;
11293 dw_loc_descr_ref result
;
11294 dw_fde_ref fde
= cfun
->fde
;
11296 /* We only use "frame base" when we're sure we're talking about the
11297 post-prologue local stack frame. We do this by *not* running
11298 register elimination until this point, and recognizing the special
11299 argument pointer and soft frame pointer rtx's. */
11300 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
11302 rtx elim
= (ira_use_lra_p
11303 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
11304 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
11308 if (GET_CODE (elim
) == PLUS
)
11310 offset
+= INTVAL (XEXP (elim
, 1));
11311 elim
= XEXP (elim
, 0);
11313 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
11314 && (elim
== hard_frame_pointer_rtx
11315 || elim
== stack_pointer_rtx
))
11316 || elim
== (frame_pointer_needed
11317 ? hard_frame_pointer_rtx
11318 : stack_pointer_rtx
));
11320 /* If drap register is used to align stack, use frame
11321 pointer + offset to access stack variables. If stack
11322 is aligned without drap, use stack pointer + offset to
11323 access stack variables. */
11324 if (crtl
->stack_realign_tried
11325 && reg
== frame_pointer_rtx
)
11328 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
11329 ? HARD_FRAME_POINTER_REGNUM
11331 return new_reg_loc_descr (base_reg
, offset
);
11334 gcc_assert (frame_pointer_fb_offset_valid
);
11335 offset
+= frame_pointer_fb_offset
;
11336 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11340 regno
= REGNO (reg
);
11341 #ifdef LEAF_REG_REMAP
11342 if (crtl
->uses_only_leaf_regs
)
11344 int leaf_reg
= LEAF_REG_REMAP (regno
);
11345 if (leaf_reg
!= -1)
11346 regno
= (unsigned) leaf_reg
;
11349 regno
= DWARF_FRAME_REGNUM (regno
);
11351 if (!optimize
&& fde
11352 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
))
11354 /* Use cfa+offset to represent the location of arguments passed
11355 on the stack when drap is used to align stack.
11356 Only do this when not optimizing, for optimized code var-tracking
11357 is supposed to track where the arguments live and the register
11358 used as vdrap or drap in some spot might be used for something
11359 else in other part of the routine. */
11360 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11364 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
11367 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
11369 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11370 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11375 /* Return true if this RTL expression describes a base+offset calculation. */
11378 is_based_loc (const_rtx rtl
)
11380 return (GET_CODE (rtl
) == PLUS
11381 && ((REG_P (XEXP (rtl
, 0))
11382 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
11383 && CONST_INT_P (XEXP (rtl
, 1)))));
11386 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11389 static dw_loc_descr_ref
11390 tls_mem_loc_descriptor (rtx mem
)
11393 dw_loc_descr_ref loc_result
;
11395 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
11398 base
= get_base_address (MEM_EXPR (mem
));
11400 || TREE_CODE (base
) != VAR_DECL
11401 || !DECL_THREAD_LOCAL_P (base
))
11404 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1);
11405 if (loc_result
== NULL
)
11408 if (MEM_OFFSET (mem
))
11409 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
11414 /* Output debug info about reason why we failed to expand expression as dwarf
11418 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
11420 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
11422 fprintf (dump_file
, "Failed to expand as dwarf: ");
11424 print_generic_expr (dump_file
, expr
, dump_flags
);
11427 fprintf (dump_file
, "\n");
11428 print_rtl (dump_file
, rtl
);
11430 fprintf (dump_file
, "\nReason: %s\n", reason
);
11434 /* Helper function for const_ok_for_output, called either directly
11435 or via for_each_rtx. */
11438 const_ok_for_output_1 (rtx
*rtlp
, void *data ATTRIBUTE_UNUSED
)
11442 if (GET_CODE (rtl
) == UNSPEC
)
11444 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
11445 we can't express it in the debug info. */
11446 #ifdef ENABLE_CHECKING
11447 /* Don't complain about TLS UNSPECs, those are just too hard to
11448 delegitimize. Note this could be a non-decl SYMBOL_REF such as
11449 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
11450 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
11451 if (XVECLEN (rtl
, 0) == 0
11452 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
11453 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
)
11454 inform (current_function_decl
11455 ? DECL_SOURCE_LOCATION (current_function_decl
)
11456 : UNKNOWN_LOCATION
,
11457 #if NUM_UNSPEC_VALUES > 0
11458 "non-delegitimized UNSPEC %s (%d) found in variable location",
11459 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
11460 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
11463 "non-delegitimized UNSPEC %d found in variable location",
11467 expansion_failed (NULL_TREE
, rtl
,
11468 "UNSPEC hasn't been delegitimized.\n");
11472 if (targetm
.const_not_ok_for_debug_p (rtl
))
11474 expansion_failed (NULL_TREE
, rtl
,
11475 "Expression rejected for debug by the backend.\n");
11479 /* FIXME: Refer to PR60655. It is possible for simplification
11480 of rtl expressions in var tracking to produce such expressions.
11481 We should really identify / validate expressions
11482 enclosed in CONST that can be handled by assemblers on various
11483 targets and only handle legitimate cases here. */
11484 if (GET_CODE (rtl
) != SYMBOL_REF
)
11486 if (GET_CODE (rtl
) == NOT
)
11492 if (CONSTANT_POOL_ADDRESS_P (rtl
))
11495 get_pool_constant_mark (rtl
, &marked
);
11496 /* If all references to this pool constant were optimized away,
11497 it was not output and thus we can't represent it. */
11500 expansion_failed (NULL_TREE
, rtl
,
11501 "Constant was removed from constant pool.\n");
11506 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
11509 /* Avoid references to external symbols in debug info, on several targets
11510 the linker might even refuse to link when linking a shared library,
11511 and in many other cases the relocations for .debug_info/.debug_loc are
11512 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
11513 to be defined within the same shared library or executable are fine. */
11514 if (SYMBOL_REF_EXTERNAL_P (rtl
))
11516 tree decl
= SYMBOL_REF_DECL (rtl
);
11518 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
11520 expansion_failed (NULL_TREE
, rtl
,
11521 "Symbol not defined in current TU.\n");
11529 /* Return true if constant RTL can be emitted in DW_OP_addr or
11530 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
11531 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
11534 const_ok_for_output (rtx rtl
)
11536 if (GET_CODE (rtl
) == SYMBOL_REF
)
11537 return const_ok_for_output_1 (&rtl
, NULL
) == 0;
11539 if (GET_CODE (rtl
) == CONST
)
11540 return for_each_rtx (&XEXP (rtl
, 0), const_ok_for_output_1
, NULL
) == 0;
11545 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
11546 if possible, NULL otherwise. */
11549 base_type_for_mode (enum machine_mode mode
, bool unsignedp
)
11551 dw_die_ref type_die
;
11552 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
11556 switch (TREE_CODE (type
))
11564 type_die
= lookup_type_die (type
);
11566 type_die
= modified_type_die (type
, false, false, comp_unit_die ());
11567 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
11572 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
11573 type matching MODE, or, if MODE is narrower than or as wide as
11574 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
11577 static dw_loc_descr_ref
11578 convert_descriptor_to_mode (enum machine_mode mode
, dw_loc_descr_ref op
)
11580 enum machine_mode outer_mode
= mode
;
11581 dw_die_ref type_die
;
11582 dw_loc_descr_ref cvt
;
11584 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
11586 add_loc_descr (&op
, new_loc_descr (DW_OP_GNU_convert
, 0, 0));
11589 type_die
= base_type_for_mode (outer_mode
, 1);
11590 if (type_die
== NULL
)
11592 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11593 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11594 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11595 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11596 add_loc_descr (&op
, cvt
);
11600 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
11602 static dw_loc_descr_ref
11603 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
11604 dw_loc_descr_ref op1
)
11606 dw_loc_descr_ref ret
= op0
;
11607 add_loc_descr (&ret
, op1
);
11608 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11609 if (STORE_FLAG_VALUE
!= 1)
11611 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
11612 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
11617 /* Return location descriptor for signed comparison OP RTL. */
11619 static dw_loc_descr_ref
11620 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11621 enum machine_mode mem_mode
)
11623 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11624 dw_loc_descr_ref op0
, op1
;
11627 if (op_mode
== VOIDmode
)
11628 op_mode
= GET_MODE (XEXP (rtl
, 1));
11629 if (op_mode
== VOIDmode
)
11633 && (GET_MODE_CLASS (op_mode
) != MODE_INT
11634 || GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
))
11637 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11638 VAR_INIT_STATUS_INITIALIZED
);
11639 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11640 VAR_INIT_STATUS_INITIALIZED
);
11642 if (op0
== NULL
|| op1
== NULL
)
11645 if (GET_MODE_CLASS (op_mode
) != MODE_INT
11646 || GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11647 return compare_loc_descriptor (op
, op0
, op1
);
11649 if (GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11651 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
11652 dw_loc_descr_ref cvt
;
11654 if (type_die
== NULL
)
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 (&op0
, cvt
);
11661 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11662 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11663 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11664 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11665 add_loc_descr (&op1
, cvt
);
11666 return compare_loc_descriptor (op
, op0
, op1
);
11669 shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
11670 /* For eq/ne, if the operands are known to be zero-extended,
11671 there is no need to do the fancy shifting up. */
11672 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
11674 dw_loc_descr_ref last0
, last1
;
11675 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11677 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11679 /* deref_size zero extends, and for constants we can check
11680 whether they are zero extended or not. */
11681 if (((last0
->dw_loc_opc
== DW_OP_deref_size
11682 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11683 || (CONST_INT_P (XEXP (rtl
, 0))
11684 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
11685 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
11686 && ((last1
->dw_loc_opc
== DW_OP_deref_size
11687 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11688 || (CONST_INT_P (XEXP (rtl
, 1))
11689 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
11690 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
11691 return compare_loc_descriptor (op
, op0
, op1
);
11693 /* EQ/NE comparison against constant in narrower type than
11694 DWARF2_ADDR_SIZE can be performed either as
11695 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
11698 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
11699 DW_OP_{eq,ne}. Pick whatever is shorter. */
11700 if (CONST_INT_P (XEXP (rtl
, 1))
11701 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
11702 && (size_of_int_loc_descriptor (shift
) + 1
11703 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
)
11704 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
11705 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11706 & GET_MODE_MASK (op_mode
))))
11708 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
11709 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11710 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11711 & GET_MODE_MASK (op_mode
));
11712 return compare_loc_descriptor (op
, op0
, op1
);
11715 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11716 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11717 if (CONST_INT_P (XEXP (rtl
, 1)))
11718 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
);
11721 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11722 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11724 return compare_loc_descriptor (op
, op0
, op1
);
11727 /* Return location descriptor for unsigned comparison OP RTL. */
11729 static dw_loc_descr_ref
11730 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11731 enum machine_mode mem_mode
)
11733 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11734 dw_loc_descr_ref op0
, op1
;
11736 if (op_mode
== VOIDmode
)
11737 op_mode
= GET_MODE (XEXP (rtl
, 1));
11738 if (op_mode
== VOIDmode
)
11740 if (GET_MODE_CLASS (op_mode
) != MODE_INT
)
11743 if (dwarf_strict
&& GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11746 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11747 VAR_INIT_STATUS_INITIALIZED
);
11748 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11749 VAR_INIT_STATUS_INITIALIZED
);
11751 if (op0
== NULL
|| op1
== NULL
)
11754 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
11756 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
11757 dw_loc_descr_ref last0
, last1
;
11758 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11760 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11762 if (CONST_INT_P (XEXP (rtl
, 0)))
11763 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
11764 /* deref_size zero extends, so no need to mask it again. */
11765 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
11766 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11768 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11769 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11771 if (CONST_INT_P (XEXP (rtl
, 1)))
11772 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
11773 /* deref_size zero extends, so no need to mask it again. */
11774 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
11775 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11777 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11778 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11781 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11783 HOST_WIDE_INT bias
= 1;
11784 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11785 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11786 if (CONST_INT_P (XEXP (rtl
, 1)))
11787 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
11788 + INTVAL (XEXP (rtl
, 1)));
11790 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
11793 return compare_loc_descriptor (op
, op0
, op1
);
11796 /* Return location descriptor for {U,S}{MIN,MAX}. */
11798 static dw_loc_descr_ref
11799 minmax_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11800 enum machine_mode mem_mode
)
11802 enum dwarf_location_atom op
;
11803 dw_loc_descr_ref op0
, op1
, ret
;
11804 dw_loc_descr_ref bra_node
, drop_node
;
11807 && (GET_MODE_CLASS (mode
) != MODE_INT
11808 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
))
11811 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11812 VAR_INIT_STATUS_INITIALIZED
);
11813 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11814 VAR_INIT_STATUS_INITIALIZED
);
11816 if (op0
== NULL
|| op1
== NULL
)
11819 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
11820 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
11821 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
11822 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
11824 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11826 HOST_WIDE_INT mask
= GET_MODE_MASK (mode
);
11827 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11828 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11829 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11830 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11832 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
11834 HOST_WIDE_INT bias
= 1;
11835 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11836 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11837 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11840 else if (GET_MODE_CLASS (mode
) == MODE_INT
11841 && GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11843 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (mode
)) * BITS_PER_UNIT
;
11844 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11845 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11846 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11847 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11849 else if (GET_MODE_CLASS (mode
) == MODE_INT
11850 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11852 dw_die_ref type_die
= base_type_for_mode (mode
, 0);
11853 dw_loc_descr_ref cvt
;
11854 if (type_die
== NULL
)
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 (&op0
, cvt
);
11861 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11862 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11863 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11864 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11865 add_loc_descr (&op1
, cvt
);
11868 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
11873 add_loc_descr (&ret
, op1
);
11874 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11875 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
11876 add_loc_descr (&ret
, bra_node
);
11877 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11878 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
11879 add_loc_descr (&ret
, drop_node
);
11880 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11881 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
11882 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
11883 && GET_MODE_CLASS (mode
) == MODE_INT
11884 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11885 ret
= convert_descriptor_to_mode (mode
, ret
);
11889 /* Helper function for mem_loc_descriptor. Perform OP binary op,
11890 but after converting arguments to type_die, afterwards
11891 convert back to unsigned. */
11893 static dw_loc_descr_ref
11894 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
11895 enum machine_mode mode
, enum machine_mode mem_mode
)
11897 dw_loc_descr_ref cvt
, op0
, op1
;
11899 if (type_die
== NULL
)
11901 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11902 VAR_INIT_STATUS_INITIALIZED
);
11903 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11904 VAR_INIT_STATUS_INITIALIZED
);
11905 if (op0
== NULL
|| op1
== NULL
)
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 (&op0
, cvt
);
11912 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11913 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11914 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11915 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11916 add_loc_descr (&op1
, cvt
);
11917 add_loc_descr (&op0
, op1
);
11918 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
11919 return convert_descriptor_to_mode (mode
, op0
);
11922 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
11923 const0 is DW_OP_lit0 or corresponding typed constant,
11924 const1 is DW_OP_lit1 or corresponding typed constant
11925 and constMSB is constant with just the MSB bit set
11927 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11928 L1: const0 DW_OP_swap
11929 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
11930 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11935 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11936 L1: const0 DW_OP_swap
11937 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11938 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11943 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
11944 L1: const1 DW_OP_swap
11945 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11946 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11950 static dw_loc_descr_ref
11951 clz_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11952 enum machine_mode mem_mode
)
11954 dw_loc_descr_ref op0
, ret
, tmp
;
11955 HOST_WIDE_INT valv
;
11956 dw_loc_descr_ref l1jump
, l1label
;
11957 dw_loc_descr_ref l2jump
, l2label
;
11958 dw_loc_descr_ref l3jump
, l3label
;
11959 dw_loc_descr_ref l4jump
, l4label
;
11962 if (GET_MODE_CLASS (mode
) != MODE_INT
11963 || GET_MODE (XEXP (rtl
, 0)) != mode
)
11966 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11967 VAR_INIT_STATUS_INITIALIZED
);
11971 if (GET_CODE (rtl
) == CLZ
)
11973 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11974 valv
= GET_MODE_BITSIZE (mode
);
11976 else if (GET_CODE (rtl
) == FFS
)
11978 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11979 valv
= GET_MODE_BITSIZE (mode
);
11980 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11981 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11982 add_loc_descr (&ret
, l1jump
);
11983 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
11984 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
11985 VAR_INIT_STATUS_INITIALIZED
);
11988 add_loc_descr (&ret
, tmp
);
11989 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11990 add_loc_descr (&ret
, l4jump
);
11991 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
11992 ? const1_rtx
: const0_rtx
,
11994 VAR_INIT_STATUS_INITIALIZED
);
11995 if (l1label
== NULL
)
11997 add_loc_descr (&ret
, l1label
);
11998 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11999 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
12000 add_loc_descr (&ret
, l2label
);
12001 if (GET_CODE (rtl
) != CLZ
)
12003 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
12004 msb
= GEN_INT ((unsigned HOST_WIDE_INT
) 1
12005 << (GET_MODE_BITSIZE (mode
) - 1));
12007 msb
= immed_wide_int_const
12008 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
12009 GET_MODE_PRECISION (mode
)), mode
);
12010 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
12011 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12012 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
12013 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
12015 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
12016 VAR_INIT_STATUS_INITIALIZED
);
12019 add_loc_descr (&ret
, tmp
);
12020 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12021 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12022 add_loc_descr (&ret
, l3jump
);
12023 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12024 VAR_INIT_STATUS_INITIALIZED
);
12027 add_loc_descr (&ret
, tmp
);
12028 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
12029 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
12030 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12031 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
12032 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12033 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12034 add_loc_descr (&ret
, l2jump
);
12035 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
12036 add_loc_descr (&ret
, l3label
);
12037 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
12038 add_loc_descr (&ret
, l4label
);
12039 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12040 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12041 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12042 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12043 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12044 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
12045 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12046 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
12050 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
12051 const1 is DW_OP_lit1 or corresponding typed constant):
12053 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12054 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12058 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12059 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12062 static dw_loc_descr_ref
12063 popcount_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12064 enum machine_mode mem_mode
)
12066 dw_loc_descr_ref op0
, ret
, tmp
;
12067 dw_loc_descr_ref l1jump
, l1label
;
12068 dw_loc_descr_ref l2jump
, l2label
;
12070 if (GET_MODE_CLASS (mode
) != MODE_INT
12071 || GET_MODE (XEXP (rtl
, 0)) != mode
)
12074 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12075 VAR_INIT_STATUS_INITIALIZED
);
12079 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12080 VAR_INIT_STATUS_INITIALIZED
);
12083 add_loc_descr (&ret
, tmp
);
12084 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12085 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
12086 add_loc_descr (&ret
, l1label
);
12087 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12088 add_loc_descr (&ret
, l2jump
);
12089 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12090 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
12091 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12092 VAR_INIT_STATUS_INITIALIZED
);
12095 add_loc_descr (&ret
, tmp
);
12096 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12097 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
12098 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
12099 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12100 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12101 VAR_INIT_STATUS_INITIALIZED
);
12102 add_loc_descr (&ret
, tmp
);
12103 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12104 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12105 add_loc_descr (&ret
, l1jump
);
12106 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
12107 add_loc_descr (&ret
, l2label
);
12108 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12109 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12110 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12111 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12115 /* BSWAP (constS is initial shift count, either 56 or 24):
12117 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
12118 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
12119 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
12120 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
12121 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
12123 static dw_loc_descr_ref
12124 bswap_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12125 enum machine_mode mem_mode
)
12127 dw_loc_descr_ref op0
, ret
, tmp
;
12128 dw_loc_descr_ref l1jump
, l1label
;
12129 dw_loc_descr_ref l2jump
, l2label
;
12131 if (GET_MODE_CLASS (mode
) != MODE_INT
12132 || BITS_PER_UNIT
!= 8
12133 || (GET_MODE_BITSIZE (mode
) != 32
12134 && GET_MODE_BITSIZE (mode
) != 64))
12137 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12138 VAR_INIT_STATUS_INITIALIZED
);
12143 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12145 VAR_INIT_STATUS_INITIALIZED
);
12148 add_loc_descr (&ret
, tmp
);
12149 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12150 VAR_INIT_STATUS_INITIALIZED
);
12153 add_loc_descr (&ret
, tmp
);
12154 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
12155 add_loc_descr (&ret
, l1label
);
12156 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12158 VAR_INIT_STATUS_INITIALIZED
);
12159 add_loc_descr (&ret
, tmp
);
12160 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
12161 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12162 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12163 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
12164 VAR_INIT_STATUS_INITIALIZED
);
12167 add_loc_descr (&ret
, tmp
);
12168 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12169 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
12170 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12171 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12172 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12173 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12174 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12175 VAR_INIT_STATUS_INITIALIZED
);
12176 add_loc_descr (&ret
, tmp
);
12177 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
12178 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12179 add_loc_descr (&ret
, l2jump
);
12180 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
12181 VAR_INIT_STATUS_INITIALIZED
);
12182 add_loc_descr (&ret
, tmp
);
12183 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12184 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12185 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12186 add_loc_descr (&ret
, l1jump
);
12187 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
12188 add_loc_descr (&ret
, l2label
);
12189 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12190 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
12191 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12192 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12193 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12194 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12198 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
12199 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12200 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
12201 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
12203 ROTATERT is similar:
12204 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
12205 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12206 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
12208 static dw_loc_descr_ref
12209 rotate_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12210 enum machine_mode mem_mode
)
12212 rtx rtlop1
= XEXP (rtl
, 1);
12213 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
12216 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12219 if (GET_MODE (rtlop1
) != VOIDmode
12220 && GET_MODE_BITSIZE (GET_MODE (rtlop1
)) < GET_MODE_BITSIZE (mode
))
12221 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12222 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12223 VAR_INIT_STATUS_INITIALIZED
);
12224 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12225 VAR_INIT_STATUS_INITIALIZED
);
12226 if (op0
== NULL
|| op1
== NULL
)
12228 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
12229 for (i
= 0; i
< 2; i
++)
12231 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
12232 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
12234 VAR_INIT_STATUS_INITIALIZED
);
12235 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12236 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12238 : HOST_BITS_PER_WIDE_INT
== 64
12239 ? DW_OP_const8u
: DW_OP_constu
,
12240 GET_MODE_MASK (mode
), 0);
12243 if (mask
[i
] == NULL
)
12245 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
12248 add_loc_descr (&ret
, op1
);
12249 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12250 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12251 if (GET_CODE (rtl
) == ROTATERT
)
12253 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12254 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12255 GET_MODE_BITSIZE (mode
), 0));
12257 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12258 if (mask
[0] != NULL
)
12259 add_loc_descr (&ret
, mask
[0]);
12260 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
12261 if (mask
[1] != NULL
)
12263 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12264 add_loc_descr (&ret
, mask
[1]);
12265 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12267 if (GET_CODE (rtl
) == ROTATE
)
12269 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12270 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12271 GET_MODE_BITSIZE (mode
), 0));
12273 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12274 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12278 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
12279 for DEBUG_PARAMETER_REF RTL. */
12281 static dw_loc_descr_ref
12282 parameter_ref_descriptor (rtx rtl
)
12284 dw_loc_descr_ref ret
;
12289 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
12290 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
12291 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
12294 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12295 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
12296 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12300 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
12301 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
12306 /* The following routine converts the RTL for a variable or parameter
12307 (resident in memory) into an equivalent Dwarf representation of a
12308 mechanism for getting the address of that same variable onto the top of a
12309 hypothetical "address evaluation" stack.
12311 When creating memory location descriptors, we are effectively transforming
12312 the RTL for a memory-resident object into its Dwarf postfix expression
12313 equivalent. This routine recursively descends an RTL tree, turning
12314 it into Dwarf postfix code as it goes.
12316 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
12318 MEM_MODE is the mode of the memory reference, needed to handle some
12319 autoincrement addressing modes.
12321 Return 0 if we can't represent the location. */
12324 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12325 enum machine_mode mem_mode
,
12326 enum var_init_status initialized
)
12328 dw_loc_descr_ref mem_loc_result
= NULL
;
12329 enum dwarf_location_atom op
;
12330 dw_loc_descr_ref op0
, op1
;
12331 rtx inner
= NULL_RTX
;
12333 if (mode
== VOIDmode
)
12334 mode
= GET_MODE (rtl
);
12336 /* Note that for a dynamically sized array, the location we will generate a
12337 description of here will be the lowest numbered location which is
12338 actually within the array. That's *not* necessarily the same as the
12339 zeroth element of the array. */
12341 rtl
= targetm
.delegitimize_address (rtl
);
12343 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
12346 switch (GET_CODE (rtl
))
12351 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
12354 /* The case of a subreg may arise when we have a local (register)
12355 variable or a formal (register) parameter which doesn't quite fill
12356 up an entire register. For now, just assume that it is
12357 legitimate to make the Dwarf info refer to the whole register which
12358 contains the given subreg. */
12359 if (!subreg_lowpart_p (rtl
))
12361 inner
= SUBREG_REG (rtl
);
12363 if (inner
== NULL_RTX
)
12364 inner
= XEXP (rtl
, 0);
12365 if (GET_MODE_CLASS (mode
) == MODE_INT
12366 && GET_MODE_CLASS (GET_MODE (inner
)) == MODE_INT
12367 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12368 #ifdef POINTERS_EXTEND_UNSIGNED
12369 || (mode
== Pmode
&& mem_mode
!= VOIDmode
)
12372 && GET_MODE_SIZE (GET_MODE (inner
)) <= DWARF2_ADDR_SIZE
)
12374 mem_loc_result
= mem_loc_descriptor (inner
,
12376 mem_mode
, initialized
);
12381 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (inner
)))
12383 if (GET_MODE_SIZE (mode
) != GET_MODE_SIZE (GET_MODE (inner
))
12384 && (GET_MODE_CLASS (mode
) != MODE_INT
12385 || GET_MODE_CLASS (GET_MODE (inner
)) != MODE_INT
))
12389 dw_die_ref type_die
;
12390 dw_loc_descr_ref cvt
;
12392 mem_loc_result
= mem_loc_descriptor (inner
,
12394 mem_mode
, initialized
);
12395 if (mem_loc_result
== NULL
)
12397 type_die
= base_type_for_mode (mode
,
12398 GET_MODE_CLASS (mode
) == MODE_INT
);
12399 if (type_die
== NULL
)
12401 mem_loc_result
= NULL
;
12404 if (GET_MODE_SIZE (mode
)
12405 != GET_MODE_SIZE (GET_MODE (inner
)))
12406 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12408 cvt
= new_loc_descr (DW_OP_GNU_reinterpret
, 0, 0);
12409 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12410 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12411 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12412 add_loc_descr (&mem_loc_result
, cvt
);
12417 if (GET_MODE_CLASS (mode
) != MODE_INT
12418 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12419 && rtl
!= arg_pointer_rtx
12420 && rtl
!= frame_pointer_rtx
12421 #ifdef POINTERS_EXTEND_UNSIGNED
12422 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12426 dw_die_ref type_die
;
12427 unsigned int dbx_regnum
;
12431 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
12433 type_die
= base_type_for_mode (mode
,
12434 GET_MODE_CLASS (mode
) == MODE_INT
);
12435 if (type_die
== NULL
)
12438 dbx_regnum
= dbx_reg_number (rtl
);
12439 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12441 mem_loc_result
= new_loc_descr (DW_OP_GNU_regval_type
,
12443 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12444 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12445 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12448 /* Whenever a register number forms a part of the description of the
12449 method for calculating the (dynamic) address of a memory resident
12450 object, DWARF rules require the register number be referred to as
12451 a "base register". This distinction is not based in any way upon
12452 what category of register the hardware believes the given register
12453 belongs to. This is strictly DWARF terminology we're dealing with
12454 here. Note that in cases where the location of a memory-resident
12455 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12456 OP_CONST (0)) the actual DWARF location descriptor that we generate
12457 may just be OP_BASEREG (basereg). This may look deceptively like
12458 the object in question was allocated to a register (rather than in
12459 memory) so DWARF consumers need to be aware of the subtle
12460 distinction between OP_REG and OP_BASEREG. */
12461 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
12462 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
12463 else if (stack_realign_drap
12465 && crtl
->args
.internal_arg_pointer
== rtl
12466 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
12468 /* If RTL is internal_arg_pointer, which has been optimized
12469 out, use DRAP instead. */
12470 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
12471 VAR_INIT_STATUS_INITIALIZED
);
12477 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12479 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12480 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12483 else if (GET_CODE (rtl
) == ZERO_EXTEND
12484 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12485 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
12486 < HOST_BITS_PER_WIDE_INT
12487 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
12488 to expand zero extend as two shifts instead of
12490 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= 4)
12492 enum machine_mode imode
= GET_MODE (XEXP (rtl
, 0));
12493 mem_loc_result
= op0
;
12494 add_loc_descr (&mem_loc_result
,
12495 int_loc_descriptor (GET_MODE_MASK (imode
)));
12496 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
12498 else if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12500 int shift
= DWARF2_ADDR_SIZE
12501 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
12502 shift
*= BITS_PER_UNIT
;
12503 if (GET_CODE (rtl
) == SIGN_EXTEND
)
12507 mem_loc_result
= op0
;
12508 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12509 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
12510 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12511 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12513 else if (!dwarf_strict
)
12515 dw_die_ref type_die1
, type_die2
;
12516 dw_loc_descr_ref cvt
;
12518 type_die1
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
12519 GET_CODE (rtl
) == ZERO_EXTEND
);
12520 if (type_die1
== NULL
)
12522 type_die2
= base_type_for_mode (mode
, 1);
12523 if (type_die2
== NULL
)
12525 mem_loc_result
= op0
;
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_die1
;
12529 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12530 add_loc_descr (&mem_loc_result
, cvt
);
12531 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12532 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12533 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
12534 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12535 add_loc_descr (&mem_loc_result
, cvt
);
12541 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
12542 if (new_rtl
!= rtl
)
12544 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
12546 if (mem_loc_result
!= NULL
)
12547 return mem_loc_result
;
12550 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
12551 get_address_mode (rtl
), mode
,
12552 VAR_INIT_STATUS_INITIALIZED
);
12553 if (mem_loc_result
== NULL
)
12554 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
12555 if (mem_loc_result
!= NULL
)
12557 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12558 || GET_MODE_CLASS (mode
) != MODE_INT
)
12560 dw_die_ref type_die
;
12561 dw_loc_descr_ref deref
;
12566 = base_type_for_mode (mode
, GET_MODE_CLASS (mode
) == MODE_INT
);
12567 if (type_die
== NULL
)
12569 deref
= new_loc_descr (DW_OP_GNU_deref_type
,
12570 GET_MODE_SIZE (mode
), 0);
12571 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12572 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12573 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12574 add_loc_descr (&mem_loc_result
, deref
);
12576 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
12577 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
12579 add_loc_descr (&mem_loc_result
,
12580 new_loc_descr (DW_OP_deref_size
,
12581 GET_MODE_SIZE (mode
), 0));
12586 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
12589 /* Some ports can transform a symbol ref into a label ref, because
12590 the symbol ref is too far away and has to be dumped into a constant
12594 if (GET_MODE_CLASS (mode
) != MODE_INT
12595 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12596 #ifdef POINTERS_EXTEND_UNSIGNED
12597 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12601 if (GET_CODE (rtl
) == SYMBOL_REF
12602 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
12604 dw_loc_descr_ref temp
;
12606 /* If this is not defined, we have no way to emit the data. */
12607 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
12610 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
12612 mem_loc_result
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
12613 add_loc_descr (&mem_loc_result
, temp
);
12618 if (!const_ok_for_output (rtl
))
12622 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
12623 vec_safe_push (used_rtx_array
, rtl
);
12629 case DEBUG_IMPLICIT_PTR
:
12630 expansion_failed (NULL_TREE
, rtl
,
12631 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
12637 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
12639 if (GET_MODE_CLASS (mode
) != MODE_INT
12640 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12641 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12642 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12645 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
12646 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12648 op0
= one_reg_loc_descriptor (dbx_regnum
,
12649 VAR_INIT_STATUS_INITIALIZED
);
12652 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
12653 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
12655 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12656 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12657 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
12661 gcc_unreachable ();
12664 mem_loc_result
= new_loc_descr (DW_OP_GNU_entry_value
, 0, 0);
12665 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12666 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
12669 case DEBUG_PARAMETER_REF
:
12670 mem_loc_result
= parameter_ref_descriptor (rtl
);
12674 /* Extract the PLUS expression nested inside and fall into
12675 PLUS code below. */
12676 rtl
= XEXP (rtl
, 1);
12681 /* Turn these into a PLUS expression and fall into the PLUS code
12683 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
12684 gen_int_mode (GET_CODE (rtl
) == PRE_INC
12685 ? GET_MODE_UNIT_SIZE (mem_mode
)
12686 : -GET_MODE_UNIT_SIZE (mem_mode
),
12689 /* ... fall through ... */
12693 if (is_based_loc (rtl
)
12694 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12695 || XEXP (rtl
, 0) == arg_pointer_rtx
12696 || XEXP (rtl
, 0) == frame_pointer_rtx
)
12697 && GET_MODE_CLASS (mode
) == MODE_INT
)
12698 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
12699 INTVAL (XEXP (rtl
, 1)),
12700 VAR_INIT_STATUS_INITIALIZED
);
12703 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12704 VAR_INIT_STATUS_INITIALIZED
);
12705 if (mem_loc_result
== 0)
12708 if (CONST_INT_P (XEXP (rtl
, 1))
12709 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12710 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
12713 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12714 VAR_INIT_STATUS_INITIALIZED
);
12717 add_loc_descr (&mem_loc_result
, op1
);
12718 add_loc_descr (&mem_loc_result
,
12719 new_loc_descr (DW_OP_plus
, 0, 0));
12724 /* If a pseudo-reg is optimized away, it is possible for it to
12725 be replaced with a MEM containing a multiply or shift. */
12736 && GET_MODE_CLASS (mode
) == MODE_INT
12737 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12739 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12740 base_type_for_mode (mode
, 0),
12764 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12766 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12767 VAR_INIT_STATUS_INITIALIZED
);
12769 rtx rtlop1
= XEXP (rtl
, 1);
12770 if (GET_MODE (rtlop1
) != VOIDmode
12771 && GET_MODE_BITSIZE (GET_MODE (rtlop1
))
12772 < GET_MODE_BITSIZE (mode
))
12773 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12774 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12775 VAR_INIT_STATUS_INITIALIZED
);
12778 if (op0
== 0 || op1
== 0)
12781 mem_loc_result
= op0
;
12782 add_loc_descr (&mem_loc_result
, op1
);
12783 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12799 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12800 VAR_INIT_STATUS_INITIALIZED
);
12801 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12802 VAR_INIT_STATUS_INITIALIZED
);
12804 if (op0
== 0 || op1
== 0)
12807 mem_loc_result
= op0
;
12808 add_loc_descr (&mem_loc_result
, op1
);
12809 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12813 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
&& !dwarf_strict
)
12815 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
12816 base_type_for_mode (mode
, 0),
12821 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12822 VAR_INIT_STATUS_INITIALIZED
);
12823 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12824 VAR_INIT_STATUS_INITIALIZED
);
12826 if (op0
== 0 || op1
== 0)
12829 mem_loc_result
= op0
;
12830 add_loc_descr (&mem_loc_result
, op1
);
12831 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12832 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12833 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
12834 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
12835 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
12839 if (!dwarf_strict
&& GET_MODE_CLASS (mode
) == MODE_INT
)
12841 if (GET_MODE_CLASS (mode
) > DWARF2_ADDR_SIZE
)
12846 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12847 base_type_for_mode (mode
, 1),
12865 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12866 VAR_INIT_STATUS_INITIALIZED
);
12871 mem_loc_result
= op0
;
12872 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12876 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12877 #ifdef POINTERS_EXTEND_UNSIGNED
12879 && mem_mode
!= VOIDmode
12880 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
12884 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12888 && (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
12889 || GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_DOUBLE_INT
))
12891 dw_die_ref type_die
= base_type_for_mode (mode
, 1);
12892 enum machine_mode amode
;
12893 if (type_die
== NULL
)
12895 amode
= mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
,
12897 if (INTVAL (rtl
) >= 0
12898 && amode
!= BLKmode
12899 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
12900 /* const DW_OP_GNU_convert <XXX> vs.
12901 DW_OP_GNU_const_type <XXX, 1, const>. */
12902 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
12903 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode
))
12905 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12906 op0
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12907 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12908 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12909 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12910 add_loc_descr (&mem_loc_result
, op0
);
12911 return mem_loc_result
;
12913 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0,
12915 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12916 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12917 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12918 if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12919 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
12922 mem_loc_result
->dw_loc_oprnd2
.val_class
12923 = dw_val_class_const_double
;
12924 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12925 = double_int::from_shwi (INTVAL (rtl
));
12933 dw_die_ref type_die
;
12935 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
12936 CONST_DOUBLE rtx could represent either a large integer
12937 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
12938 the value is always a floating point constant.
12940 When it is an integer, a CONST_DOUBLE is used whenever
12941 the constant requires 2 HWIs to be adequately represented.
12942 We output CONST_DOUBLEs as blocks. */
12943 if (mode
== VOIDmode
12944 || (GET_MODE (rtl
) == VOIDmode
12945 && GET_MODE_BITSIZE (mode
) != HOST_BITS_PER_DOUBLE_INT
))
12947 type_die
= base_type_for_mode (mode
,
12948 GET_MODE_CLASS (mode
) == MODE_INT
);
12949 if (type_die
== NULL
)
12951 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
12952 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12953 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12954 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12955 #if TARGET_SUPPORTS_WIDE_INT == 0
12956 if (!SCALAR_FLOAT_MODE_P (mode
))
12958 mem_loc_result
->dw_loc_oprnd2
.val_class
12959 = dw_val_class_const_double
;
12960 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12961 = rtx_to_double_int (rtl
);
12966 unsigned int length
= GET_MODE_SIZE (mode
);
12967 unsigned char *array
12968 = (unsigned char*) ggc_alloc_atomic (length
);
12970 insert_float (rtl
, array
);
12971 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
12972 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
12973 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
12974 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
12979 case CONST_WIDE_INT
:
12982 dw_die_ref type_die
;
12984 type_die
= base_type_for_mode (mode
,
12985 GET_MODE_CLASS (mode
) == MODE_INT
);
12986 if (type_die
== NULL
)
12988 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
12989 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12990 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12991 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12992 mem_loc_result
->dw_loc_oprnd2
.val_class
12993 = dw_val_class_wide_int
;
12994 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc_cleared_wide_int ();
12995 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= std::make_pair (rtl
, mode
);
13000 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
13004 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
13008 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
13012 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
13016 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
13020 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
13024 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
13028 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
13032 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
13036 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
13041 if (GET_MODE_CLASS (mode
) != MODE_INT
)
13046 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
13051 if (CONST_INT_P (XEXP (rtl
, 1))
13052 && CONST_INT_P (XEXP (rtl
, 2))
13053 && ((unsigned) INTVAL (XEXP (rtl
, 1))
13054 + (unsigned) INTVAL (XEXP (rtl
, 2))
13055 <= GET_MODE_BITSIZE (mode
))
13056 && GET_MODE_CLASS (mode
) == MODE_INT
13057 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
13058 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
13061 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
13062 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13065 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
13069 mem_loc_result
= op0
;
13070 size
= INTVAL (XEXP (rtl
, 1));
13071 shift
= INTVAL (XEXP (rtl
, 2));
13072 if (BITS_BIG_ENDIAN
)
13073 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
13075 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
13077 add_loc_descr (&mem_loc_result
,
13078 int_loc_descriptor (DWARF2_ADDR_SIZE
13080 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
13082 if (size
!= (int) DWARF2_ADDR_SIZE
)
13084 add_loc_descr (&mem_loc_result
,
13085 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
13086 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13093 dw_loc_descr_ref op2
, bra_node
, drop_node
;
13094 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
13095 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
13096 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
13097 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13098 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
13099 VAR_INIT_STATUS_INITIALIZED
);
13100 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
13101 VAR_INIT_STATUS_INITIALIZED
);
13102 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
13105 mem_loc_result
= op1
;
13106 add_loc_descr (&mem_loc_result
, op2
);
13107 add_loc_descr (&mem_loc_result
, op0
);
13108 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
13109 add_loc_descr (&mem_loc_result
, bra_node
);
13110 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
13111 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
13112 add_loc_descr (&mem_loc_result
, drop_node
);
13113 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13114 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
13119 case FLOAT_TRUNCATE
:
13121 case UNSIGNED_FLOAT
:
13126 dw_die_ref type_die
;
13127 dw_loc_descr_ref cvt
;
13129 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
13130 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13133 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl
, 0))) == MODE_INT
13134 && (GET_CODE (rtl
) == FLOAT
13135 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)))
13136 <= DWARF2_ADDR_SIZE
))
13138 type_die
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
13139 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
13140 if (type_die
== NULL
)
13142 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13143 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13144 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13145 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13146 add_loc_descr (&op0
, cvt
);
13148 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
13149 if (type_die
== NULL
)
13151 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13152 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13153 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13154 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13155 add_loc_descr (&op0
, cvt
);
13156 if (GET_MODE_CLASS (mode
) == MODE_INT
13157 && (GET_CODE (rtl
) == FIX
13158 || GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
))
13160 op0
= convert_descriptor_to_mode (mode
, op0
);
13164 mem_loc_result
= op0
;
13171 mem_loc_result
= clz_loc_descriptor (rtl
, mode
, mem_mode
);
13176 mem_loc_result
= popcount_loc_descriptor (rtl
, mode
, mem_mode
);
13180 mem_loc_result
= bswap_loc_descriptor (rtl
, mode
, mem_mode
);
13185 mem_loc_result
= rotate_loc_descriptor (rtl
, mode
, mem_mode
);
13189 /* In theory, we could implement the above. */
13190 /* DWARF cannot represent the unsigned compare operations
13215 case FRACT_CONVERT
:
13216 case UNSIGNED_FRACT_CONVERT
:
13218 case UNSIGNED_SAT_FRACT
:
13224 case VEC_DUPLICATE
:
13228 case STRICT_LOW_PART
:
13233 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13234 can't express it in the debug info. This can happen e.g. with some
13239 resolve_one_addr (&rtl
, NULL
);
13243 #ifdef ENABLE_CHECKING
13244 print_rtl (stderr
, rtl
);
13245 gcc_unreachable ();
13251 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13252 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13254 return mem_loc_result
;
13257 /* Return a descriptor that describes the concatenation of two locations.
13258 This is typically a complex variable. */
13260 static dw_loc_descr_ref
13261 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
13263 dw_loc_descr_ref cc_loc_result
= NULL
;
13264 dw_loc_descr_ref x0_ref
13265 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13266 dw_loc_descr_ref x1_ref
13267 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13269 if (x0_ref
== 0 || x1_ref
== 0)
13272 cc_loc_result
= x0_ref
;
13273 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
13275 add_loc_descr (&cc_loc_result
, x1_ref
);
13276 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
13278 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13279 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13281 return cc_loc_result
;
13284 /* Return a descriptor that describes the concatenation of N
13287 static dw_loc_descr_ref
13288 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
13291 dw_loc_descr_ref cc_loc_result
= NULL
;
13292 unsigned int n
= XVECLEN (concatn
, 0);
13294 for (i
= 0; i
< n
; ++i
)
13296 dw_loc_descr_ref ref
;
13297 rtx x
= XVECEXP (concatn
, 0, i
);
13299 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13303 add_loc_descr (&cc_loc_result
, ref
);
13304 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
13307 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13308 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13310 return cc_loc_result
;
13313 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
13314 for DEBUG_IMPLICIT_PTR RTL. */
13316 static dw_loc_descr_ref
13317 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
13319 dw_loc_descr_ref ret
;
13324 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
13325 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
13326 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
13327 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
13328 ret
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
13329 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13332 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13333 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
13334 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13338 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
13339 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
13344 /* Output a proper Dwarf location descriptor for a variable or parameter
13345 which is either allocated in a register or in a memory location. For a
13346 register, we just generate an OP_REG and the register number. For a
13347 memory location we provide a Dwarf postfix expression describing how to
13348 generate the (dynamic) address of the object onto the address stack.
13350 MODE is mode of the decl if this loc_descriptor is going to be used in
13351 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13352 allowed, VOIDmode otherwise.
13354 If we don't know how to describe it, return 0. */
13356 static dw_loc_descr_ref
13357 loc_descriptor (rtx rtl
, enum machine_mode mode
,
13358 enum var_init_status initialized
)
13360 dw_loc_descr_ref loc_result
= NULL
;
13362 switch (GET_CODE (rtl
))
13365 /* The case of a subreg may arise when we have a local (register)
13366 variable or a formal (register) parameter which doesn't quite fill
13367 up an entire register. For now, just assume that it is
13368 legitimate to make the Dwarf info refer to the whole register which
13369 contains the given subreg. */
13370 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
13371 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
13372 GET_MODE (SUBREG_REG (rtl
)), initialized
);
13378 loc_result
= reg_loc_descriptor (rtl
, initialized
);
13382 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
13383 GET_MODE (rtl
), initialized
);
13384 if (loc_result
== NULL
)
13385 loc_result
= tls_mem_loc_descriptor (rtl
);
13386 if (loc_result
== NULL
)
13388 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
13389 if (new_rtl
!= rtl
)
13390 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
13395 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
13400 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
13405 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
13407 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
13408 if (GET_CODE (loc
) == EXPR_LIST
)
13409 loc
= XEXP (loc
, 0);
13410 loc_result
= loc_descriptor (loc
, mode
, initialized
);
13414 rtl
= XEXP (rtl
, 1);
13419 rtvec par_elems
= XVEC (rtl
, 0);
13420 int num_elem
= GET_NUM_ELEM (par_elems
);
13421 enum machine_mode mode
;
13424 /* Create the first one, so we have something to add to. */
13425 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
13426 VOIDmode
, initialized
);
13427 if (loc_result
== NULL
)
13429 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
13430 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13431 for (i
= 1; i
< num_elem
; i
++)
13433 dw_loc_descr_ref temp
;
13435 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
13436 VOIDmode
, initialized
);
13439 add_loc_descr (&loc_result
, temp
);
13440 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
13441 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13447 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
13448 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
13453 if (mode
== VOIDmode
)
13454 mode
= GET_MODE (rtl
);
13456 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13458 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13460 /* Note that a CONST_DOUBLE rtx could represent either an integer
13461 or a floating-point constant. A CONST_DOUBLE is used whenever
13462 the constant requires more than one word in order to be
13463 adequately represented. We output CONST_DOUBLEs as blocks. */
13464 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13465 GET_MODE_SIZE (mode
), 0);
13466 #if TARGET_SUPPORTS_WIDE_INT == 0
13467 if (!SCALAR_FLOAT_MODE_P (mode
))
13469 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
13470 loc_result
->dw_loc_oprnd2
.v
.val_double
13471 = rtx_to_double_int (rtl
);
13476 unsigned int length
= GET_MODE_SIZE (mode
);
13477 unsigned char *array
13478 = (unsigned char*) ggc_alloc_atomic (length
);
13480 insert_float (rtl
, array
);
13481 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13482 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
13483 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
13484 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13489 case CONST_WIDE_INT
:
13490 if (mode
== VOIDmode
)
13491 mode
= GET_MODE (rtl
);
13493 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13495 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13496 GET_MODE_SIZE (mode
), 0);
13497 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
13498 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc_cleared_wide_int ();
13499 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= std::make_pair (rtl
, mode
);
13504 if (mode
== VOIDmode
)
13505 mode
= GET_MODE (rtl
);
13507 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13509 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
13510 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
13511 unsigned char *array
= (unsigned char *)
13512 ggc_alloc_atomic (length
* elt_size
);
13515 enum machine_mode imode
= GET_MODE_INNER (mode
);
13517 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13518 switch (GET_MODE_CLASS (mode
))
13520 case MODE_VECTOR_INT
:
13521 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13523 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13524 insert_wide_int (std::make_pair (elt
, imode
), p
, elt_size
);
13528 case MODE_VECTOR_FLOAT
:
13529 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13531 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13532 insert_float (elt
, p
);
13537 gcc_unreachable ();
13540 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13541 length
* elt_size
, 0);
13542 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13543 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
13544 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
13545 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13550 if (mode
== VOIDmode
13551 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
13552 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
13553 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
13555 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
13560 if (!const_ok_for_output (rtl
))
13563 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
13564 && (dwarf_version
>= 4 || !dwarf_strict
))
13566 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
13567 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13568 vec_safe_push (used_rtx_array
, rtl
);
13572 case DEBUG_IMPLICIT_PTR
:
13573 loc_result
= implicit_ptr_descriptor (rtl
, 0);
13577 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
13578 && CONST_INT_P (XEXP (rtl
, 1)))
13581 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
13587 if ((GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE (rtl
) == mode
13588 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
13589 && dwarf_version
>= 4)
13590 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
13592 /* Value expression. */
13593 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
13595 add_loc_descr (&loc_result
,
13596 new_loc_descr (DW_OP_stack_value
, 0, 0));
13604 /* We need to figure out what section we should use as the base for the
13605 address ranges where a given location is valid.
13606 1. If this particular DECL has a section associated with it, use that.
13607 2. If this function has a section associated with it, use that.
13608 3. Otherwise, use the text section.
13609 XXX: If you split a variable across multiple sections, we won't notice. */
13611 static const char *
13612 secname_for_decl (const_tree decl
)
13614 const char *secname
;
13616 if (VAR_OR_FUNCTION_DECL_P (decl
) && DECL_SECTION_NAME (decl
))
13618 tree sectree
= DECL_SECTION_NAME (decl
);
13619 secname
= TREE_STRING_POINTER (sectree
);
13621 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
13623 tree sectree
= DECL_SECTION_NAME (current_function_decl
);
13624 secname
= TREE_STRING_POINTER (sectree
);
13626 else if (cfun
&& in_cold_section_p
)
13627 secname
= crtl
->subsections
.cold_section_label
;
13629 secname
= text_section_label
;
13634 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13637 decl_by_reference_p (tree decl
)
13639 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
13640 || TREE_CODE (decl
) == VAR_DECL
)
13641 && DECL_BY_REFERENCE (decl
));
13644 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13647 static dw_loc_descr_ref
13648 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
13649 enum var_init_status initialized
)
13651 int have_address
= 0;
13652 dw_loc_descr_ref descr
;
13653 enum machine_mode mode
;
13655 if (want_address
!= 2)
13657 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
13659 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13661 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13662 if (GET_CODE (varloc
) == EXPR_LIST
)
13663 varloc
= XEXP (varloc
, 0);
13664 mode
= GET_MODE (varloc
);
13665 if (MEM_P (varloc
))
13667 rtx addr
= XEXP (varloc
, 0);
13668 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
13669 mode
, initialized
);
13674 rtx x
= avoid_constant_pool_reference (varloc
);
13676 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
13681 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
13688 if (GET_CODE (varloc
) == VAR_LOCATION
)
13689 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
13691 mode
= DECL_MODE (loc
);
13692 descr
= loc_descriptor (varloc
, mode
, initialized
);
13699 if (want_address
== 2 && !have_address
13700 && (dwarf_version
>= 4 || !dwarf_strict
))
13702 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
13704 expansion_failed (loc
, NULL_RTX
,
13705 "DWARF address size mismatch");
13708 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13711 /* Show if we can't fill the request for an address. */
13712 if (want_address
&& !have_address
)
13714 expansion_failed (loc
, NULL_RTX
,
13715 "Want address and only have value");
13719 /* If we've got an address and don't want one, dereference. */
13720 if (!want_address
&& have_address
)
13722 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
13723 enum dwarf_location_atom op
;
13725 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
13727 expansion_failed (loc
, NULL_RTX
,
13728 "DWARF address size mismatch");
13731 else if (size
== DWARF2_ADDR_SIZE
)
13734 op
= DW_OP_deref_size
;
13736 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
13742 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
13743 if it is not possible. */
13745 static dw_loc_descr_ref
13746 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
13748 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
13749 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
13750 else if (dwarf_version
>= 3 || !dwarf_strict
)
13751 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
13756 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13757 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
13759 static dw_loc_descr_ref
13760 dw_sra_loc_expr (tree decl
, rtx loc
)
13763 unsigned int padsize
= 0;
13764 dw_loc_descr_ref descr
, *descr_tail
;
13765 unsigned HOST_WIDE_INT decl_size
;
13767 enum var_init_status initialized
;
13769 if (DECL_SIZE (decl
) == NULL
13770 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
13773 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
13775 descr_tail
= &descr
;
13777 for (p
= loc
; p
; p
= XEXP (p
, 1))
13779 unsigned int bitsize
= decl_piece_bitsize (p
);
13780 rtx loc_note
= *decl_piece_varloc_ptr (p
);
13781 dw_loc_descr_ref cur_descr
;
13782 dw_loc_descr_ref
*tail
, last
= NULL
;
13783 unsigned int opsize
= 0;
13785 if (loc_note
== NULL_RTX
13786 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
13788 padsize
+= bitsize
;
13791 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
13792 varloc
= NOTE_VAR_LOCATION (loc_note
);
13793 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
13794 if (cur_descr
== NULL
)
13796 padsize
+= bitsize
;
13800 /* Check that cur_descr either doesn't use
13801 DW_OP_*piece operations, or their sum is equal
13802 to bitsize. Otherwise we can't embed it. */
13803 for (tail
= &cur_descr
; *tail
!= NULL
;
13804 tail
= &(*tail
)->dw_loc_next
)
13805 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
13807 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
13811 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
13813 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
13817 if (last
!= NULL
&& opsize
!= bitsize
)
13819 padsize
+= bitsize
;
13820 /* Discard the current piece of the descriptor and release any
13821 addr_table entries it uses. */
13822 remove_loc_list_addr_table_entries (cur_descr
);
13826 /* If there is a hole, add DW_OP_*piece after empty DWARF
13827 expression, which means that those bits are optimized out. */
13830 if (padsize
> decl_size
)
13832 remove_loc_list_addr_table_entries (cur_descr
);
13833 goto discard_descr
;
13835 decl_size
-= padsize
;
13836 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
13837 if (*descr_tail
== NULL
)
13839 remove_loc_list_addr_table_entries (cur_descr
);
13840 goto discard_descr
;
13842 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13845 *descr_tail
= cur_descr
;
13847 if (bitsize
> decl_size
)
13848 goto discard_descr
;
13849 decl_size
-= bitsize
;
13852 HOST_WIDE_INT offset
= 0;
13853 if (GET_CODE (varloc
) == VAR_LOCATION
13854 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13856 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13857 if (GET_CODE (varloc
) == EXPR_LIST
)
13858 varloc
= XEXP (varloc
, 0);
13862 if (GET_CODE (varloc
) == CONST
13863 || GET_CODE (varloc
) == SIGN_EXTEND
13864 || GET_CODE (varloc
) == ZERO_EXTEND
)
13865 varloc
= XEXP (varloc
, 0);
13866 else if (GET_CODE (varloc
) == SUBREG
)
13867 varloc
= SUBREG_REG (varloc
);
13872 /* DW_OP_bit_size offset should be zero for register
13873 or implicit location descriptions and empty location
13874 descriptions, but for memory addresses needs big endian
13876 if (MEM_P (varloc
))
13878 unsigned HOST_WIDE_INT memsize
13879 = MEM_SIZE (varloc
) * BITS_PER_UNIT
;
13880 if (memsize
!= bitsize
)
13882 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
13883 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
13884 goto discard_descr
;
13885 if (memsize
< bitsize
)
13886 goto discard_descr
;
13887 if (BITS_BIG_ENDIAN
)
13888 offset
= memsize
- bitsize
;
13892 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
13893 if (*descr_tail
== NULL
)
13894 goto discard_descr
;
13895 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13899 /* If there were any non-empty expressions, add padding till the end of
13901 if (descr
!= NULL
&& decl_size
!= 0)
13903 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
13904 if (*descr_tail
== NULL
)
13905 goto discard_descr
;
13910 /* Discard the descriptor and release any addr_table entries it uses. */
13911 remove_loc_list_addr_table_entries (descr
);
13915 /* Return the dwarf representation of the location list LOC_LIST of
13916 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
13919 static dw_loc_list_ref
13920 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
13922 const char *endname
, *secname
;
13924 enum var_init_status initialized
;
13925 struct var_loc_node
*node
;
13926 dw_loc_descr_ref descr
;
13927 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
13928 dw_loc_list_ref list
= NULL
;
13929 dw_loc_list_ref
*listp
= &list
;
13931 /* Now that we know what section we are using for a base,
13932 actually construct the list of locations.
13933 The first location information is what is passed to the
13934 function that creates the location list, and the remaining
13935 locations just get added on to that list.
13936 Note that we only know the start address for a location
13937 (IE location changes), so to build the range, we use
13938 the range [current location start, next location start].
13939 This means we have to special case the last node, and generate
13940 a range of [last location start, end of function label]. */
13942 secname
= secname_for_decl (decl
);
13944 for (node
= loc_list
->first
; node
; node
= node
->next
)
13945 if (GET_CODE (node
->loc
) == EXPR_LIST
13946 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
13948 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13950 /* This requires DW_OP_{,bit_}piece, which is not usable
13951 inside DWARF expressions. */
13952 if (want_address
!= 2)
13954 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13960 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13961 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13962 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
13966 bool range_across_switch
= false;
13967 /* If section switch happens in between node->label
13968 and node->next->label (or end of function) and
13969 we can't emit it as a single entry list,
13970 emit two ranges, first one ending at the end
13971 of first partition and second one starting at the
13972 beginning of second partition. */
13973 if (node
== loc_list
->last_before_switch
13974 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
13975 && current_function_decl
)
13977 endname
= cfun
->fde
->dw_fde_end
;
13978 range_across_switch
= true;
13980 /* The variable has a location between NODE->LABEL and
13981 NODE->NEXT->LABEL. */
13982 else if (node
->next
)
13983 endname
= node
->next
->label
;
13984 /* If the variable has a location at the last label
13985 it keeps its location until the end of function. */
13986 else if (!current_function_decl
)
13987 endname
= text_end_label
;
13990 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
13991 current_function_funcdef_no
);
13992 endname
= ggc_strdup (label_id
);
13995 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
13996 if (TREE_CODE (decl
) == PARM_DECL
13997 && node
== loc_list
->first
13998 && NOTE_P (node
->loc
)
13999 && strcmp (node
->label
, endname
) == 0)
14000 (*listp
)->force
= true;
14001 listp
= &(*listp
)->dw_loc_next
;
14003 if (range_across_switch
)
14005 if (GET_CODE (node
->loc
) == EXPR_LIST
)
14006 descr
= dw_sra_loc_expr (decl
, node
->loc
);
14009 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
14010 varloc
= NOTE_VAR_LOCATION (node
->loc
);
14011 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
14014 gcc_assert (descr
);
14015 /* The variable has a location between NODE->LABEL and
14016 NODE->NEXT->LABEL. */
14018 endname
= node
->next
->label
;
14020 endname
= cfun
->fde
->dw_fde_second_end
;
14021 *listp
= new_loc_list (descr
,
14022 cfun
->fde
->dw_fde_second_begin
,
14024 listp
= &(*listp
)->dw_loc_next
;
14029 /* Try to avoid the overhead of a location list emitting a location
14030 expression instead, but only if we didn't have more than one
14031 location entry in the first place. If some entries were not
14032 representable, we don't want to pretend a single entry that was
14033 applies to the entire scope in which the variable is
14035 if (list
&& loc_list
->first
->next
)
14041 /* Return if the loc_list has only single element and thus can be represented
14042 as location description. */
14045 single_element_loc_list_p (dw_loc_list_ref list
)
14047 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
14048 return !list
->ll_symbol
;
14051 /* To each location in list LIST add loc descr REF. */
14054 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
14056 dw_loc_descr_ref copy
;
14057 add_loc_descr (&list
->expr
, ref
);
14058 list
= list
->dw_loc_next
;
14061 copy
= ggc_alloc_dw_loc_descr_node ();
14062 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
14063 add_loc_descr (&list
->expr
, copy
);
14064 while (copy
->dw_loc_next
)
14066 dw_loc_descr_ref new_copy
= ggc_alloc_dw_loc_descr_node ();
14067 memcpy (new_copy
, copy
->dw_loc_next
, sizeof (dw_loc_descr_node
));
14068 copy
->dw_loc_next
= new_copy
;
14071 list
= list
->dw_loc_next
;
14075 /* Given two lists RET and LIST
14076 produce location list that is result of adding expression in LIST
14077 to expression in RET on each position in program.
14078 Might be destructive on both RET and LIST.
14080 TODO: We handle only simple cases of RET or LIST having at most one
14081 element. General case would inolve sorting the lists in program order
14082 and merging them that will need some additional work.
14083 Adding that will improve quality of debug info especially for SRA-ed
14087 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
14096 if (!list
->dw_loc_next
)
14098 add_loc_descr_to_each (*ret
, list
->expr
);
14101 if (!(*ret
)->dw_loc_next
)
14103 add_loc_descr_to_each (list
, (*ret
)->expr
);
14107 expansion_failed (NULL_TREE
, NULL_RTX
,
14108 "Don't know how to merge two non-trivial"
14109 " location lists.\n");
14114 /* LOC is constant expression. Try a luck, look it up in constant
14115 pool and return its loc_descr of its address. */
14117 static dw_loc_descr_ref
14118 cst_pool_loc_descr (tree loc
)
14120 /* Get an RTL for this, if something has been emitted. */
14121 rtx rtl
= lookup_constant_def (loc
);
14123 if (!rtl
|| !MEM_P (rtl
))
14128 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
14130 /* TODO: We might get more coverage if we was actually delaying expansion
14131 of all expressions till end of compilation when constant pools are fully
14133 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
14135 expansion_failed (loc
, NULL_RTX
,
14136 "CST value in contant pool but not marked.");
14139 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
14140 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
14143 /* Return dw_loc_list representing address of addr_expr LOC
14144 by looking for inner INDIRECT_REF expression and turning
14145 it into simple arithmetics. */
14147 static dw_loc_list_ref
14148 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
)
14151 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14152 enum machine_mode mode
;
14153 int unsignedp
, volatilep
= 0;
14154 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14156 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
14157 &bitsize
, &bitpos
, &offset
, &mode
,
14158 &unsignedp
, &volatilep
, false);
14160 if (bitpos
% BITS_PER_UNIT
)
14162 expansion_failed (loc
, NULL_RTX
, "bitfield access");
14165 if (!INDIRECT_REF_P (obj
))
14167 expansion_failed (obj
,
14168 NULL_RTX
, "no indirect ref in inner refrence");
14171 if (!offset
&& !bitpos
)
14172 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1);
14174 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
14175 && (dwarf_version
>= 4 || !dwarf_strict
))
14177 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0);
14182 /* Variable offset. */
14183 list_ret1
= loc_list_from_tree (offset
, 0);
14184 if (list_ret1
== 0)
14186 add_loc_list (&list_ret
, list_ret1
);
14189 add_loc_descr_to_each (list_ret
,
14190 new_loc_descr (DW_OP_plus
, 0, 0));
14192 bytepos
= bitpos
/ BITS_PER_UNIT
;
14194 add_loc_descr_to_each (list_ret
,
14195 new_loc_descr (DW_OP_plus_uconst
,
14197 else if (bytepos
< 0)
14198 loc_list_plus_const (list_ret
, bytepos
);
14199 add_loc_descr_to_each (list_ret
,
14200 new_loc_descr (DW_OP_stack_value
, 0, 0));
14206 /* Generate Dwarf location list representing LOC.
14207 If WANT_ADDRESS is false, expression computing LOC will be computed
14208 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14209 if WANT_ADDRESS is 2, expression computing address useable in location
14210 will be returned (i.e. DW_OP_reg can be used
14211 to refer to register values). */
14213 static dw_loc_list_ref
14214 loc_list_from_tree (tree loc
, int want_address
)
14216 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
14217 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14218 int have_address
= 0;
14219 enum dwarf_location_atom op
;
14221 /* ??? Most of the time we do not take proper care for sign/zero
14222 extending the values properly. Hopefully this won't be a real
14225 switch (TREE_CODE (loc
))
14228 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
14231 case PLACEHOLDER_EXPR
:
14232 /* This case involves extracting fields from an object to determine the
14233 position of other fields. We don't try to encode this here. The
14234 only user of this is Ada, which encodes the needed information using
14235 the names of types. */
14236 expansion_failed (loc
, NULL_RTX
, "PLACEHOLDER_EXPR");
14240 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
14241 /* There are no opcodes for these operations. */
14244 case PREINCREMENT_EXPR
:
14245 case PREDECREMENT_EXPR
:
14246 case POSTINCREMENT_EXPR
:
14247 case POSTDECREMENT_EXPR
:
14248 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
14249 /* There are no opcodes for these operations. */
14253 /* If we already want an address, see if there is INDIRECT_REF inside
14254 e.g. for &this->field. */
14257 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
14258 (loc
, want_address
== 2);
14261 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
14262 && (ret
= cst_pool_loc_descr (loc
)))
14265 /* Otherwise, process the argument and look for the address. */
14266 if (!list_ret
&& !ret
)
14267 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 1);
14271 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
14277 if (DECL_THREAD_LOCAL_P (loc
))
14280 enum dwarf_location_atom tls_op
;
14281 enum dtprel_bool dtprel
= dtprel_false
;
14283 if (targetm
.have_tls
)
14285 /* If this is not defined, we have no way to emit the
14287 if (!targetm
.asm_out
.output_dwarf_dtprel
)
14290 /* The way DW_OP_GNU_push_tls_address is specified, we
14291 can only look up addresses of objects in the current
14292 module. We used DW_OP_addr as first op, but that's
14293 wrong, because DW_OP_addr is relocated by the debug
14294 info consumer, while DW_OP_GNU_push_tls_address
14295 operand shouldn't be. */
14296 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
14298 dtprel
= dtprel_true
;
14299 tls_op
= DW_OP_GNU_push_tls_address
;
14303 if (!targetm
.emutls
.debug_form_tls_address
14304 || !(dwarf_version
>= 3 || !dwarf_strict
))
14306 /* We stuffed the control variable into the DECL_VALUE_EXPR
14307 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
14308 no longer appear in gimple code. We used the control
14309 variable in specific so that we could pick it up here. */
14310 loc
= DECL_VALUE_EXPR (loc
);
14311 tls_op
= DW_OP_form_tls_address
;
14314 rtl
= rtl_for_decl_location (loc
);
14315 if (rtl
== NULL_RTX
)
14320 rtl
= XEXP (rtl
, 0);
14321 if (! CONSTANT_P (rtl
))
14324 ret
= new_addr_loc_descr (rtl
, dtprel
);
14325 ret1
= new_loc_descr (tls_op
, 0, 0);
14326 add_loc_descr (&ret
, ret1
);
14335 if (DECL_HAS_VALUE_EXPR_P (loc
))
14336 return loc_list_from_tree (DECL_VALUE_EXPR (loc
),
14340 case FUNCTION_DECL
:
14343 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
14345 if (loc_list
&& loc_list
->first
)
14347 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
14348 have_address
= want_address
!= 0;
14351 rtl
= rtl_for_decl_location (loc
);
14352 if (rtl
== NULL_RTX
)
14354 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
14357 else if (CONST_INT_P (rtl
))
14359 HOST_WIDE_INT val
= INTVAL (rtl
);
14360 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14361 val
&= GET_MODE_MASK (DECL_MODE (loc
));
14362 ret
= int_loc_descriptor (val
);
14364 else if (GET_CODE (rtl
) == CONST_STRING
)
14366 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
14369 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
14370 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
14373 enum machine_mode mode
, mem_mode
;
14375 /* Certain constructs can only be represented at top-level. */
14376 if (want_address
== 2)
14378 ret
= loc_descriptor (rtl
, VOIDmode
,
14379 VAR_INIT_STATUS_INITIALIZED
);
14384 mode
= GET_MODE (rtl
);
14385 mem_mode
= VOIDmode
;
14389 mode
= get_address_mode (rtl
);
14390 rtl
= XEXP (rtl
, 0);
14393 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
14394 VAR_INIT_STATUS_INITIALIZED
);
14397 expansion_failed (loc
, rtl
,
14398 "failed to produce loc descriptor for rtl");
14405 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
14409 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14413 case COMPOUND_EXPR
:
14414 return loc_list_from_tree (TREE_OPERAND (loc
, 1), want_address
);
14417 case VIEW_CONVERT_EXPR
:
14420 return loc_list_from_tree (TREE_OPERAND (loc
, 0), want_address
);
14422 case COMPONENT_REF
:
14423 case BIT_FIELD_REF
:
14425 case ARRAY_RANGE_REF
:
14426 case REALPART_EXPR
:
14427 case IMAGPART_EXPR
:
14430 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14431 enum machine_mode mode
;
14432 int unsignedp
, volatilep
= 0;
14434 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
14435 &unsignedp
, &volatilep
, false);
14437 gcc_assert (obj
!= loc
);
14439 list_ret
= loc_list_from_tree (obj
,
14441 && !bitpos
&& !offset
? 2 : 1);
14442 /* TODO: We can extract value of the small expression via shifting even
14443 for nonzero bitpos. */
14446 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
14448 expansion_failed (loc
, NULL_RTX
,
14449 "bitfield access");
14453 if (offset
!= NULL_TREE
)
14455 /* Variable offset. */
14456 list_ret1
= loc_list_from_tree (offset
, 0);
14457 if (list_ret1
== 0)
14459 add_loc_list (&list_ret
, list_ret1
);
14462 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
14465 bytepos
= bitpos
/ BITS_PER_UNIT
;
14467 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
14468 else if (bytepos
< 0)
14469 loc_list_plus_const (list_ret
, bytepos
);
14476 if ((want_address
|| !tree_fits_shwi_p (loc
))
14477 && (ret
= cst_pool_loc_descr (loc
)))
14479 else if (want_address
== 2
14480 && tree_fits_shwi_p (loc
)
14481 && (ret
= address_of_int_loc_descriptor
14482 (int_size_in_bytes (TREE_TYPE (loc
)),
14483 tree_to_shwi (loc
))))
14485 else if (tree_fits_shwi_p (loc
))
14486 ret
= int_loc_descriptor (tree_to_shwi (loc
));
14489 expansion_failed (loc
, NULL_RTX
,
14490 "Integer operand is not host integer");
14499 if ((ret
= cst_pool_loc_descr (loc
)))
14502 /* We can construct small constants here using int_loc_descriptor. */
14503 expansion_failed (loc
, NULL_RTX
,
14504 "constructor or constant not in constant pool");
14507 case TRUTH_AND_EXPR
:
14508 case TRUTH_ANDIF_EXPR
:
14513 case TRUTH_XOR_EXPR
:
14518 case TRUTH_OR_EXPR
:
14519 case TRUTH_ORIF_EXPR
:
14524 case FLOOR_DIV_EXPR
:
14525 case CEIL_DIV_EXPR
:
14526 case ROUND_DIV_EXPR
:
14527 case TRUNC_DIV_EXPR
:
14528 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14537 case FLOOR_MOD_EXPR
:
14538 case CEIL_MOD_EXPR
:
14539 case ROUND_MOD_EXPR
:
14540 case TRUNC_MOD_EXPR
:
14541 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14546 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14547 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14548 if (list_ret
== 0 || list_ret1
== 0)
14551 add_loc_list (&list_ret
, list_ret1
);
14554 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14555 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14556 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
14557 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14558 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14570 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
14573 case POINTER_PLUS_EXPR
:
14575 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
14577 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14581 loc_list_plus_const (list_ret
, tree_to_shwi (TREE_OPERAND (loc
, 1)));
14589 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14596 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14603 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14610 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14625 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14626 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14627 if (list_ret
== 0 || list_ret1
== 0)
14630 add_loc_list (&list_ret
, list_ret1
);
14633 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14636 case TRUTH_NOT_EXPR
:
14650 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14654 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14660 const enum tree_code code
=
14661 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
14663 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
14664 build2 (code
, integer_type_node
,
14665 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
14666 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
14669 /* ... fall through ... */
14673 dw_loc_descr_ref lhs
14674 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
14675 dw_loc_list_ref rhs
14676 = loc_list_from_tree (TREE_OPERAND (loc
, 2), 0);
14677 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
14679 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14680 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
14683 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14684 add_loc_descr_to_each (list_ret
, bra_node
);
14686 add_loc_list (&list_ret
, rhs
);
14687 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14688 add_loc_descr_to_each (list_ret
, jump_node
);
14690 add_loc_descr_to_each (list_ret
, lhs
);
14691 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14692 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
14694 /* ??? Need a node to point the skip at. Use a nop. */
14695 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14696 add_loc_descr_to_each (list_ret
, tmp
);
14697 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14698 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14702 case FIX_TRUNC_EXPR
:
14706 /* Leave front-end specific codes as simply unknown. This comes
14707 up, for instance, with the C STMT_EXPR. */
14708 if ((unsigned int) TREE_CODE (loc
)
14709 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
14711 expansion_failed (loc
, NULL_RTX
,
14712 "language specific tree node");
14716 #ifdef ENABLE_CHECKING
14717 /* Otherwise this is a generic code; we should just lists all of
14718 these explicitly. We forgot one. */
14719 gcc_unreachable ();
14721 /* In a release build, we want to degrade gracefully: better to
14722 generate incomplete debugging information than to crash. */
14727 if (!ret
&& !list_ret
)
14730 if (want_address
== 2 && !have_address
14731 && (dwarf_version
>= 4 || !dwarf_strict
))
14733 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
14735 expansion_failed (loc
, NULL_RTX
,
14736 "DWARF address size mismatch");
14740 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14742 add_loc_descr_to_each (list_ret
,
14743 new_loc_descr (DW_OP_stack_value
, 0, 0));
14746 /* Show if we can't fill the request for an address. */
14747 if (want_address
&& !have_address
)
14749 expansion_failed (loc
, NULL_RTX
,
14750 "Want address and only have value");
14754 gcc_assert (!ret
|| !list_ret
);
14756 /* If we've got an address and don't want one, dereference. */
14757 if (!want_address
&& have_address
)
14759 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
14761 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
14763 expansion_failed (loc
, NULL_RTX
,
14764 "DWARF address size mismatch");
14767 else if (size
== DWARF2_ADDR_SIZE
)
14770 op
= DW_OP_deref_size
;
14773 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
14775 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
14778 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
14783 /* Same as above but return only single location expression. */
14784 static dw_loc_descr_ref
14785 loc_descriptor_from_tree (tree loc
, int want_address
)
14787 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
);
14790 if (ret
->dw_loc_next
)
14792 expansion_failed (loc
, NULL_RTX
,
14793 "Location list where only loc descriptor needed");
14799 /* Given a value, round it up to the lowest multiple of `boundary'
14800 which is not less than the value itself. */
14802 static inline HOST_WIDE_INT
14803 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
14805 return (((value
+ boundary
- 1) / boundary
) * boundary
);
14808 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
14809 pointer to the declared type for the relevant field variable, or return
14810 `integer_type_node' if the given node turns out to be an
14811 ERROR_MARK node. */
14814 field_type (const_tree decl
)
14818 if (TREE_CODE (decl
) == ERROR_MARK
)
14819 return integer_type_node
;
14821 type
= DECL_BIT_FIELD_TYPE (decl
);
14822 if (type
== NULL_TREE
)
14823 type
= TREE_TYPE (decl
);
14828 /* Given a pointer to a tree node, return the alignment in bits for
14829 it, or else return BITS_PER_WORD if the node actually turns out to
14830 be an ERROR_MARK node. */
14832 static inline unsigned
14833 simple_type_align_in_bits (const_tree type
)
14835 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
14838 static inline unsigned
14839 simple_decl_align_in_bits (const_tree decl
)
14841 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
14844 /* Return the result of rounding T up to ALIGN. */
14846 static inline offset_int
14847 round_up_to_align (const offset_int
&t
, unsigned int align
)
14849 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
14852 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
14853 lowest addressed byte of the "containing object" for the given FIELD_DECL,
14854 or return 0 if we are unable to determine what that offset is, either
14855 because the argument turns out to be a pointer to an ERROR_MARK node, or
14856 because the offset is actually variable. (We can't handle the latter case
14859 static HOST_WIDE_INT
14860 field_byte_offset (const_tree decl
)
14862 offset_int object_offset_in_bits
;
14863 offset_int object_offset_in_bytes
;
14864 offset_int bitpos_int
;
14866 if (TREE_CODE (decl
) == ERROR_MARK
)
14869 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
14871 /* We cannot yet cope with fields whose positions are variable, so
14872 for now, when we see such things, we simply return 0. Someday, we may
14873 be able to handle such cases, but it will be damn difficult. */
14874 if (TREE_CODE (bit_position (decl
)) != INTEGER_CST
)
14877 bitpos_int
= wi::to_offset (bit_position (decl
));
14879 #ifdef PCC_BITFIELD_TYPE_MATTERS
14880 if (PCC_BITFIELD_TYPE_MATTERS
)
14883 tree field_size_tree
;
14884 offset_int deepest_bitpos
;
14885 offset_int field_size_in_bits
;
14886 unsigned int type_align_in_bits
;
14887 unsigned int decl_align_in_bits
;
14888 offset_int type_size_in_bits
;
14890 type
= field_type (decl
);
14891 type_size_in_bits
= offset_int_type_size_in_bits (type
);
14892 type_align_in_bits
= simple_type_align_in_bits (type
);
14894 field_size_tree
= DECL_SIZE (decl
);
14896 /* The size could be unspecified if there was an error, or for
14897 a flexible array member. */
14898 if (!field_size_tree
)
14899 field_size_tree
= bitsize_zero_node
;
14901 /* If the size of the field is not constant, use the type size. */
14902 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
14903 field_size_in_bits
= wi::to_offset (field_size_tree
);
14905 field_size_in_bits
= type_size_in_bits
;
14907 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
14909 /* The GCC front-end doesn't make any attempt to keep track of the
14910 starting bit offset (relative to the start of the containing
14911 structure type) of the hypothetical "containing object" for a
14912 bit-field. Thus, when computing the byte offset value for the
14913 start of the "containing object" of a bit-field, we must deduce
14914 this information on our own. This can be rather tricky to do in
14915 some cases. For example, handling the following structure type
14916 definition when compiling for an i386/i486 target (which only
14917 aligns long long's to 32-bit boundaries) can be very tricky:
14919 struct S { int field1; long long field2:31; };
14921 Fortunately, there is a simple rule-of-thumb which can be used
14922 in such cases. When compiling for an i386/i486, GCC will
14923 allocate 8 bytes for the structure shown above. It decides to
14924 do this based upon one simple rule for bit-field allocation.
14925 GCC allocates each "containing object" for each bit-field at
14926 the first (i.e. lowest addressed) legitimate alignment boundary
14927 (based upon the required minimum alignment for the declared
14928 type of the field) which it can possibly use, subject to the
14929 condition that there is still enough available space remaining
14930 in the containing object (when allocated at the selected point)
14931 to fully accommodate all of the bits of the bit-field itself.
14933 This simple rule makes it obvious why GCC allocates 8 bytes for
14934 each object of the structure type shown above. When looking
14935 for a place to allocate the "containing object" for `field2',
14936 the compiler simply tries to allocate a 64-bit "containing
14937 object" at each successive 32-bit boundary (starting at zero)
14938 until it finds a place to allocate that 64- bit field such that
14939 at least 31 contiguous (and previously unallocated) bits remain
14940 within that selected 64 bit field. (As it turns out, for the
14941 example above, the compiler finds it is OK to allocate the
14942 "containing object" 64-bit field at bit-offset zero within the
14945 Here we attempt to work backwards from the limited set of facts
14946 we're given, and we try to deduce from those facts, where GCC
14947 must have believed that the containing object started (within
14948 the structure type). The value we deduce is then used (by the
14949 callers of this routine) to generate DW_AT_location and
14950 DW_AT_bit_offset attributes for fields (both bit-fields and, in
14951 the case of DW_AT_location, regular fields as well). */
14953 /* Figure out the bit-distance from the start of the structure to
14954 the "deepest" bit of the bit-field. */
14955 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
14957 /* This is the tricky part. Use some fancy footwork to deduce
14958 where the lowest addressed bit of the containing object must
14960 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14962 /* Round up to type_align by default. This works best for
14964 object_offset_in_bits
14965 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
14967 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
14969 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14971 /* Round up to decl_align instead. */
14972 object_offset_in_bits
14973 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
14977 #endif /* PCC_BITFIELD_TYPE_MATTERS */
14978 object_offset_in_bits
= bitpos_int
;
14980 object_offset_in_bytes
14981 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
14982 return object_offset_in_bytes
.to_shwi ();
14985 /* The following routines define various Dwarf attributes and any data
14986 associated with them. */
14988 /* Add a location description attribute value to a DIE.
14990 This emits location attributes suitable for whole variables and
14991 whole parameters. Note that the location attributes for struct fields are
14992 generated by the routine `data_member_location_attribute' below. */
14995 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
14996 dw_loc_list_ref descr
)
15000 if (single_element_loc_list_p (descr
))
15001 add_AT_loc (die
, attr_kind
, descr
->expr
);
15003 add_AT_loc_list (die
, attr_kind
, descr
);
15006 /* Add DW_AT_accessibility attribute to DIE if needed. */
15009 add_accessibility_attribute (dw_die_ref die
, tree decl
)
15011 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
15012 children, otherwise the default is DW_ACCESS_public. In DWARF2
15013 the default has always been DW_ACCESS_public. */
15014 if (TREE_PROTECTED (decl
))
15015 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
15016 else if (TREE_PRIVATE (decl
))
15018 if (dwarf_version
== 2
15019 || die
->die_parent
== NULL
15020 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
15021 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
15023 else if (dwarf_version
> 2
15025 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
15026 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
15029 /* Attach the specialized form of location attribute used for data members of
15030 struct and union types. In the special case of a FIELD_DECL node which
15031 represents a bit-field, the "offset" part of this special location
15032 descriptor must indicate the distance in bytes from the lowest-addressed
15033 byte of the containing struct or union type to the lowest-addressed byte of
15034 the "containing object" for the bit-field. (See the `field_byte_offset'
15037 For any given bit-field, the "containing object" is a hypothetical object
15038 (of some integral or enum type) within which the given bit-field lives. The
15039 type of this hypothetical "containing object" is always the same as the
15040 declared type of the individual bit-field itself (for GCC anyway... the
15041 DWARF spec doesn't actually mandate this). Note that it is the size (in
15042 bytes) of the hypothetical "containing object" which will be given in the
15043 DW_AT_byte_size attribute for this bit-field. (See the
15044 `byte_size_attribute' function below.) It is also used when calculating the
15045 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15046 function below.) */
15049 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
15051 HOST_WIDE_INT offset
;
15052 dw_loc_descr_ref loc_descr
= 0;
15054 if (TREE_CODE (decl
) == TREE_BINFO
)
15056 /* We're working on the TAG_inheritance for a base class. */
15057 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
15059 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15060 aren't at a fixed offset from all (sub)objects of the same
15061 type. We need to extract the appropriate offset from our
15062 vtable. The following dwarf expression means
15064 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15066 This is specific to the V3 ABI, of course. */
15068 dw_loc_descr_ref tmp
;
15070 /* Make a copy of the object address. */
15071 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
15072 add_loc_descr (&loc_descr
, tmp
);
15074 /* Extract the vtable address. */
15075 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
15076 add_loc_descr (&loc_descr
, tmp
);
15078 /* Calculate the address of the offset. */
15079 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
15080 gcc_assert (offset
< 0);
15082 tmp
= int_loc_descriptor (-offset
);
15083 add_loc_descr (&loc_descr
, tmp
);
15084 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
15085 add_loc_descr (&loc_descr
, tmp
);
15087 /* Extract the offset. */
15088 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
15089 add_loc_descr (&loc_descr
, tmp
);
15091 /* Add it to the object address. */
15092 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
15093 add_loc_descr (&loc_descr
, tmp
);
15096 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
15099 offset
= field_byte_offset (decl
);
15103 if (dwarf_version
> 2)
15105 /* Don't need to output a location expression, just the constant. */
15107 add_AT_int (die
, DW_AT_data_member_location
, offset
);
15109 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
15114 enum dwarf_location_atom op
;
15116 /* The DWARF2 standard says that we should assume that the structure
15117 address is already on the stack, so we can specify a structure
15118 field address by using DW_OP_plus_uconst. */
15119 op
= DW_OP_plus_uconst
;
15120 loc_descr
= new_loc_descr (op
, offset
, 0);
15124 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
15127 /* Writes integer values to dw_vec_const array. */
15130 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
15134 *dest
++ = val
& 0xff;
15140 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15142 static HOST_WIDE_INT
15143 extract_int (const unsigned char *src
, unsigned int size
)
15145 HOST_WIDE_INT val
= 0;
15151 val
|= *--src
& 0xff;
15157 /* Writes wide_int values to dw_vec_const array. */
15160 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
15164 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
15166 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
15170 /* We'd have to extend this code to support odd sizes. */
15171 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
15173 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
15175 if (WORDS_BIG_ENDIAN
)
15176 for (i
= n
- 1; i
>= 0; i
--)
15178 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
15179 dest
+= sizeof (HOST_WIDE_INT
);
15182 for (i
= 0; i
< n
; i
++)
15184 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
15185 dest
+= sizeof (HOST_WIDE_INT
);
15189 /* Writes floating point values to dw_vec_const array. */
15192 insert_float (const_rtx rtl
, unsigned char *array
)
15194 REAL_VALUE_TYPE rv
;
15198 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
15199 real_to_target (val
, &rv
, GET_MODE (rtl
));
15201 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15202 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
15204 insert_int (val
[i
], 4, array
);
15209 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15210 does not have a "location" either in memory or in a register. These
15211 things can arise in GNU C when a constant is passed as an actual parameter
15212 to an inlined function. They can also arise in C++ where declared
15213 constants do not necessarily get memory "homes". */
15216 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
15218 switch (GET_CODE (rtl
))
15222 HOST_WIDE_INT val
= INTVAL (rtl
);
15225 add_AT_int (die
, DW_AT_const_value
, val
);
15227 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
15231 case CONST_WIDE_INT
:
15232 add_AT_wide (die
, DW_AT_const_value
,
15233 std::make_pair (rtl
, GET_MODE (rtl
)));
15237 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15238 floating-point constant. A CONST_DOUBLE is used whenever the
15239 constant requires more than one word in order to be adequately
15242 enum machine_mode mode
= GET_MODE (rtl
);
15244 if (TARGET_SUPPORTS_WIDE_INT
== 0 && !SCALAR_FLOAT_MODE_P (mode
))
15245 add_AT_double (die
, DW_AT_const_value
,
15246 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
15249 unsigned int length
= GET_MODE_SIZE (mode
);
15250 unsigned char *array
= (unsigned char *) ggc_alloc_atomic (length
);
15252 insert_float (rtl
, array
);
15253 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
15260 enum machine_mode mode
= GET_MODE (rtl
);
15261 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
15262 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
15263 unsigned char *array
= (unsigned char *) ggc_alloc_atomic
15264 (length
* elt_size
);
15267 enum machine_mode imode
= GET_MODE_INNER (mode
);
15269 switch (GET_MODE_CLASS (mode
))
15271 case MODE_VECTOR_INT
:
15272 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15274 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15275 insert_wide_int (std::make_pair (elt
, imode
), p
, elt_size
);
15279 case MODE_VECTOR_FLOAT
:
15280 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15282 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15283 insert_float (elt
, p
);
15288 gcc_unreachable ();
15291 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
15296 if (dwarf_version
>= 4 || !dwarf_strict
)
15298 dw_loc_descr_ref loc_result
;
15299 resolve_one_addr (&rtl
, NULL
);
15301 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15302 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
15303 add_AT_loc (die
, DW_AT_location
, loc_result
);
15304 vec_safe_push (used_rtx_array
, rtl
);
15310 if (CONSTANT_P (XEXP (rtl
, 0)))
15311 return add_const_value_attribute (die
, XEXP (rtl
, 0));
15314 if (!const_ok_for_output (rtl
))
15317 if (dwarf_version
>= 4 || !dwarf_strict
)
15322 /* In cases where an inlined instance of an inline function is passed
15323 the address of an `auto' variable (which is local to the caller) we
15324 can get a situation where the DECL_RTL of the artificial local
15325 variable (for the inlining) which acts as a stand-in for the
15326 corresponding formal parameter (of the inline function) will look
15327 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15328 exactly a compile-time constant expression, but it isn't the address
15329 of the (artificial) local variable either. Rather, it represents the
15330 *value* which the artificial local variable always has during its
15331 lifetime. We currently have no way to represent such quasi-constant
15332 values in Dwarf, so for now we just punt and generate nothing. */
15340 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
15341 && MEM_READONLY_P (rtl
)
15342 && GET_MODE (rtl
) == BLKmode
)
15344 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
15350 /* No other kinds of rtx should be possible here. */
15351 gcc_unreachable ();
15356 /* Determine whether the evaluation of EXPR references any variables
15357 or functions which aren't otherwise used (and therefore may not be
15360 reference_to_unused (tree
* tp
, int * walk_subtrees
,
15361 void * data ATTRIBUTE_UNUSED
)
15363 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
15364 *walk_subtrees
= 0;
15366 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
15367 && ! TREE_ASM_WRITTEN (*tp
))
15369 /* ??? The C++ FE emits debug information for using decls, so
15370 putting gcc_unreachable here falls over. See PR31899. For now
15371 be conservative. */
15372 else if (!cgraph_global_info_ready
15373 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
15375 else if (TREE_CODE (*tp
) == VAR_DECL
)
15377 varpool_node
*node
= varpool_get_node (*tp
);
15378 if (!node
|| !node
->definition
)
15381 else if (TREE_CODE (*tp
) == FUNCTION_DECL
15382 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
15384 /* The call graph machinery must have finished analyzing,
15385 optimizing and gimplifying the CU by now.
15386 So if *TP has no call graph node associated
15387 to it, it means *TP will not be emitted. */
15388 if (!cgraph_get_node (*tp
))
15391 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
15397 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15398 for use in a later add_const_value_attribute call. */
15401 rtl_for_decl_init (tree init
, tree type
)
15403 rtx rtl
= NULL_RTX
;
15407 /* If a variable is initialized with a string constant without embedded
15408 zeros, build CONST_STRING. */
15409 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
15411 tree enttype
= TREE_TYPE (type
);
15412 tree domain
= TYPE_DOMAIN (type
);
15413 enum machine_mode mode
= TYPE_MODE (enttype
);
15415 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
15417 && integer_zerop (TYPE_MIN_VALUE (domain
))
15418 && compare_tree_int (TYPE_MAX_VALUE (domain
),
15419 TREE_STRING_LENGTH (init
) - 1) == 0
15420 && ((size_t) TREE_STRING_LENGTH (init
)
15421 == strlen (TREE_STRING_POINTER (init
)) + 1))
15423 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
15424 ggc_strdup (TREE_STRING_POINTER (init
)));
15425 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
15426 MEM_READONLY_P (rtl
) = 1;
15429 /* Other aggregates, and complex values, could be represented using
15431 else if (AGGREGATE_TYPE_P (type
)
15432 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
15433 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
15434 || TREE_CODE (type
) == COMPLEX_TYPE
)
15436 /* Vectors only work if their mode is supported by the target.
15437 FIXME: generic vectors ought to work too. */
15438 else if (TREE_CODE (type
) == VECTOR_TYPE
15439 && !VECTOR_MODE_P (TYPE_MODE (type
)))
15441 /* If the initializer is something that we know will expand into an
15442 immediate RTL constant, expand it now. We must be careful not to
15443 reference variables which won't be output. */
15444 else if (initializer_constant_valid_p (init
, type
)
15445 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
15447 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15449 if (TREE_CODE (type
) == VECTOR_TYPE
)
15450 switch (TREE_CODE (init
))
15455 if (TREE_CONSTANT (init
))
15457 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
15458 bool constant_p
= true;
15460 unsigned HOST_WIDE_INT ix
;
15462 /* Even when ctor is constant, it might contain non-*_CST
15463 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15464 belong into VECTOR_CST nodes. */
15465 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
15466 if (!CONSTANT_CLASS_P (value
))
15468 constant_p
= false;
15474 init
= build_vector_from_ctor (type
, elts
);
15484 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
15486 /* If expand_expr returns a MEM, it wasn't immediate. */
15487 gcc_assert (!rtl
|| !MEM_P (rtl
));
15493 /* Generate RTL for the variable DECL to represent its location. */
15496 rtl_for_decl_location (tree decl
)
15500 /* Here we have to decide where we are going to say the parameter "lives"
15501 (as far as the debugger is concerned). We only have a couple of
15502 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15504 DECL_RTL normally indicates where the parameter lives during most of the
15505 activation of the function. If optimization is enabled however, this
15506 could be either NULL or else a pseudo-reg. Both of those cases indicate
15507 that the parameter doesn't really live anywhere (as far as the code
15508 generation parts of GCC are concerned) during most of the function's
15509 activation. That will happen (for example) if the parameter is never
15510 referenced within the function.
15512 We could just generate a location descriptor here for all non-NULL
15513 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15514 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15515 where DECL_RTL is NULL or is a pseudo-reg.
15517 Note however that we can only get away with using DECL_INCOMING_RTL as
15518 a backup substitute for DECL_RTL in certain limited cases. In cases
15519 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15520 we can be sure that the parameter was passed using the same type as it is
15521 declared to have within the function, and that its DECL_INCOMING_RTL
15522 points us to a place where a value of that type is passed.
15524 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15525 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15526 because in these cases DECL_INCOMING_RTL points us to a value of some
15527 type which is *different* from the type of the parameter itself. Thus,
15528 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15529 such cases, the debugger would end up (for example) trying to fetch a
15530 `float' from a place which actually contains the first part of a
15531 `double'. That would lead to really incorrect and confusing
15532 output at debug-time.
15534 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15535 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15536 are a couple of exceptions however. On little-endian machines we can
15537 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15538 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15539 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15540 when (on a little-endian machine) a non-prototyped function has a
15541 parameter declared to be of type `short' or `char'. In such cases,
15542 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15543 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15544 passed `int' value. If the debugger then uses that address to fetch
15545 a `short' or a `char' (on a little-endian machine) the result will be
15546 the correct data, so we allow for such exceptional cases below.
15548 Note that our goal here is to describe the place where the given formal
15549 parameter lives during most of the function's activation (i.e. between the
15550 end of the prologue and the start of the epilogue). We'll do that as best
15551 as we can. Note however that if the given formal parameter is modified
15552 sometime during the execution of the function, then a stack backtrace (at
15553 debug-time) will show the function as having been called with the *new*
15554 value rather than the value which was originally passed in. This happens
15555 rarely enough that it is not a major problem, but it *is* a problem, and
15556 I'd like to fix it.
15558 A future version of dwarf2out.c may generate two additional attributes for
15559 any given DW_TAG_formal_parameter DIE which will describe the "passed
15560 type" and the "passed location" for the given formal parameter in addition
15561 to the attributes we now generate to indicate the "declared type" and the
15562 "active location" for each parameter. This additional set of attributes
15563 could be used by debuggers for stack backtraces. Separately, note that
15564 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15565 This happens (for example) for inlined-instances of inline function formal
15566 parameters which are never referenced. This really shouldn't be
15567 happening. All PARM_DECL nodes should get valid non-NULL
15568 DECL_INCOMING_RTL values. FIXME. */
15570 /* Use DECL_RTL as the "location" unless we find something better. */
15571 rtl
= DECL_RTL_IF_SET (decl
);
15573 /* When generating abstract instances, ignore everything except
15574 constants, symbols living in memory, and symbols living in
15575 fixed registers. */
15576 if (! reload_completed
)
15579 && (CONSTANT_P (rtl
)
15581 && CONSTANT_P (XEXP (rtl
, 0)))
15583 && TREE_CODE (decl
) == VAR_DECL
15584 && TREE_STATIC (decl
))))
15586 rtl
= targetm
.delegitimize_address (rtl
);
15591 else if (TREE_CODE (decl
) == PARM_DECL
)
15593 if (rtl
== NULL_RTX
15594 || is_pseudo_reg (rtl
)
15596 && is_pseudo_reg (XEXP (rtl
, 0))
15597 && DECL_INCOMING_RTL (decl
)
15598 && MEM_P (DECL_INCOMING_RTL (decl
))
15599 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
15601 tree declared_type
= TREE_TYPE (decl
);
15602 tree passed_type
= DECL_ARG_TYPE (decl
);
15603 enum machine_mode dmode
= TYPE_MODE (declared_type
);
15604 enum machine_mode pmode
= TYPE_MODE (passed_type
);
15606 /* This decl represents a formal parameter which was optimized out.
15607 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15608 all cases where (rtl == NULL_RTX) just below. */
15609 if (dmode
== pmode
)
15610 rtl
= DECL_INCOMING_RTL (decl
);
15611 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
15612 && SCALAR_INT_MODE_P (dmode
)
15613 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
15614 && DECL_INCOMING_RTL (decl
))
15616 rtx inc
= DECL_INCOMING_RTL (decl
);
15619 else if (MEM_P (inc
))
15621 if (BYTES_BIG_ENDIAN
)
15622 rtl
= adjust_address_nv (inc
, dmode
,
15623 GET_MODE_SIZE (pmode
)
15624 - GET_MODE_SIZE (dmode
));
15631 /* If the parm was passed in registers, but lives on the stack, then
15632 make a big endian correction if the mode of the type of the
15633 parameter is not the same as the mode of the rtl. */
15634 /* ??? This is the same series of checks that are made in dbxout.c before
15635 we reach the big endian correction code there. It isn't clear if all
15636 of these checks are necessary here, but keeping them all is the safe
15638 else if (MEM_P (rtl
)
15639 && XEXP (rtl
, 0) != const0_rtx
15640 && ! CONSTANT_P (XEXP (rtl
, 0))
15641 /* Not passed in memory. */
15642 && !MEM_P (DECL_INCOMING_RTL (decl
))
15643 /* Not passed by invisible reference. */
15644 && (!REG_P (XEXP (rtl
, 0))
15645 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
15646 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
15647 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
15648 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
15651 /* Big endian correction check. */
15652 && BYTES_BIG_ENDIAN
15653 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
15654 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
15657 enum machine_mode addr_mode
= get_address_mode (rtl
);
15658 int offset
= (UNITS_PER_WORD
15659 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
15661 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15662 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
15665 else if (TREE_CODE (decl
) == VAR_DECL
15668 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
15669 && BYTES_BIG_ENDIAN
)
15671 enum machine_mode addr_mode
= get_address_mode (rtl
);
15672 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
15673 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
15675 /* If a variable is declared "register" yet is smaller than
15676 a register, then if we store the variable to memory, it
15677 looks like we're storing a register-sized value, when in
15678 fact we are not. We need to adjust the offset of the
15679 storage location to reflect the actual value's bytes,
15680 else gdb will not be able to display it. */
15682 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15683 plus_constant (addr_mode
, XEXP (rtl
, 0),
15687 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15688 and will have been substituted directly into all expressions that use it.
15689 C does not have such a concept, but C++ and other languages do. */
15690 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
15691 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
15694 rtl
= targetm
.delegitimize_address (rtl
);
15696 /* If we don't look past the constant pool, we risk emitting a
15697 reference to a constant pool entry that isn't referenced from
15698 code, and thus is not emitted. */
15700 rtl
= avoid_constant_pool_reference (rtl
);
15702 /* Try harder to get a rtl. If this symbol ends up not being emitted
15703 in the current CU, resolve_addr will remove the expression referencing
15705 if (rtl
== NULL_RTX
15706 && TREE_CODE (decl
) == VAR_DECL
15707 && !DECL_EXTERNAL (decl
)
15708 && TREE_STATIC (decl
)
15709 && DECL_NAME (decl
)
15710 && !DECL_HARD_REGISTER (decl
)
15711 && DECL_MODE (decl
) != VOIDmode
)
15713 rtl
= make_decl_rtl_for_debug (decl
);
15715 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
15716 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
15723 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15724 returned. If so, the decl for the COMMON block is returned, and the
15725 value is the offset into the common block for the symbol. */
15728 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
15730 tree val_expr
, cvar
;
15731 enum machine_mode mode
;
15732 HOST_WIDE_INT bitsize
, bitpos
;
15734 int unsignedp
, volatilep
= 0;
15736 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15737 it does not have a value (the offset into the common area), or if it
15738 is thread local (as opposed to global) then it isn't common, and shouldn't
15739 be handled as such. */
15740 if (TREE_CODE (decl
) != VAR_DECL
15741 || !TREE_STATIC (decl
)
15742 || !DECL_HAS_VALUE_EXPR_P (decl
)
15746 val_expr
= DECL_VALUE_EXPR (decl
);
15747 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
15750 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
,
15751 &mode
, &unsignedp
, &volatilep
, true);
15753 if (cvar
== NULL_TREE
15754 || TREE_CODE (cvar
) != VAR_DECL
15755 || DECL_ARTIFICIAL (cvar
)
15756 || !TREE_PUBLIC (cvar
))
15760 if (offset
!= NULL
)
15762 if (!tree_fits_shwi_p (offset
))
15764 *value
= tree_to_shwi (offset
);
15767 *value
+= bitpos
/ BITS_PER_UNIT
;
15772 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
15773 data attribute for a variable or a parameter. We generate the
15774 DW_AT_const_value attribute only in those cases where the given variable
15775 or parameter does not have a true "location" either in memory or in a
15776 register. This can happen (for example) when a constant is passed as an
15777 actual argument in a call to an inline function. (It's possible that
15778 these things can crop up in other ways also.) Note that one type of
15779 constant value which can be passed into an inlined function is a constant
15780 pointer. This can happen for example if an actual argument in an inlined
15781 function call evaluates to a compile-time constant address.
15783 CACHE_P is true if it is worth caching the location list for DECL,
15784 so that future calls can reuse it rather than regenerate it from scratch.
15785 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
15786 since we will need to refer to them each time the function is inlined. */
15789 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
,
15790 enum dwarf_attribute attr
)
15793 dw_loc_list_ref list
;
15794 var_loc_list
*loc_list
;
15795 cached_dw_loc_list
*cache
;
15798 if (TREE_CODE (decl
) == ERROR_MARK
)
15801 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
15802 || TREE_CODE (decl
) == RESULT_DECL
);
15804 /* Try to get some constant RTL for this decl, and use that as the value of
15807 rtl
= rtl_for_decl_location (decl
);
15808 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15809 && add_const_value_attribute (die
, rtl
))
15812 /* See if we have single element location list that is equivalent to
15813 a constant value. That way we are better to use add_const_value_attribute
15814 rather than expanding constant value equivalent. */
15815 loc_list
= lookup_decl_loc (decl
);
15818 && loc_list
->first
->next
== NULL
15819 && NOTE_P (loc_list
->first
->loc
)
15820 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
15821 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
15823 struct var_loc_node
*node
;
15825 node
= loc_list
->first
;
15826 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
15827 if (GET_CODE (rtl
) == EXPR_LIST
)
15828 rtl
= XEXP (rtl
, 0);
15829 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15830 && add_const_value_attribute (die
, rtl
))
15833 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
15834 list several times. See if we've already cached the contents. */
15836 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
15840 cache
= (cached_dw_loc_list
*)
15841 htab_find_with_hash (cached_dw_loc_list_table
, decl
, DECL_UID (decl
));
15843 list
= cache
->loc_list
;
15847 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2);
15848 /* It is usually worth caching this result if the decl is from
15849 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
15850 if (cache_p
&& list
&& list
->dw_loc_next
)
15852 slot
= htab_find_slot_with_hash (cached_dw_loc_list_table
, decl
,
15853 DECL_UID (decl
), INSERT
);
15854 cache
= ggc_alloc_cleared_cached_dw_loc_list ();
15855 cache
->decl_id
= DECL_UID (decl
);
15856 cache
->loc_list
= list
;
15862 add_AT_location_description (die
, attr
, list
);
15865 /* None of that worked, so it must not really have a location;
15866 try adding a constant value attribute from the DECL_INITIAL. */
15867 return tree_add_const_value_attribute_for_decl (die
, decl
);
15870 /* Add VARIABLE and DIE into deferred locations list. */
15873 defer_location (tree variable
, dw_die_ref die
)
15875 deferred_locations entry
;
15876 entry
.variable
= variable
;
15878 vec_safe_push (deferred_locations_list
, entry
);
15881 /* Helper function for tree_add_const_value_attribute. Natively encode
15882 initializer INIT into an array. Return true if successful. */
15885 native_encode_initializer (tree init
, unsigned char *array
, int size
)
15889 if (init
== NULL_TREE
)
15893 switch (TREE_CODE (init
))
15896 type
= TREE_TYPE (init
);
15897 if (TREE_CODE (type
) == ARRAY_TYPE
)
15899 tree enttype
= TREE_TYPE (type
);
15900 enum machine_mode mode
= TYPE_MODE (enttype
);
15902 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
15904 if (int_size_in_bytes (type
) != size
)
15906 if (size
> TREE_STRING_LENGTH (init
))
15908 memcpy (array
, TREE_STRING_POINTER (init
),
15909 TREE_STRING_LENGTH (init
));
15910 memset (array
+ TREE_STRING_LENGTH (init
),
15911 '\0', size
- TREE_STRING_LENGTH (init
));
15914 memcpy (array
, TREE_STRING_POINTER (init
), size
);
15919 type
= TREE_TYPE (init
);
15920 if (int_size_in_bytes (type
) != size
)
15922 if (TREE_CODE (type
) == ARRAY_TYPE
)
15924 HOST_WIDE_INT min_index
;
15925 unsigned HOST_WIDE_INT cnt
;
15926 int curpos
= 0, fieldsize
;
15927 constructor_elt
*ce
;
15929 if (TYPE_DOMAIN (type
) == NULL_TREE
15930 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
15933 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
15934 if (fieldsize
<= 0)
15937 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
15938 memset (array
, '\0', size
);
15939 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15941 tree val
= ce
->value
;
15942 tree index
= ce
->index
;
15944 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15945 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
15948 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
15953 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
15956 curpos
= pos
+ fieldsize
;
15957 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15959 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
15960 - tree_to_shwi (TREE_OPERAND (index
, 0));
15961 while (count
-- > 0)
15964 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
15965 curpos
+= fieldsize
;
15968 gcc_assert (curpos
<= size
);
15972 else if (TREE_CODE (type
) == RECORD_TYPE
15973 || TREE_CODE (type
) == UNION_TYPE
)
15975 tree field
= NULL_TREE
;
15976 unsigned HOST_WIDE_INT cnt
;
15977 constructor_elt
*ce
;
15979 if (int_size_in_bytes (type
) != size
)
15982 if (TREE_CODE (type
) == RECORD_TYPE
)
15983 field
= TYPE_FIELDS (type
);
15985 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15987 tree val
= ce
->value
;
15988 int pos
, fieldsize
;
15990 if (ce
->index
!= 0)
15996 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
15999 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
16000 && TYPE_DOMAIN (TREE_TYPE (field
))
16001 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
16003 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
16004 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
16006 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
16007 pos
= int_byte_position (field
);
16008 gcc_assert (pos
+ fieldsize
<= size
);
16010 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
16016 case VIEW_CONVERT_EXPR
:
16017 case NON_LVALUE_EXPR
:
16018 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
16020 return native_encode_expr (init
, array
, size
) == size
;
16024 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16025 attribute is the const value T. */
16028 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
16031 tree type
= TREE_TYPE (t
);
16034 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
16038 gcc_assert (!DECL_P (init
));
16040 rtl
= rtl_for_decl_init (init
, type
);
16042 return add_const_value_attribute (die
, rtl
);
16043 /* If the host and target are sane, try harder. */
16044 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
16045 && initializer_constant_valid_p (init
, type
))
16047 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
16048 if (size
> 0 && (int) size
== size
)
16050 unsigned char *array
= (unsigned char *)
16051 ggc_internal_cleared_alloc (size
);
16053 if (native_encode_initializer (init
, array
, size
))
16055 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
16064 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16065 attribute is the const value of T, where T is an integral constant
16066 variable with static storage duration
16067 (so it can't be a PARM_DECL or a RESULT_DECL). */
16070 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
16074 || (TREE_CODE (decl
) != VAR_DECL
16075 && TREE_CODE (decl
) != CONST_DECL
)
16076 || (TREE_CODE (decl
) == VAR_DECL
16077 && !TREE_STATIC (decl
)))
16080 if (TREE_READONLY (decl
)
16081 && ! TREE_THIS_VOLATILE (decl
)
16082 && DECL_INITIAL (decl
))
16087 /* Don't add DW_AT_const_value if abstract origin already has one. */
16088 if (get_AT (var_die
, DW_AT_const_value
))
16091 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
16094 /* Convert the CFI instructions for the current function into a
16095 location list. This is used for DW_AT_frame_base when we targeting
16096 a dwarf2 consumer that does not support the dwarf3
16097 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16100 static dw_loc_list_ref
16101 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
16105 dw_loc_list_ref list
, *list_tail
;
16107 dw_cfa_location last_cfa
, next_cfa
;
16108 const char *start_label
, *last_label
, *section
;
16109 dw_cfa_location remember
;
16112 gcc_assert (fde
!= NULL
);
16114 section
= secname_for_decl (current_function_decl
);
16118 memset (&next_cfa
, 0, sizeof (next_cfa
));
16119 next_cfa
.reg
= INVALID_REGNUM
;
16120 remember
= next_cfa
;
16122 start_label
= fde
->dw_fde_begin
;
16124 /* ??? Bald assumption that the CIE opcode list does not contain
16125 advance opcodes. */
16126 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
16127 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16129 last_cfa
= next_cfa
;
16130 last_label
= start_label
;
16132 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
16134 /* If the first partition contained no CFI adjustments, the
16135 CIE opcodes apply to the whole first partition. */
16136 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16137 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
16138 list_tail
=&(*list_tail
)->dw_loc_next
;
16139 start_label
= last_label
= fde
->dw_fde_second_begin
;
16142 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
16144 switch (cfi
->dw_cfi_opc
)
16146 case DW_CFA_set_loc
:
16147 case DW_CFA_advance_loc1
:
16148 case DW_CFA_advance_loc2
:
16149 case DW_CFA_advance_loc4
:
16150 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16152 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16153 start_label
, last_label
, section
);
16155 list_tail
= &(*list_tail
)->dw_loc_next
;
16156 last_cfa
= next_cfa
;
16157 start_label
= last_label
;
16159 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
16162 case DW_CFA_advance_loc
:
16163 /* The encoding is complex enough that we should never emit this. */
16164 gcc_unreachable ();
16167 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16170 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
16172 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16174 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16175 start_label
, last_label
, section
);
16177 list_tail
= &(*list_tail
)->dw_loc_next
;
16178 last_cfa
= next_cfa
;
16179 start_label
= last_label
;
16181 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16182 start_label
, fde
->dw_fde_end
, section
);
16183 list_tail
= &(*list_tail
)->dw_loc_next
;
16184 start_label
= last_label
= fde
->dw_fde_second_begin
;
16188 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16190 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16191 start_label
, last_label
, section
);
16192 list_tail
= &(*list_tail
)->dw_loc_next
;
16193 start_label
= last_label
;
16196 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
16198 fde
->dw_fde_second_begin
16199 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
16202 if (list
&& list
->dw_loc_next
)
16208 /* Compute a displacement from the "steady-state frame pointer" to the
16209 frame base (often the same as the CFA), and store it in
16210 frame_pointer_fb_offset. OFFSET is added to the displacement
16211 before the latter is negated. */
16214 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
16218 #ifdef FRAME_POINTER_CFA_OFFSET
16219 reg
= frame_pointer_rtx
;
16220 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
16222 reg
= arg_pointer_rtx
;
16223 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
16226 elim
= (ira_use_lra_p
16227 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
16228 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
16229 if (GET_CODE (elim
) == PLUS
)
16231 offset
+= INTVAL (XEXP (elim
, 1));
16232 elim
= XEXP (elim
, 0);
16235 frame_pointer_fb_offset
= -offset
;
16237 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
16238 in which to eliminate. This is because it's stack pointer isn't
16239 directly accessible as a register within the ISA. To work around
16240 this, assume that while we cannot provide a proper value for
16241 frame_pointer_fb_offset, we won't need one either. */
16242 frame_pointer_fb_offset_valid
16243 = ((SUPPORTS_STACK_ALIGNMENT
16244 && (elim
== hard_frame_pointer_rtx
16245 || elim
== stack_pointer_rtx
))
16246 || elim
== (frame_pointer_needed
16247 ? hard_frame_pointer_rtx
16248 : stack_pointer_rtx
));
16251 /* Generate a DW_AT_name attribute given some string value to be included as
16252 the value of the attribute. */
16255 add_name_attribute (dw_die_ref die
, const char *name_string
)
16257 if (name_string
!= NULL
&& *name_string
!= 0)
16259 if (demangle_name_func
)
16260 name_string
= (*demangle_name_func
) (name_string
);
16262 add_AT_string (die
, DW_AT_name
, name_string
);
16266 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
16267 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
16268 of TYPE accordingly.
16270 ??? This is a temporary measure until after we're able to generate
16271 regular DWARF for the complex Ada type system. */
16274 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
16275 dw_die_ref context_die
)
16278 dw_die_ref dtype_die
;
16280 if (!lang_hooks
.types
.descriptive_type
)
16283 dtype
= lang_hooks
.types
.descriptive_type (type
);
16287 dtype_die
= lookup_type_die (dtype
);
16290 gen_type_die (dtype
, context_die
);
16291 dtype_die
= lookup_type_die (dtype
);
16292 gcc_assert (dtype_die
);
16295 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
16298 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
16300 static const char *
16301 comp_dir_string (void)
16305 static const char *cached_wd
= NULL
;
16307 if (cached_wd
!= NULL
)
16310 wd
= get_src_pwd ();
16314 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
16318 wdlen
= strlen (wd
);
16319 wd1
= (char *) ggc_alloc_atomic (wdlen
+ 2);
16321 wd1
[wdlen
] = DIR_SEPARATOR
;
16322 wd1
[wdlen
+ 1] = 0;
16326 cached_wd
= remap_debug_filename (wd
);
16330 /* Generate a DW_AT_comp_dir attribute for DIE. */
16333 add_comp_dir_attribute (dw_die_ref die
)
16335 const char * wd
= comp_dir_string ();
16337 add_AT_string (die
, DW_AT_comp_dir
, wd
);
16340 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16344 lower_bound_default (void)
16346 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
16351 case DW_LANG_C_plus_plus
:
16353 case DW_LANG_ObjC_plus_plus
:
16356 case DW_LANG_Fortran77
:
16357 case DW_LANG_Fortran90
:
16358 case DW_LANG_Fortran95
:
16362 case DW_LANG_Python
:
16363 return dwarf_version
>= 4 ? 0 : -1;
16364 case DW_LANG_Ada95
:
16365 case DW_LANG_Ada83
:
16366 case DW_LANG_Cobol74
:
16367 case DW_LANG_Cobol85
:
16368 case DW_LANG_Pascal83
:
16369 case DW_LANG_Modula2
:
16371 return dwarf_version
>= 4 ? 1 : -1;
16377 /* Given a tree node describing an array bound (either lower or upper) output
16378 a representation for that bound. */
16381 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
16383 switch (TREE_CODE (bound
))
16388 /* All fixed-bounds are represented by INTEGER_CST nodes. */
16391 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (bound
));
16394 /* Use the default if possible. */
16395 if (bound_attr
== DW_AT_lower_bound
16396 && tree_fits_shwi_p (bound
)
16397 && (dflt
= lower_bound_default ()) != -1
16398 && tree_to_shwi (bound
) == dflt
)
16401 /* If HOST_WIDE_INT is big enough then represent the bound as
16402 a constant value. We need to choose a form based on
16403 whether the type is signed or unsigned. We cannot just
16404 call add_AT_unsigned if the value itself is positive
16405 (add_AT_unsigned might add the unsigned value encoded as
16406 DW_FORM_data[1248]). Some DWARF consumers will lookup the
16407 bounds type and then sign extend any unsigned values found
16408 for signed types. This is needed only for
16409 DW_AT_{lower,upper}_bound, since for most other attributes,
16410 consumers will treat DW_FORM_data[1248] as unsigned values,
16411 regardless of the underlying type. */
16412 else if (prec
<= HOST_BITS_PER_WIDE_INT
16413 || tree_fits_uhwi_p (bound
))
16415 if (TYPE_UNSIGNED (TREE_TYPE (bound
)))
16416 add_AT_unsigned (subrange_die
, bound_attr
,
16417 TREE_INT_CST_LOW (bound
));
16419 add_AT_int (subrange_die
, bound_attr
, TREE_INT_CST_LOW (bound
));
16422 /* Otherwise represent the bound as an unsigned value with
16423 the precision of its type. The precision and signedness
16424 of the type will be necessary to re-interpret it
16426 add_AT_wide (subrange_die
, bound_attr
, bound
);
16431 case VIEW_CONVERT_EXPR
:
16432 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
16442 dw_die_ref decl_die
= lookup_decl_die (bound
);
16444 /* ??? Can this happen, or should the variable have been bound
16445 first? Probably it can, since I imagine that we try to create
16446 the types of parameters in the order in which they exist in
16447 the list, and won't have created a forward reference to a
16448 later parameter. */
16449 if (decl_die
!= NULL
)
16451 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16459 /* Otherwise try to create a stack operation procedure to
16460 evaluate the value of the array bound. */
16462 dw_die_ref ctx
, decl_die
;
16463 dw_loc_list_ref list
;
16465 list
= loc_list_from_tree (bound
, 2);
16466 if (list
== NULL
|| single_element_loc_list_p (list
))
16468 /* If DW_AT_*bound is not a reference nor constant, it is
16469 a DWARF expression rather than location description.
16470 For that loc_list_from_tree (bound, 0) is needed.
16471 If that fails to give a single element list,
16472 fall back to outputting this as a reference anyway. */
16473 dw_loc_list_ref list2
= loc_list_from_tree (bound
, 0);
16474 if (list2
&& single_element_loc_list_p (list2
))
16476 add_AT_loc (subrange_die
, bound_attr
, list2
->expr
);
16483 if (current_function_decl
== 0)
16484 ctx
= comp_unit_die ();
16486 ctx
= lookup_decl_die (current_function_decl
);
16488 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
16489 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
16490 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
16491 add_AT_location_description (decl_die
, DW_AT_location
, list
);
16492 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16498 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16499 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16500 Note that the block of subscript information for an array type also
16501 includes information about the element type of the given array type. */
16504 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
16506 unsigned dimension_number
;
16508 dw_die_ref subrange_die
;
16510 for (dimension_number
= 0;
16511 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
16512 type
= TREE_TYPE (type
), dimension_number
++)
16514 tree domain
= TYPE_DOMAIN (type
);
16516 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
16519 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16520 and (in GNU C only) variable bounds. Handle all three forms
16522 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
16525 /* We have an array type with specified bounds. */
16526 lower
= TYPE_MIN_VALUE (domain
);
16527 upper
= TYPE_MAX_VALUE (domain
);
16529 /* Define the index type. */
16530 if (TREE_TYPE (domain
))
16532 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16533 TREE_TYPE field. We can't emit debug info for this
16534 because it is an unnamed integral type. */
16535 if (TREE_CODE (domain
) == INTEGER_TYPE
16536 && TYPE_NAME (domain
) == NULL_TREE
16537 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
16538 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
16541 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
16545 /* ??? If upper is NULL, the array has unspecified length,
16546 but it does have a lower bound. This happens with Fortran
16548 Since the debugger is definitely going to need to know N
16549 to produce useful results, go ahead and output the lower
16550 bound solo, and hope the debugger can cope. */
16552 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
16554 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
16557 /* Otherwise we have an array type with an unspecified length. The
16558 DWARF-2 spec does not say how to handle this; let's just leave out the
16563 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
16566 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
16568 dw_die_ref decl_die
;
16569 HOST_WIDE_INT size
;
16571 switch (TREE_CODE (tree_node
))
16576 case ENUMERAL_TYPE
:
16579 case QUAL_UNION_TYPE
:
16580 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
16581 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
16583 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
16586 size
= int_size_in_bytes (tree_node
);
16589 /* For a data member of a struct or union, the DW_AT_byte_size is
16590 generally given as the number of bytes normally allocated for an
16591 object of the *declared* type of the member itself. This is true
16592 even for bit-fields. */
16593 size
= int_size_in_bytes (field_type (tree_node
));
16596 gcc_unreachable ();
16599 /* Note that `size' might be -1 when we get to this point. If it is, that
16600 indicates that the byte size of the entity in question is variable. We
16601 have no good way of expressing this fact in Dwarf at the present time,
16602 when location description was not used by the caller code instead. */
16604 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
16607 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16608 which specifies the distance in bits from the highest order bit of the
16609 "containing object" for the bit-field to the highest order bit of the
16612 For any given bit-field, the "containing object" is a hypothetical object
16613 (of some integral or enum type) within which the given bit-field lives. The
16614 type of this hypothetical "containing object" is always the same as the
16615 declared type of the individual bit-field itself. The determination of the
16616 exact location of the "containing object" for a bit-field is rather
16617 complicated. It's handled by the `field_byte_offset' function (above).
16619 Note that it is the size (in bytes) of the hypothetical "containing object"
16620 which will be given in the DW_AT_byte_size attribute for this bit-field.
16621 (See `byte_size_attribute' above). */
16624 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
16626 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
16627 tree type
= DECL_BIT_FIELD_TYPE (decl
);
16628 HOST_WIDE_INT bitpos_int
;
16629 HOST_WIDE_INT highest_order_object_bit_offset
;
16630 HOST_WIDE_INT highest_order_field_bit_offset
;
16631 HOST_WIDE_INT bit_offset
;
16633 /* Must be a field and a bit field. */
16634 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
16636 /* We can't yet handle bit-fields whose offsets are variable, so if we
16637 encounter such things, just return without generating any attribute
16638 whatsoever. Likewise for variable or too large size. */
16639 if (! tree_fits_shwi_p (bit_position (decl
))
16640 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
16643 bitpos_int
= int_bit_position (decl
);
16645 /* Note that the bit offset is always the distance (in bits) from the
16646 highest-order bit of the "containing object" to the highest-order bit of
16647 the bit-field itself. Since the "high-order end" of any object or field
16648 is different on big-endian and little-endian machines, the computation
16649 below must take account of these differences. */
16650 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
16651 highest_order_field_bit_offset
= bitpos_int
;
16653 if (! BYTES_BIG_ENDIAN
)
16655 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
16656 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
16660 = (! BYTES_BIG_ENDIAN
16661 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
16662 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
16664 if (bit_offset
< 0)
16665 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
16667 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
16670 /* For a FIELD_DECL node which represents a bit field, output an attribute
16671 which specifies the length in bits of the given field. */
16674 add_bit_size_attribute (dw_die_ref die
, tree decl
)
16676 /* Must be a field and a bit field. */
16677 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
16678 && DECL_BIT_FIELD_TYPE (decl
));
16680 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
16681 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
16684 /* If the compiled language is ANSI C, then add a 'prototyped'
16685 attribute, if arg types are given for the parameters of a function. */
16688 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
16690 if (get_AT_unsigned (comp_unit_die (), DW_AT_language
) == DW_LANG_C89
16691 && prototype_p (func_type
))
16692 add_AT_flag (die
, DW_AT_prototyped
, 1);
16695 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
16696 by looking in either the type declaration or object declaration
16699 static inline dw_die_ref
16700 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
16702 dw_die_ref origin_die
= NULL
;
16704 if (TREE_CODE (origin
) != FUNCTION_DECL
)
16706 /* We may have gotten separated from the block for the inlined
16707 function, if we're in an exception handler or some such; make
16708 sure that the abstract function has been written out.
16710 Doing this for nested functions is wrong, however; functions are
16711 distinct units, and our context might not even be inline. */
16715 fn
= TYPE_STUB_DECL (fn
);
16717 fn
= decl_function_context (fn
);
16719 dwarf2out_abstract_function (fn
);
16722 if (DECL_P (origin
))
16723 origin_die
= lookup_decl_die (origin
);
16724 else if (TYPE_P (origin
))
16725 origin_die
= lookup_type_die (origin
);
16727 /* XXX: Functions that are never lowered don't always have correct block
16728 trees (in the case of java, they simply have no block tree, in some other
16729 languages). For these functions, there is nothing we can really do to
16730 output correct debug info for inlined functions in all cases. Rather
16731 than die, we'll just produce deficient debug info now, in that we will
16732 have variables without a proper abstract origin. In the future, when all
16733 functions are lowered, we should re-add a gcc_assert (origin_die)
16737 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
16741 /* We do not currently support the pure_virtual attribute. */
16744 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
16746 if (DECL_VINDEX (func_decl
))
16748 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
16750 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
16751 add_AT_loc (die
, DW_AT_vtable_elem_location
,
16752 new_loc_descr (DW_OP_constu
,
16753 tree_to_shwi (DECL_VINDEX (func_decl
)),
16756 /* GNU extension: Record what type this method came from originally. */
16757 if (debug_info_level
> DINFO_LEVEL_TERSE
16758 && DECL_CONTEXT (func_decl
))
16759 add_AT_die_ref (die
, DW_AT_containing_type
,
16760 lookup_type_die (DECL_CONTEXT (func_decl
)));
16764 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
16765 given decl. This used to be a vendor extension until after DWARF 4
16766 standardized it. */
16769 add_linkage_attr (dw_die_ref die
, tree decl
)
16771 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
16773 /* Mimic what assemble_name_raw does with a leading '*'. */
16774 if (name
[0] == '*')
16777 if (dwarf_version
>= 4)
16778 add_AT_string (die
, DW_AT_linkage_name
, name
);
16780 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
16783 /* Add source coordinate attributes for the given decl. */
16786 add_src_coords_attributes (dw_die_ref die
, tree decl
)
16788 expanded_location s
;
16790 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
16792 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
16793 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
16794 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
16797 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
16800 add_linkage_name (dw_die_ref die
, tree decl
)
16802 if (debug_info_level
> DINFO_LEVEL_TERSE
16803 && (TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
16804 && TREE_PUBLIC (decl
)
16805 && !DECL_ABSTRACT (decl
)
16806 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
16807 && die
->die_tag
!= DW_TAG_member
)
16809 /* Defer until we have an assembler name set. */
16810 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
16812 limbo_die_node
*asm_name
;
16814 asm_name
= ggc_alloc_cleared_limbo_die_node ();
16815 asm_name
->die
= die
;
16816 asm_name
->created_for
= decl
;
16817 asm_name
->next
= deferred_asm_name
;
16818 deferred_asm_name
= asm_name
;
16820 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
16821 add_linkage_attr (die
, decl
);
16825 /* Add a DW_AT_name attribute and source coordinate attribute for the
16826 given decl, but only if it actually has a name. */
16829 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
16833 decl_name
= DECL_NAME (decl
);
16834 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
16836 const char *name
= dwarf2_name (decl
, 0);
16838 add_name_attribute (die
, name
);
16839 if (! DECL_ARTIFICIAL (decl
))
16840 add_src_coords_attributes (die
, decl
);
16842 add_linkage_name (die
, decl
);
16845 #ifdef VMS_DEBUGGING_INFO
16846 /* Get the function's name, as described by its RTL. This may be different
16847 from the DECL_NAME name used in the source file. */
16848 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
16850 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
16851 XEXP (DECL_RTL (decl
), 0), false);
16852 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
16854 #endif /* VMS_DEBUGGING_INFO */
16857 #ifdef VMS_DEBUGGING_INFO
16858 /* Output the debug main pointer die for VMS */
16861 dwarf2out_vms_debug_main_pointer (void)
16863 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
16866 /* Allocate the VMS debug main subprogram die. */
16867 die
= ggc_alloc_cleared_die_node ();
16868 die
->die_tag
= DW_TAG_subprogram
;
16869 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
16870 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
16871 current_function_funcdef_no
);
16872 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
16874 /* Make it the first child of comp_unit_die (). */
16875 die
->die_parent
= comp_unit_die ();
16876 if (comp_unit_die ()->die_child
)
16878 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
16879 comp_unit_die ()->die_child
->die_sib
= die
;
16883 die
->die_sib
= die
;
16884 comp_unit_die ()->die_child
= die
;
16887 #endif /* VMS_DEBUGGING_INFO */
16889 /* Push a new declaration scope. */
16892 push_decl_scope (tree scope
)
16894 vec_safe_push (decl_scope_table
, scope
);
16897 /* Pop a declaration scope. */
16900 pop_decl_scope (void)
16902 decl_scope_table
->pop ();
16905 /* walk_tree helper function for uses_local_type, below. */
16908 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
16911 *walk_subtrees
= 0;
16914 tree name
= TYPE_NAME (*tp
);
16915 if (name
&& DECL_P (name
) && decl_function_context (name
))
16921 /* If TYPE involves a function-local type (including a local typedef to a
16922 non-local type), returns that type; otherwise returns NULL_TREE. */
16925 uses_local_type (tree type
)
16927 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
16931 /* Return the DIE for the scope that immediately contains this type.
16932 Non-named types that do not involve a function-local type get global
16933 scope. Named types nested in namespaces or other types get their
16934 containing scope. All other types (i.e. function-local named types) get
16935 the current active scope. */
16938 scope_die_for (tree t
, dw_die_ref context_die
)
16940 dw_die_ref scope_die
= NULL
;
16941 tree containing_scope
;
16943 /* Non-types always go in the current scope. */
16944 gcc_assert (TYPE_P (t
));
16946 /* Use the scope of the typedef, rather than the scope of the type
16948 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
16949 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
16951 containing_scope
= TYPE_CONTEXT (t
);
16953 /* Use the containing namespace if there is one. */
16954 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
16956 if (context_die
== lookup_decl_die (containing_scope
))
16958 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
16959 context_die
= get_context_die (containing_scope
);
16961 containing_scope
= NULL_TREE
;
16964 /* Ignore function type "scopes" from the C frontend. They mean that
16965 a tagged type is local to a parmlist of a function declarator, but
16966 that isn't useful to DWARF. */
16967 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
16968 containing_scope
= NULL_TREE
;
16970 if (SCOPE_FILE_SCOPE_P (containing_scope
))
16972 /* If T uses a local type keep it local as well, to avoid references
16973 to function-local DIEs from outside the function. */
16974 if (current_function_decl
&& uses_local_type (t
))
16975 scope_die
= context_die
;
16977 scope_die
= comp_unit_die ();
16979 else if (TYPE_P (containing_scope
))
16981 /* For types, we can just look up the appropriate DIE. */
16982 if (debug_info_level
> DINFO_LEVEL_TERSE
)
16983 scope_die
= get_context_die (containing_scope
);
16986 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
16987 if (scope_die
== NULL
)
16988 scope_die
= comp_unit_die ();
16992 scope_die
= context_die
;
16997 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
17000 local_scope_p (dw_die_ref context_die
)
17002 for (; context_die
; context_die
= context_die
->die_parent
)
17003 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
17004 || context_die
->die_tag
== DW_TAG_subprogram
)
17010 /* Returns nonzero if CONTEXT_DIE is a class. */
17013 class_scope_p (dw_die_ref context_die
)
17015 return (context_die
17016 && (context_die
->die_tag
== DW_TAG_structure_type
17017 || context_die
->die_tag
== DW_TAG_class_type
17018 || context_die
->die_tag
== DW_TAG_interface_type
17019 || context_die
->die_tag
== DW_TAG_union_type
));
17022 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17023 whether or not to treat a DIE in this context as a declaration. */
17026 class_or_namespace_scope_p (dw_die_ref context_die
)
17028 return (class_scope_p (context_die
)
17029 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
17032 /* Many forms of DIEs require a "type description" attribute. This
17033 routine locates the proper "type descriptor" die for the type given
17034 by 'type', and adds a DW_AT_type attribute below the given die. */
17037 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
17038 int decl_volatile
, dw_die_ref context_die
)
17040 enum tree_code code
= TREE_CODE (type
);
17041 dw_die_ref type_die
= NULL
;
17043 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17044 or fixed-point type, use the inner type. This is because we have no
17045 support for unnamed types in base_type_die. This can happen if this is
17046 an Ada subrange type. Correct solution is emit a subrange type die. */
17047 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
17048 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
17049 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
17051 if (code
== ERROR_MARK
17052 /* Handle a special case. For functions whose return type is void, we
17053 generate *no* type attribute. (Note that no object may have type
17054 `void', so this only applies to function return types). */
17055 || code
== VOID_TYPE
)
17058 type_die
= modified_type_die (type
,
17059 decl_const
|| TYPE_READONLY (type
),
17060 decl_volatile
|| TYPE_VOLATILE (type
),
17063 if (type_die
!= NULL
)
17064 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
17067 /* Given an object die, add the calling convention attribute for the
17068 function call type. */
17070 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
17072 enum dwarf_calling_convention value
= DW_CC_normal
;
17074 value
= ((enum dwarf_calling_convention
)
17075 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
17078 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
17080 /* DWARF 2 doesn't provide a way to identify a program's source-level
17081 entry point. DW_AT_calling_convention attributes are only meant
17082 to describe functions' calling conventions. However, lacking a
17083 better way to signal the Fortran main program, we used this for
17084 a long time, following existing custom. Now, DWARF 4 has
17085 DW_AT_main_subprogram, which we add below, but some tools still
17086 rely on the old way, which we thus keep. */
17087 value
= DW_CC_program
;
17089 if (dwarf_version
>= 4 || !dwarf_strict
)
17090 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
17093 /* Only add the attribute if the backend requests it, and
17094 is not DW_CC_normal. */
17095 if (value
&& (value
!= DW_CC_normal
))
17096 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
17099 /* Given a tree pointer to a struct, class, union, or enum type node, return
17100 a pointer to the (string) tag name for the given type, or zero if the type
17101 was declared without a tag. */
17103 static const char *
17104 type_tag (const_tree type
)
17106 const char *name
= 0;
17108 if (TYPE_NAME (type
) != 0)
17112 /* Find the IDENTIFIER_NODE for the type name. */
17113 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
17114 && !TYPE_NAMELESS (type
))
17115 t
= TYPE_NAME (type
);
17117 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17118 a TYPE_DECL node, regardless of whether or not a `typedef' was
17120 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
17121 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
17123 /* We want to be extra verbose. Don't call dwarf_name if
17124 DECL_NAME isn't set. The default hook for decl_printable_name
17125 doesn't like that, and in this context it's correct to return
17126 0, instead of "<anonymous>" or the like. */
17127 if (DECL_NAME (TYPE_NAME (type
))
17128 && !DECL_NAMELESS (TYPE_NAME (type
)))
17129 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
17132 /* Now get the name as a string, or invent one. */
17133 if (!name
&& t
!= 0)
17134 name
= IDENTIFIER_POINTER (t
);
17137 return (name
== 0 || *name
== '\0') ? 0 : name
;
17140 /* Return the type associated with a data member, make a special check
17141 for bit field types. */
17144 member_declared_type (const_tree member
)
17146 return (DECL_BIT_FIELD_TYPE (member
)
17147 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
17150 /* Get the decl's label, as described by its RTL. This may be different
17151 from the DECL_NAME name used in the source file. */
17154 static const char *
17155 decl_start_label (tree decl
)
17158 const char *fnname
;
17160 x
= DECL_RTL (decl
);
17161 gcc_assert (MEM_P (x
));
17164 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
17166 fnname
= XSTR (x
, 0);
17171 /* These routines generate the internal representation of the DIE's for
17172 the compilation unit. Debugging information is collected by walking
17173 the declaration trees passed in from dwarf2out_decl(). */
17176 gen_array_type_die (tree type
, dw_die_ref context_die
)
17178 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17179 dw_die_ref array_die
;
17181 /* GNU compilers represent multidimensional array types as sequences of one
17182 dimensional array types whose element types are themselves array types.
17183 We sometimes squish that down to a single array_type DIE with multiple
17184 subscripts in the Dwarf debugging info. The draft Dwarf specification
17185 say that we are allowed to do this kind of compression in C, because
17186 there is no difference between an array of arrays and a multidimensional
17187 array. We don't do this for Ada to remain as close as possible to the
17188 actual representation, which is especially important against the language
17189 flexibilty wrt arrays of variable size. */
17191 bool collapse_nested_arrays
= !is_ada ();
17194 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17195 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17196 if (TYPE_STRING_FLAG (type
)
17197 && TREE_CODE (type
) == ARRAY_TYPE
17199 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
17201 HOST_WIDE_INT size
;
17203 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
17204 add_name_attribute (array_die
, type_tag (type
));
17205 equate_type_number_to_die (type
, array_die
);
17206 size
= int_size_in_bytes (type
);
17208 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17209 else if (TYPE_DOMAIN (type
) != NULL_TREE
17210 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
17211 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
17213 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
17214 dw_loc_list_ref loc
= loc_list_from_tree (szdecl
, 2);
17216 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
17217 if (loc
&& size
> 0)
17219 add_AT_location_description (array_die
, DW_AT_string_length
, loc
);
17220 if (size
!= DWARF2_ADDR_SIZE
)
17221 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17227 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17228 add_name_attribute (array_die
, type_tag (type
));
17229 equate_type_number_to_die (type
, array_die
);
17231 if (TREE_CODE (type
) == VECTOR_TYPE
)
17232 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
17234 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17236 && TREE_CODE (type
) == ARRAY_TYPE
17237 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
17238 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
17239 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17242 /* We default the array ordering. SDB will probably do
17243 the right things even if DW_AT_ordering is not present. It's not even
17244 an issue until we start to get into multidimensional arrays anyway. If
17245 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17246 then we'll have to put the DW_AT_ordering attribute back in. (But if
17247 and when we find out that we need to put these in, we will only do so
17248 for multidimensional arrays. */
17249 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
17252 if (TREE_CODE (type
) == VECTOR_TYPE
)
17254 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
17255 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17256 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
);
17257 add_bound_info (subrange_die
, DW_AT_upper_bound
,
17258 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
17261 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
17263 /* Add representation of the type of the elements of this array type and
17264 emit the corresponding DIE if we haven't done it already. */
17265 element_type
= TREE_TYPE (type
);
17266 if (collapse_nested_arrays
)
17267 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
17269 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
17271 element_type
= TREE_TYPE (element_type
);
17274 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
17276 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
17277 if (TYPE_ARTIFICIAL (type
))
17278 add_AT_flag (array_die
, DW_AT_artificial
, 1);
17280 if (get_AT (array_die
, DW_AT_name
))
17281 add_pubtype (type
, array_die
);
17284 static dw_loc_descr_ref
17285 descr_info_loc (tree val
, tree base_decl
)
17287 HOST_WIDE_INT size
;
17288 dw_loc_descr_ref loc
, loc2
;
17289 enum dwarf_location_atom op
;
17291 if (val
== base_decl
)
17292 return new_loc_descr (DW_OP_push_object_address
, 0, 0);
17294 switch (TREE_CODE (val
))
17297 return descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17299 return loc_descriptor_from_tree (val
, 0);
17301 if (tree_fits_shwi_p (val
))
17302 return int_loc_descriptor (tree_to_shwi (val
));
17305 size
= int_size_in_bytes (TREE_TYPE (val
));
17308 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17311 if (size
== DWARF2_ADDR_SIZE
)
17312 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref
, 0, 0));
17314 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref_size
, size
, 0));
17316 case POINTER_PLUS_EXPR
:
17318 if (tree_fits_uhwi_p (TREE_OPERAND (val
, 1))
17319 && tree_to_uhwi (TREE_OPERAND (val
, 1)) < 16384)
17321 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17324 loc_descr_plus_const (&loc
, tree_to_shwi (TREE_OPERAND (val
, 1)));
17330 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17333 loc2
= descr_info_loc (TREE_OPERAND (val
, 1), base_decl
);
17336 add_loc_descr (&loc
, loc2
);
17337 add_loc_descr (&loc2
, new_loc_descr (op
, 0, 0));
17359 add_descr_info_field (dw_die_ref die
, enum dwarf_attribute attr
,
17360 tree val
, tree base_decl
)
17362 dw_loc_descr_ref loc
;
17364 if (tree_fits_shwi_p (val
))
17366 add_AT_unsigned (die
, attr
, tree_to_shwi (val
));
17370 loc
= descr_info_loc (val
, base_decl
);
17374 add_AT_loc (die
, attr
, loc
);
17377 /* This routine generates DIE for array with hidden descriptor, details
17378 are filled into *info by a langhook. */
17381 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
17382 dw_die_ref context_die
)
17384 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17385 dw_die_ref array_die
;
17388 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17389 add_name_attribute (array_die
, type_tag (type
));
17390 equate_type_number_to_die (type
, array_die
);
17392 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17394 && info
->ndimensions
>= 2)
17395 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17397 if (info
->data_location
)
17398 add_descr_info_field (array_die
, DW_AT_data_location
, info
->data_location
,
17400 if (info
->associated
)
17401 add_descr_info_field (array_die
, DW_AT_associated
, info
->associated
,
17403 if (info
->allocated
)
17404 add_descr_info_field (array_die
, DW_AT_allocated
, info
->allocated
,
17407 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
17409 dw_die_ref subrange_die
17410 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17412 if (info
->dimen
[dim
].lower_bound
)
17414 /* If it is the default value, omit it. */
17417 if (tree_fits_shwi_p (info
->dimen
[dim
].lower_bound
)
17418 && (dflt
= lower_bound_default ()) != -1
17419 && tree_to_shwi (info
->dimen
[dim
].lower_bound
) == dflt
)
17422 add_descr_info_field (subrange_die
, DW_AT_lower_bound
,
17423 info
->dimen
[dim
].lower_bound
,
17426 if (info
->dimen
[dim
].upper_bound
)
17427 add_descr_info_field (subrange_die
, DW_AT_upper_bound
,
17428 info
->dimen
[dim
].upper_bound
,
17430 if (info
->dimen
[dim
].stride
)
17431 add_descr_info_field (subrange_die
, DW_AT_byte_stride
,
17432 info
->dimen
[dim
].stride
,
17436 gen_type_die (info
->element_type
, context_die
);
17437 add_type_attribute (array_die
, info
->element_type
, 0, 0, context_die
);
17439 if (get_AT (array_die
, DW_AT_name
))
17440 add_pubtype (type
, array_die
);
17445 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
17447 tree origin
= decl_ultimate_origin (decl
);
17448 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
17450 if (origin
!= NULL
)
17451 add_abstract_origin_attribute (decl_die
, origin
);
17454 add_name_and_src_coords_attributes (decl_die
, decl
);
17455 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
17456 0, 0, context_die
);
17459 if (DECL_ABSTRACT (decl
))
17460 equate_decl_number_to_die (decl
, decl_die
);
17462 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
17466 /* Walk through the list of incomplete types again, trying once more to
17467 emit full debugging info for them. */
17470 retry_incomplete_types (void)
17474 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
17475 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
17476 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
17479 /* Determine what tag to use for a record type. */
17481 static enum dwarf_tag
17482 record_type_tag (tree type
)
17484 if (! lang_hooks
.types
.classify_record
)
17485 return DW_TAG_structure_type
;
17487 switch (lang_hooks
.types
.classify_record (type
))
17489 case RECORD_IS_STRUCT
:
17490 return DW_TAG_structure_type
;
17492 case RECORD_IS_CLASS
:
17493 return DW_TAG_class_type
;
17495 case RECORD_IS_INTERFACE
:
17496 if (dwarf_version
>= 3 || !dwarf_strict
)
17497 return DW_TAG_interface_type
;
17498 return DW_TAG_structure_type
;
17501 gcc_unreachable ();
17505 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17506 include all of the information about the enumeration values also. Each
17507 enumerated type name/value is listed as a child of the enumerated type
17511 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
17513 dw_die_ref type_die
= lookup_type_die (type
);
17515 if (type_die
== NULL
)
17517 type_die
= new_die (DW_TAG_enumeration_type
,
17518 scope_die_for (type
, context_die
), type
);
17519 equate_type_number_to_die (type
, type_die
);
17520 add_name_attribute (type_die
, type_tag (type
));
17521 if (dwarf_version
>= 4 || !dwarf_strict
)
17523 if (ENUM_IS_SCOPED (type
))
17524 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
17525 if (ENUM_IS_OPAQUE (type
))
17526 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17529 else if (! TYPE_SIZE (type
))
17532 remove_AT (type_die
, DW_AT_declaration
);
17534 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17535 given enum type is incomplete, do not generate the DW_AT_byte_size
17536 attribute or the DW_AT_element_list attribute. */
17537 if (TYPE_SIZE (type
))
17541 TREE_ASM_WRITTEN (type
) = 1;
17542 add_byte_size_attribute (type_die
, type
);
17543 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
17545 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
17546 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
17549 /* If the first reference to this type was as the return type of an
17550 inline function, then it may not have a parent. Fix this now. */
17551 if (type_die
->die_parent
== NULL
)
17552 add_child_die (scope_die_for (type
, context_die
), type_die
);
17554 for (link
= TYPE_VALUES (type
);
17555 link
!= NULL
; link
= TREE_CHAIN (link
))
17557 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
17558 tree value
= TREE_VALUE (link
);
17560 add_name_attribute (enum_die
,
17561 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
17563 if (TREE_CODE (value
) == CONST_DECL
)
17564 value
= DECL_INITIAL (value
);
17566 if (simple_type_size_in_bits (TREE_TYPE (value
))
17567 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
17569 /* For constant forms created by add_AT_unsigned DWARF
17570 consumers (GDB, elfutils, etc.) always zero extend
17571 the value. Only when the actual value is negative
17572 do we need to use add_AT_int to generate a constant
17573 form that can represent negative values. */
17574 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
17575 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
17576 add_AT_unsigned (enum_die
, DW_AT_const_value
,
17577 (unsigned HOST_WIDE_INT
) val
);
17579 add_AT_int (enum_die
, DW_AT_const_value
, val
);
17582 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
17583 that here. TODO: This should be re-worked to use correct
17584 signed/unsigned double tags for all cases. */
17585 add_AT_wide (enum_die
, DW_AT_const_value
, value
);
17588 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
17589 if (TYPE_ARTIFICIAL (type
))
17590 add_AT_flag (type_die
, DW_AT_artificial
, 1);
17593 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17595 add_pubtype (type
, type_die
);
17600 /* Generate a DIE to represent either a real live formal parameter decl or to
17601 represent just the type of some formal parameter position in some function
17604 Note that this routine is a bit unusual because its argument may be a
17605 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17606 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17607 node. If it's the former then this function is being called to output a
17608 DIE to represent a formal parameter object (or some inlining thereof). If
17609 it's the latter, then this function is only being called to output a
17610 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17611 argument type of some subprogram type.
17612 If EMIT_NAME_P is true, name and source coordinate attributes
17616 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
17617 dw_die_ref context_die
)
17619 tree node_or_origin
= node
? node
: origin
;
17620 tree ultimate_origin
;
17621 dw_die_ref parm_die
17622 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
17624 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
17626 case tcc_declaration
:
17627 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
17628 if (node
|| ultimate_origin
)
17629 origin
= ultimate_origin
;
17630 if (origin
!= NULL
)
17631 add_abstract_origin_attribute (parm_die
, origin
);
17632 else if (emit_name_p
)
17633 add_name_and_src_coords_attributes (parm_die
, node
);
17635 || (! DECL_ABSTRACT (node_or_origin
)
17636 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
17637 decl_function_context
17638 (node_or_origin
))))
17640 tree type
= TREE_TYPE (node_or_origin
);
17641 if (decl_by_reference_p (node_or_origin
))
17642 add_type_attribute (parm_die
, TREE_TYPE (type
), 0, 0,
17645 add_type_attribute (parm_die
, type
,
17646 TREE_READONLY (node_or_origin
),
17647 TREE_THIS_VOLATILE (node_or_origin
),
17650 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
17651 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17653 if (node
&& node
!= origin
)
17654 equate_decl_number_to_die (node
, parm_die
);
17655 if (! DECL_ABSTRACT (node_or_origin
))
17656 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
17657 node
== NULL
, DW_AT_location
);
17662 /* We were called with some kind of a ..._TYPE node. */
17663 add_type_attribute (parm_die
, node_or_origin
, 0, 0, context_die
);
17667 gcc_unreachable ();
17673 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17674 children DW_TAG_formal_parameter DIEs representing the arguments of the
17677 PARM_PACK must be a function parameter pack.
17678 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17679 must point to the subsequent arguments of the function PACK_ARG belongs to.
17680 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17681 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17682 following the last one for which a DIE was generated. */
17685 gen_formal_parameter_pack_die (tree parm_pack
,
17687 dw_die_ref subr_die
,
17691 dw_die_ref parm_pack_die
;
17693 gcc_assert (parm_pack
17694 && lang_hooks
.function_parameter_pack_p (parm_pack
)
17697 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
17698 add_src_coords_attributes (parm_pack_die
, parm_pack
);
17700 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
17702 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
17705 gen_formal_parameter_die (arg
, NULL
,
17706 false /* Don't emit name attribute. */,
17711 return parm_pack_die
;
17714 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17715 at the end of an (ANSI prototyped) formal parameters list. */
17718 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
17720 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
17723 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17724 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17725 parameters as specified in some function type specification (except for
17726 those which appear as part of a function *definition*). */
17729 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
17732 tree formal_type
= NULL
;
17733 tree first_parm_type
;
17736 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
17738 arg
= DECL_ARGUMENTS (function_or_method_type
);
17739 function_or_method_type
= TREE_TYPE (function_or_method_type
);
17744 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
17746 /* Make our first pass over the list of formal parameter types and output a
17747 DW_TAG_formal_parameter DIE for each one. */
17748 for (link
= first_parm_type
; link
; )
17750 dw_die_ref parm_die
;
17752 formal_type
= TREE_VALUE (link
);
17753 if (formal_type
== void_type_node
)
17756 /* Output a (nameless) DIE to represent the formal parameter itself. */
17757 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
17758 true /* Emit name attribute. */,
17760 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
17761 && link
== first_parm_type
)
17763 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17764 if (dwarf_version
>= 3 || !dwarf_strict
)
17765 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
17767 else if (arg
&& DECL_ARTIFICIAL (arg
))
17768 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17770 link
= TREE_CHAIN (link
);
17772 arg
= DECL_CHAIN (arg
);
17775 /* If this function type has an ellipsis, add a
17776 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
17777 if (formal_type
!= void_type_node
)
17778 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
17780 /* Make our second (and final) pass over the list of formal parameter types
17781 and output DIEs to represent those types (as necessary). */
17782 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
17783 link
&& TREE_VALUE (link
);
17784 link
= TREE_CHAIN (link
))
17785 gen_type_die (TREE_VALUE (link
), context_die
);
17788 /* We want to generate the DIE for TYPE so that we can generate the
17789 die for MEMBER, which has been defined; we will need to refer back
17790 to the member declaration nested within TYPE. If we're trying to
17791 generate minimal debug info for TYPE, processing TYPE won't do the
17792 trick; we need to attach the member declaration by hand. */
17795 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
17797 gen_type_die (type
, context_die
);
17799 /* If we're trying to avoid duplicate debug info, we may not have
17800 emitted the member decl for this function. Emit it now. */
17801 if (TYPE_STUB_DECL (type
)
17802 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
17803 && ! lookup_decl_die (member
))
17805 dw_die_ref type_die
;
17806 gcc_assert (!decl_ultimate_origin (member
));
17808 push_decl_scope (type
);
17809 type_die
= lookup_type_die_strip_naming_typedef (type
);
17810 if (TREE_CODE (member
) == FUNCTION_DECL
)
17811 gen_subprogram_die (member
, type_die
);
17812 else if (TREE_CODE (member
) == FIELD_DECL
)
17814 /* Ignore the nameless fields that are used to skip bits but handle
17815 C++ anonymous unions and structs. */
17816 if (DECL_NAME (member
) != NULL_TREE
17817 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
17818 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
17820 gen_type_die (member_declared_type (member
), type_die
);
17821 gen_field_die (member
, type_die
);
17825 gen_variable_die (member
, NULL_TREE
, type_die
);
17831 /* Forward declare these functions, because they are mutually recursive
17832 with their set_block_* pairing functions. */
17833 static void set_decl_origin_self (tree
);
17834 static void set_decl_abstract_flags (tree
, int);
17836 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
17837 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
17838 that it points to the node itself, thus indicating that the node is its
17839 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
17840 the given node is NULL, recursively descend the decl/block tree which
17841 it is the root of, and for each other ..._DECL or BLOCK node contained
17842 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
17843 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
17844 values to point to themselves. */
17847 set_block_origin_self (tree stmt
)
17849 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
17851 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
17856 for (local_decl
= BLOCK_VARS (stmt
);
17857 local_decl
!= NULL_TREE
;
17858 local_decl
= DECL_CHAIN (local_decl
))
17859 if (! DECL_EXTERNAL (local_decl
))
17860 set_decl_origin_self (local_decl
); /* Potential recursion. */
17866 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17867 subblock
!= NULL_TREE
;
17868 subblock
= BLOCK_CHAIN (subblock
))
17869 set_block_origin_self (subblock
); /* Recurse. */
17874 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
17875 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
17876 node to so that it points to the node itself, thus indicating that the
17877 node represents its own (abstract) origin. Additionally, if the
17878 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
17879 the decl/block tree of which the given node is the root of, and for
17880 each other ..._DECL or BLOCK node contained therein whose
17881 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
17882 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
17883 point to themselves. */
17886 set_decl_origin_self (tree decl
)
17888 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
17890 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
17891 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17895 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17896 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
17897 if (DECL_INITIAL (decl
) != NULL_TREE
17898 && DECL_INITIAL (decl
) != error_mark_node
)
17899 set_block_origin_self (DECL_INITIAL (decl
));
17904 /* Given a pointer to some BLOCK node, and a boolean value to set the
17905 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
17906 the given block, and for all local decls and all local sub-blocks
17907 (recursively) which are contained therein. */
17910 set_block_abstract_flags (tree stmt
, int setting
)
17916 BLOCK_ABSTRACT (stmt
) = setting
;
17918 for (local_decl
= BLOCK_VARS (stmt
);
17919 local_decl
!= NULL_TREE
;
17920 local_decl
= DECL_CHAIN (local_decl
))
17921 if (! DECL_EXTERNAL (local_decl
))
17922 set_decl_abstract_flags (local_decl
, setting
);
17924 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
17926 local_decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
17927 if ((TREE_CODE (local_decl
) == VAR_DECL
&& !TREE_STATIC (local_decl
))
17928 || TREE_CODE (local_decl
) == PARM_DECL
)
17929 set_decl_abstract_flags (local_decl
, setting
);
17932 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17933 subblock
!= NULL_TREE
;
17934 subblock
= BLOCK_CHAIN (subblock
))
17935 set_block_abstract_flags (subblock
, setting
);
17938 /* Given a pointer to some ..._DECL node, and a boolean value to set the
17939 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
17940 given decl, and (in the case where the decl is a FUNCTION_DECL) also
17941 set the abstract flags for all of the parameters, local vars, local
17942 blocks and sub-blocks (recursively) to the same setting. */
17945 set_decl_abstract_flags (tree decl
, int setting
)
17947 DECL_ABSTRACT (decl
) = setting
;
17948 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17952 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17953 DECL_ABSTRACT (arg
) = setting
;
17954 if (DECL_INITIAL (decl
) != NULL_TREE
17955 && DECL_INITIAL (decl
) != error_mark_node
)
17956 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
17960 /* Generate the DWARF2 info for the "abstract" instance of a function which we
17961 may later generate inlined and/or out-of-line instances of. */
17964 dwarf2out_abstract_function (tree decl
)
17966 dw_die_ref old_die
;
17970 htab_t old_decl_loc_table
;
17971 htab_t old_cached_dw_loc_list_table
;
17972 int old_call_site_count
, old_tail_call_site_count
;
17973 struct call_arg_loc_node
*old_call_arg_locations
;
17975 /* Make sure we have the actual abstract inline, not a clone. */
17976 decl
= DECL_ORIGIN (decl
);
17978 old_die
= lookup_decl_die (decl
);
17979 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
17980 /* We've already generated the abstract instance. */
17983 /* We can be called while recursively when seeing block defining inlined subroutine
17984 DIE. Be sure to not clobber the outer location table nor use it or we would
17985 get locations in abstract instantces. */
17986 old_decl_loc_table
= decl_loc_table
;
17987 decl_loc_table
= NULL
;
17988 old_cached_dw_loc_list_table
= cached_dw_loc_list_table
;
17989 cached_dw_loc_list_table
= NULL
;
17990 old_call_arg_locations
= call_arg_locations
;
17991 call_arg_locations
= NULL
;
17992 old_call_site_count
= call_site_count
;
17993 call_site_count
= -1;
17994 old_tail_call_site_count
= tail_call_site_count
;
17995 tail_call_site_count
= -1;
17997 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
17998 we don't get confused by DECL_ABSTRACT. */
17999 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18001 context
= decl_class_context (decl
);
18003 gen_type_die_for_member
18004 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die ());
18007 /* Pretend we've just finished compiling this function. */
18008 save_fn
= current_function_decl
;
18009 current_function_decl
= decl
;
18011 was_abstract
= DECL_ABSTRACT (decl
);
18012 set_decl_abstract_flags (decl
, 1);
18013 dwarf2out_decl (decl
);
18014 if (! was_abstract
)
18015 set_decl_abstract_flags (decl
, 0);
18017 current_function_decl
= save_fn
;
18018 decl_loc_table
= old_decl_loc_table
;
18019 cached_dw_loc_list_table
= old_cached_dw_loc_list_table
;
18020 call_arg_locations
= old_call_arg_locations
;
18021 call_site_count
= old_call_site_count
;
18022 tail_call_site_count
= old_tail_call_site_count
;
18025 /* Helper function of premark_used_types() which gets called through
18028 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18029 marked as unused by prune_unused_types. */
18032 premark_used_types_helper (void **slot
, void *data ATTRIBUTE_UNUSED
)
18037 type
= (tree
) *slot
;
18038 die
= lookup_type_die (type
);
18040 die
->die_perennial_p
= 1;
18044 /* Helper function of premark_types_used_by_global_vars which gets called
18045 through htab_traverse.
18047 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18048 marked as unused by prune_unused_types. The DIE of the type is marked
18049 only if the global variable using the type will actually be emitted. */
18052 premark_types_used_by_global_vars_helper (void **slot
,
18053 void *data ATTRIBUTE_UNUSED
)
18055 struct types_used_by_vars_entry
*entry
;
18058 entry
= (struct types_used_by_vars_entry
*) *slot
;
18059 gcc_assert (entry
->type
!= NULL
18060 && entry
->var_decl
!= NULL
);
18061 die
= lookup_type_die (entry
->type
);
18064 /* Ask cgraph if the global variable really is to be emitted.
18065 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18066 varpool_node
*node
= varpool_get_node (entry
->var_decl
);
18067 if (node
&& node
->definition
)
18069 die
->die_perennial_p
= 1;
18070 /* Keep the parent DIEs as well. */
18071 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
18072 die
->die_perennial_p
= 1;
18078 /* Mark all members of used_types_hash as perennial. */
18081 premark_used_types (struct function
*fun
)
18083 if (fun
&& fun
->used_types_hash
)
18084 htab_traverse (fun
->used_types_hash
, premark_used_types_helper
, NULL
);
18087 /* Mark all members of types_used_by_vars_entry as perennial. */
18090 premark_types_used_by_global_vars (void)
18092 if (types_used_by_vars_hash
)
18093 htab_traverse (types_used_by_vars_hash
,
18094 premark_types_used_by_global_vars_helper
, NULL
);
18097 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
18098 for CA_LOC call arg loc node. */
18101 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
18102 struct call_arg_loc_node
*ca_loc
)
18104 dw_die_ref stmt_die
= NULL
, die
;
18105 tree block
= ca_loc
->block
;
18108 && block
!= DECL_INITIAL (decl
)
18109 && TREE_CODE (block
) == BLOCK
)
18111 if (block_map
.length () > BLOCK_NUMBER (block
))
18112 stmt_die
= block_map
[BLOCK_NUMBER (block
)];
18115 block
= BLOCK_SUPERCONTEXT (block
);
18117 if (stmt_die
== NULL
)
18118 stmt_die
= subr_die
;
18119 die
= new_die (DW_TAG_GNU_call_site
, stmt_die
, NULL_TREE
);
18120 add_AT_lbl_id (die
, DW_AT_low_pc
, ca_loc
->label
);
18121 if (ca_loc
->tail_call_p
)
18122 add_AT_flag (die
, DW_AT_GNU_tail_call
, 1);
18123 if (ca_loc
->symbol_ref
)
18125 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
18127 add_AT_die_ref (die
, DW_AT_abstract_origin
, tdie
);
18129 add_AT_addr (die
, DW_AT_abstract_origin
, ca_loc
->symbol_ref
, false);
18134 /* Generate a DIE to represent a declared function (either file-scope or
18138 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
18140 tree origin
= decl_ultimate_origin (decl
);
18141 dw_die_ref subr_die
;
18143 dw_die_ref old_die
= lookup_decl_die (decl
);
18144 int declaration
= (current_function_decl
!= decl
18145 || class_or_namespace_scope_p (context_die
));
18147 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
18149 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
18150 started to generate the abstract instance of an inline, decided to output
18151 its containing class, and proceeded to emit the declaration of the inline
18152 from the member list for the class. If so, DECLARATION takes priority;
18153 we'll get back to the abstract instance when done with the class. */
18155 /* The class-scope declaration DIE must be the primary DIE. */
18156 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
18159 gcc_assert (!old_die
);
18162 /* Now that the C++ front end lazily declares artificial member fns, we
18163 might need to retrofit the declaration into its class. */
18164 if (!declaration
&& !origin
&& !old_die
18165 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
18166 && !class_or_namespace_scope_p (context_die
)
18167 && debug_info_level
> DINFO_LEVEL_TERSE
)
18168 old_die
= force_decl_die (decl
);
18170 if (origin
!= NULL
)
18172 gcc_assert (!declaration
|| local_scope_p (context_die
));
18174 /* Fixup die_parent for the abstract instance of a nested
18175 inline function. */
18176 if (old_die
&& old_die
->die_parent
== NULL
)
18177 add_child_die (context_die
, old_die
);
18179 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18180 add_abstract_origin_attribute (subr_die
, origin
);
18181 /* This is where the actual code for a cloned function is.
18182 Let's emit linkage name attribute for it. This helps
18183 debuggers to e.g, set breakpoints into
18184 constructors/destructors when the user asks "break
18186 add_linkage_name (subr_die
, decl
);
18190 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18191 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18193 if (!get_AT_flag (old_die
, DW_AT_declaration
)
18194 /* We can have a normal definition following an inline one in the
18195 case of redefinition of GNU C extern inlines.
18196 It seems reasonable to use AT_specification in this case. */
18197 && !get_AT (old_die
, DW_AT_inline
))
18199 /* Detect and ignore this case, where we are trying to output
18200 something we have already output. */
18204 /* If the definition comes from the same place as the declaration,
18205 maybe use the old DIE. We always want the DIE for this function
18206 that has the *_pc attributes to be under comp_unit_die so the
18207 debugger can find it. We also need to do this for abstract
18208 instances of inlines, since the spec requires the out-of-line copy
18209 to have the same parent. For local class methods, this doesn't
18210 apply; we just use the old DIE. */
18211 if ((is_cu_die (old_die
->die_parent
) || context_die
== NULL
)
18212 && (DECL_ARTIFICIAL (decl
)
18213 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
18214 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
18215 == (unsigned) s
.line
))))
18217 subr_die
= old_die
;
18219 /* Clear out the declaration attribute and the formal parameters.
18220 Do not remove all children, because it is possible that this
18221 declaration die was forced using force_decl_die(). In such
18222 cases die that forced declaration die (e.g. TAG_imported_module)
18223 is one of the children that we do not want to remove. */
18224 remove_AT (subr_die
, DW_AT_declaration
);
18225 remove_AT (subr_die
, DW_AT_object_pointer
);
18226 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
18230 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18231 add_AT_specification (subr_die
, old_die
);
18232 add_pubname (decl
, subr_die
);
18233 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18234 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
18235 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18236 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
18238 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
18239 emit the real type on the definition die. */
18240 if (is_cxx() && debug_info_level
> DINFO_LEVEL_TERSE
)
18242 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
18243 if (die
== auto_die
|| die
== decltype_auto_die
)
18244 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18245 0, 0, context_die
);
18251 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18253 if (TREE_PUBLIC (decl
))
18254 add_AT_flag (subr_die
, DW_AT_external
, 1);
18256 add_name_and_src_coords_attributes (subr_die
, decl
);
18257 add_pubname (decl
, subr_die
);
18258 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18260 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
18261 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18262 0, 0, context_die
);
18265 add_pure_or_virtual_attribute (subr_die
, decl
);
18266 if (DECL_ARTIFICIAL (decl
))
18267 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18269 add_accessibility_attribute (subr_die
, decl
);
18274 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18276 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
18278 /* If this is an explicit function declaration then generate
18279 a DW_AT_explicit attribute. */
18280 if (lang_hooks
.decls
.function_decl_explicit_p (decl
)
18281 && (dwarf_version
>= 3 || !dwarf_strict
))
18282 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
18284 /* The first time we see a member function, it is in the context of
18285 the class to which it belongs. We make sure of this by emitting
18286 the class first. The next time is the definition, which is
18287 handled above. The two may come from the same source text.
18289 Note that force_decl_die() forces function declaration die. It is
18290 later reused to represent definition. */
18291 equate_decl_number_to_die (decl
, subr_die
);
18294 else if (DECL_ABSTRACT (decl
))
18296 if (DECL_DECLARED_INLINE_P (decl
))
18298 if (cgraph_function_possibly_inlined_p (decl
))
18299 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
18301 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
18305 if (cgraph_function_possibly_inlined_p (decl
))
18306 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
18308 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
18311 if (DECL_DECLARED_INLINE_P (decl
)
18312 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
18313 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18315 equate_decl_number_to_die (decl
, subr_die
);
18317 else if (!DECL_EXTERNAL (decl
))
18319 HOST_WIDE_INT cfa_fb_offset
;
18320 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
18322 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18323 equate_decl_number_to_die (decl
, subr_die
);
18325 gcc_checking_assert (fun
);
18326 if (!flag_reorder_blocks_and_partition
)
18328 dw_fde_ref fde
= fun
->fde
;
18329 if (fde
->dw_fde_begin
)
18331 /* We have already generated the labels. */
18332 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18333 fde
->dw_fde_end
, false);
18337 /* Create start/end labels and add the range. */
18338 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
18339 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
18340 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
18341 current_function_funcdef_no
);
18342 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
18343 current_function_funcdef_no
);
18344 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
18348 #if VMS_DEBUGGING_INFO
18349 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18350 Section 2.3 Prologue and Epilogue Attributes:
18351 When a breakpoint is set on entry to a function, it is generally
18352 desirable for execution to be suspended, not on the very first
18353 instruction of the function, but rather at a point after the
18354 function's frame has been set up, after any language defined local
18355 declaration processing has been completed, and before execution of
18356 the first statement of the function begins. Debuggers generally
18357 cannot properly determine where this point is. Similarly for a
18358 breakpoint set on exit from a function. The prologue and epilogue
18359 attributes allow a compiler to communicate the location(s) to use. */
18362 if (fde
->dw_fde_vms_end_prologue
)
18363 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
18364 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
18366 if (fde
->dw_fde_vms_begin_epilogue
)
18367 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
18368 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
18375 /* Generate pubnames entries for the split function code ranges. */
18376 dw_fde_ref fde
= fun
->fde
;
18378 if (fde
->dw_fde_second_begin
)
18380 if (dwarf_version
>= 3 || !dwarf_strict
)
18382 /* We should use ranges for non-contiguous code section
18383 addresses. Use the actual code range for the initial
18384 section, since the HOT/COLD labels might precede an
18385 alignment offset. */
18386 bool range_list_added
= false;
18387 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
18388 fde
->dw_fde_end
, &range_list_added
,
18390 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
18391 fde
->dw_fde_second_end
,
18392 &range_list_added
, false);
18393 if (range_list_added
)
18398 /* There is no real support in DW2 for this .. so we make
18399 a work-around. First, emit the pub name for the segment
18400 containing the function label. Then make and emit a
18401 simplified subprogram DIE for the second segment with the
18402 name pre-fixed by __hot/cold_sect_of_. We use the same
18403 linkage name for the second die so that gdb will find both
18404 sections when given "b foo". */
18405 const char *name
= NULL
;
18406 tree decl_name
= DECL_NAME (decl
);
18407 dw_die_ref seg_die
;
18409 /* Do the 'primary' section. */
18410 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18411 fde
->dw_fde_end
, false);
18413 /* Build a minimal DIE for the secondary section. */
18414 seg_die
= new_die (DW_TAG_subprogram
,
18415 subr_die
->die_parent
, decl
);
18417 if (TREE_PUBLIC (decl
))
18418 add_AT_flag (seg_die
, DW_AT_external
, 1);
18420 if (decl_name
!= NULL
18421 && IDENTIFIER_POINTER (decl_name
) != NULL
)
18423 name
= dwarf2_name (decl
, 1);
18424 if (! DECL_ARTIFICIAL (decl
))
18425 add_src_coords_attributes (seg_die
, decl
);
18427 add_linkage_name (seg_die
, decl
);
18429 gcc_assert (name
!= NULL
);
18430 add_pure_or_virtual_attribute (seg_die
, decl
);
18431 if (DECL_ARTIFICIAL (decl
))
18432 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
18434 name
= concat ("__second_sect_of_", name
, NULL
);
18435 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
18436 fde
->dw_fde_second_end
, false);
18437 add_name_attribute (seg_die
, name
);
18438 if (want_pubnames ())
18439 add_pubname_string (name
, seg_die
);
18443 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
18447 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
18449 /* We define the "frame base" as the function's CFA. This is more
18450 convenient for several reasons: (1) It's stable across the prologue
18451 and epilogue, which makes it better than just a frame pointer,
18452 (2) With dwarf3, there exists a one-byte encoding that allows us
18453 to reference the .debug_frame data by proxy, but failing that,
18454 (3) We can at least reuse the code inspection and interpretation
18455 code that determines the CFA position at various points in the
18457 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
18459 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
18460 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
18464 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
18465 if (list
->dw_loc_next
)
18466 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
18468 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
18471 /* Compute a displacement from the "steady-state frame pointer" to
18472 the CFA. The former is what all stack slots and argument slots
18473 will reference in the rtl; the latter is what we've told the
18474 debugger about. We'll need to adjust all frame_base references
18475 by this displacement. */
18476 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
18478 if (fun
->static_chain_decl
)
18479 add_AT_location_description (subr_die
, DW_AT_static_link
,
18480 loc_list_from_tree (fun
->static_chain_decl
, 2));
18483 /* Generate child dies for template paramaters. */
18484 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18485 gen_generic_params_dies (decl
);
18487 /* Now output descriptions of the arguments for this function. This gets
18488 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18489 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18490 `...' at the end of the formal parameter list. In order to find out if
18491 there was a trailing ellipsis or not, we must instead look at the type
18492 associated with the FUNCTION_DECL. This will be a node of type
18493 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18494 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18495 an ellipsis at the end. */
18497 /* In the case where we are describing a mere function declaration, all we
18498 need to do here (and all we *can* do here) is to describe the *types* of
18499 its formal parameters. */
18500 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
18502 else if (declaration
)
18503 gen_formal_types_die (decl
, subr_die
);
18506 /* Generate DIEs to represent all known formal parameters. */
18507 tree parm
= DECL_ARGUMENTS (decl
);
18508 tree generic_decl
= lang_hooks
.decls
.get_generic_function_decl (decl
);
18509 tree generic_decl_parm
= generic_decl
18510 ? DECL_ARGUMENTS (generic_decl
)
18513 /* Now we want to walk the list of parameters of the function and
18514 emit their relevant DIEs.
18516 We consider the case of DECL being an instance of a generic function
18517 as well as it being a normal function.
18519 If DECL is an instance of a generic function we walk the
18520 parameters of the generic function declaration _and_ the parameters of
18521 DECL itself. This is useful because we want to emit specific DIEs for
18522 function parameter packs and those are declared as part of the
18523 generic function declaration. In that particular case,
18524 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18525 That DIE has children DIEs representing the set of arguments
18526 of the pack. Note that the set of pack arguments can be empty.
18527 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18530 Otherwise, we just consider the parameters of DECL. */
18531 while (generic_decl_parm
|| parm
)
18533 if (generic_decl_parm
18534 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
18535 gen_formal_parameter_pack_die (generic_decl_parm
,
18540 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, subr_die
);
18542 if (parm
== DECL_ARGUMENTS (decl
)
18543 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
18545 && (dwarf_version
>= 3 || !dwarf_strict
))
18546 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
18548 parm
= DECL_CHAIN (parm
);
18551 if (generic_decl_parm
)
18552 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
18555 /* Decide whether we need an unspecified_parameters DIE at the end.
18556 There are 2 more cases to do this for: 1) the ansi ... declaration -
18557 this is detectable when the end of the arg list is not a
18558 void_type_node 2) an unprototyped function declaration (not a
18559 definition). This just means that we have no info about the
18560 parameters at all. */
18561 if (prototype_p (TREE_TYPE (decl
)))
18563 /* This is the prototyped case, check for.... */
18564 if (stdarg_p (TREE_TYPE (decl
)))
18565 gen_unspecified_parameters_die (decl
, subr_die
);
18567 else if (DECL_INITIAL (decl
) == NULL_TREE
)
18568 gen_unspecified_parameters_die (decl
, subr_die
);
18571 /* Output Dwarf info for all of the stuff within the body of the function
18572 (if it has one - it may be just a declaration). */
18573 outer_scope
= DECL_INITIAL (decl
);
18575 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18576 a function. This BLOCK actually represents the outermost binding contour
18577 for the function, i.e. the contour in which the function's formal
18578 parameters and labels get declared. Curiously, it appears that the front
18579 end doesn't actually put the PARM_DECL nodes for the current function onto
18580 the BLOCK_VARS list for this outer scope, but are strung off of the
18581 DECL_ARGUMENTS list for the function instead.
18583 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18584 the LABEL_DECL nodes for the function however, and we output DWARF info
18585 for those in decls_for_scope. Just within the `outer_scope' there will be
18586 a BLOCK node representing the function's outermost pair of curly braces,
18587 and any blocks used for the base and member initializers of a C++
18588 constructor function. */
18589 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
18591 int call_site_note_count
= 0;
18592 int tail_call_site_note_count
= 0;
18594 /* Emit a DW_TAG_variable DIE for a named return value. */
18595 if (DECL_NAME (DECL_RESULT (decl
)))
18596 gen_decl_die (DECL_RESULT (decl
), NULL
, subr_die
);
18598 current_function_has_inlines
= 0;
18599 decls_for_scope (outer_scope
, subr_die
, 0);
18601 if (call_arg_locations
&& !dwarf_strict
)
18603 struct call_arg_loc_node
*ca_loc
;
18604 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
18606 dw_die_ref die
= NULL
;
18607 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
18610 for (arg
= NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
);
18611 arg
; arg
= next_arg
)
18613 dw_loc_descr_ref reg
, val
;
18614 enum machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
18615 dw_die_ref cdie
, tdie
= NULL
;
18617 next_arg
= XEXP (arg
, 1);
18618 if (REG_P (XEXP (XEXP (arg
, 0), 0))
18620 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
18621 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
18622 && REGNO (XEXP (XEXP (arg
, 0), 0))
18623 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
18624 next_arg
= XEXP (next_arg
, 1);
18625 if (mode
== VOIDmode
)
18627 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
18628 if (mode
== VOIDmode
)
18629 mode
= GET_MODE (XEXP (arg
, 0));
18631 if (mode
== VOIDmode
|| mode
== BLKmode
)
18633 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
18635 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18636 tloc
= XEXP (XEXP (arg
, 0), 1);
18639 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
18640 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
18642 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18643 tlocc
= XEXP (XEXP (arg
, 0), 1);
18647 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
18648 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
18649 VAR_INIT_STATUS_INITIALIZED
);
18650 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
18652 rtx mem
= XEXP (XEXP (arg
, 0), 0);
18653 reg
= mem_loc_descriptor (XEXP (mem
, 0),
18654 get_address_mode (mem
),
18656 VAR_INIT_STATUS_INITIALIZED
);
18658 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
18659 == DEBUG_PARAMETER_REF
)
18662 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
18663 tdie
= lookup_decl_die (tdecl
);
18670 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
18671 != DEBUG_PARAMETER_REF
)
18673 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
18675 VAR_INIT_STATUS_INITIALIZED
);
18679 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18680 cdie
= new_die (DW_TAG_GNU_call_site_parameter
, die
,
18683 add_AT_loc (cdie
, DW_AT_location
, reg
);
18684 else if (tdie
!= NULL
)
18685 add_AT_die_ref (cdie
, DW_AT_abstract_origin
, tdie
);
18686 add_AT_loc (cdie
, DW_AT_GNU_call_site_value
, val
);
18687 if (next_arg
!= XEXP (arg
, 1))
18689 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
18690 if (mode
== VOIDmode
)
18691 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
18692 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
18695 VAR_INIT_STATUS_INITIALIZED
);
18697 add_AT_loc (cdie
, DW_AT_GNU_call_site_data_value
, val
);
18701 && (ca_loc
->symbol_ref
|| tloc
))
18702 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18703 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
18705 dw_loc_descr_ref tval
= NULL
;
18707 if (tloc
!= NULL_RTX
)
18708 tval
= mem_loc_descriptor (tloc
,
18709 GET_MODE (tloc
) == VOIDmode
18710 ? Pmode
: GET_MODE (tloc
),
18712 VAR_INIT_STATUS_INITIALIZED
);
18714 add_AT_loc (die
, DW_AT_GNU_call_site_target
, tval
);
18715 else if (tlocc
!= NULL_RTX
)
18717 tval
= mem_loc_descriptor (tlocc
,
18718 GET_MODE (tlocc
) == VOIDmode
18719 ? Pmode
: GET_MODE (tlocc
),
18721 VAR_INIT_STATUS_INITIALIZED
);
18723 add_AT_loc (die
, DW_AT_GNU_call_site_target_clobbered
,
18729 call_site_note_count
++;
18730 if (ca_loc
->tail_call_p
)
18731 tail_call_site_note_count
++;
18735 call_arg_locations
= NULL
;
18736 call_arg_loc_last
= NULL
;
18737 if (tail_call_site_count
>= 0
18738 && tail_call_site_count
== tail_call_site_note_count
18741 if (call_site_count
>= 0
18742 && call_site_count
== call_site_note_count
)
18743 add_AT_flag (subr_die
, DW_AT_GNU_all_call_sites
, 1);
18745 add_AT_flag (subr_die
, DW_AT_GNU_all_tail_call_sites
, 1);
18747 call_site_count
= -1;
18748 tail_call_site_count
= -1;
18751 if (subr_die
!= old_die
)
18752 /* Add the calling convention attribute if requested. */
18753 add_calling_convention_attribute (subr_die
, decl
);
18756 /* Returns a hash value for X (which really is a die_struct). */
18759 common_block_die_table_hash (const void *x
)
18761 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18762 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
18765 /* Return nonzero if decl_id and die_parent of die_struct X is the same
18766 as decl_id and die_parent of die_struct Y. */
18769 common_block_die_table_eq (const void *x
, const void *y
)
18771 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18772 const_dw_die_ref e
= (const_dw_die_ref
) y
;
18773 return d
->decl_id
== e
->decl_id
&& d
->die_parent
== e
->die_parent
;
18776 /* Generate a DIE to represent a declared data object.
18777 Either DECL or ORIGIN must be non-null. */
18780 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
18782 HOST_WIDE_INT off
= 0;
18784 tree decl_or_origin
= decl
? decl
: origin
;
18785 tree ultimate_origin
;
18786 dw_die_ref var_die
;
18787 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
18788 dw_die_ref origin_die
;
18789 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
18790 || class_or_namespace_scope_p (context_die
));
18791 bool specialization_p
= false;
18793 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
18794 if (decl
|| ultimate_origin
)
18795 origin
= ultimate_origin
;
18796 com_decl
= fortran_common (decl_or_origin
, &off
);
18798 /* Symbol in common gets emitted as a child of the common block, in the form
18799 of a data member. */
18802 dw_die_ref com_die
;
18803 dw_loc_list_ref loc
;
18804 die_node com_die_arg
;
18806 var_die
= lookup_decl_die (decl_or_origin
);
18809 if (get_AT (var_die
, DW_AT_location
) == NULL
)
18811 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2);
18816 /* Optimize the common case. */
18817 if (single_element_loc_list_p (loc
)
18818 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18819 && loc
->expr
->dw_loc_next
== NULL
18820 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
18823 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18824 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18825 = plus_constant (GET_MODE (x
), x
, off
);
18828 loc_list_plus_const (loc
, off
);
18830 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18831 remove_AT (var_die
, DW_AT_declaration
);
18837 if (common_block_die_table
== NULL
)
18838 common_block_die_table
18839 = htab_create_ggc (10, common_block_die_table_hash
,
18840 common_block_die_table_eq
, NULL
);
18842 com_die_arg
.decl_id
= DECL_UID (com_decl
);
18843 com_die_arg
.die_parent
= context_die
;
18844 com_die
= (dw_die_ref
) htab_find (common_block_die_table
, &com_die_arg
);
18845 loc
= loc_list_from_tree (com_decl
, 2);
18846 if (com_die
== NULL
)
18849 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
18852 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
18853 add_name_and_src_coords_attributes (com_die
, com_decl
);
18856 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18857 /* Avoid sharing the same loc descriptor between
18858 DW_TAG_common_block and DW_TAG_variable. */
18859 loc
= loc_list_from_tree (com_decl
, 2);
18861 else if (DECL_EXTERNAL (decl
))
18862 add_AT_flag (com_die
, DW_AT_declaration
, 1);
18863 if (want_pubnames ())
18864 add_pubname_string (cnam
, com_die
); /* ??? needed? */
18865 com_die
->decl_id
= DECL_UID (com_decl
);
18866 slot
= htab_find_slot (common_block_die_table
, com_die
, INSERT
);
18867 *slot
= (void *) com_die
;
18869 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
18871 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18872 loc
= loc_list_from_tree (com_decl
, 2);
18873 remove_AT (com_die
, DW_AT_declaration
);
18875 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
18876 add_name_and_src_coords_attributes (var_die
, decl
);
18877 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
18878 TREE_THIS_VOLATILE (decl
), context_die
);
18879 add_AT_flag (var_die
, DW_AT_external
, 1);
18884 /* Optimize the common case. */
18885 if (single_element_loc_list_p (loc
)
18886 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18887 && loc
->expr
->dw_loc_next
== NULL
18888 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
18890 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18891 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18892 = plus_constant (GET_MODE (x
), x
, off
);
18895 loc_list_plus_const (loc
, off
);
18897 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18899 else if (DECL_EXTERNAL (decl
))
18900 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18901 equate_decl_number_to_die (decl
, var_die
);
18905 /* If the compiler emitted a definition for the DECL declaration
18906 and if we already emitted a DIE for it, don't emit a second
18907 DIE for it again. Allow re-declarations of DECLs that are
18908 inside functions, though. */
18909 if (old_die
&& declaration
&& !local_scope_p (context_die
))
18912 /* For static data members, the declaration in the class is supposed
18913 to have DW_TAG_member tag; the specification should still be
18914 DW_TAG_variable referencing the DW_TAG_member DIE. */
18915 if (declaration
&& class_scope_p (context_die
))
18916 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
18918 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
18921 if (origin
!= NULL
)
18922 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
18924 /* Loop unrolling can create multiple blocks that refer to the same
18925 static variable, so we must test for the DW_AT_declaration flag.
18927 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
18928 copy decls and set the DECL_ABSTRACT flag on them instead of
18931 ??? Duplicated blocks have been rewritten to use .debug_ranges.
18933 ??? The declare_in_namespace support causes us to get two DIEs for one
18934 variable, both of which are declarations. We want to avoid considering
18935 one to be a specification, so we must test that this DIE is not a
18937 else if (old_die
&& TREE_STATIC (decl
) && ! declaration
18938 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
18940 /* This is a definition of a C++ class level static. */
18941 add_AT_specification (var_die
, old_die
);
18942 specialization_p
= true;
18943 if (DECL_NAME (decl
))
18945 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18946 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18948 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18949 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
18951 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18952 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
18954 if (old_die
->die_tag
== DW_TAG_member
)
18955 add_linkage_name (var_die
, decl
);
18959 add_name_and_src_coords_attributes (var_die
, decl
);
18961 if ((origin
== NULL
&& !specialization_p
)
18963 && !DECL_ABSTRACT (decl_or_origin
)
18964 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
18965 decl_function_context
18966 (decl_or_origin
))))
18968 tree type
= TREE_TYPE (decl_or_origin
);
18970 if (decl_by_reference_p (decl_or_origin
))
18971 add_type_attribute (var_die
, TREE_TYPE (type
), 0, 0, context_die
);
18973 add_type_attribute (var_die
, type
, TREE_READONLY (decl_or_origin
),
18974 TREE_THIS_VOLATILE (decl_or_origin
), context_die
);
18977 if (origin
== NULL
&& !specialization_p
)
18979 if (TREE_PUBLIC (decl
))
18980 add_AT_flag (var_die
, DW_AT_external
, 1);
18982 if (DECL_ARTIFICIAL (decl
))
18983 add_AT_flag (var_die
, DW_AT_artificial
, 1);
18985 add_accessibility_attribute (var_die
, decl
);
18989 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18991 if (decl
&& (DECL_ABSTRACT (decl
) || declaration
|| old_die
== NULL
))
18992 equate_decl_number_to_die (decl
, var_die
);
18995 && (! DECL_ABSTRACT (decl_or_origin
)
18996 /* Local static vars are shared between all clones/inlines,
18997 so emit DW_AT_location on the abstract DIE if DECL_RTL is
18999 || (TREE_CODE (decl_or_origin
) == VAR_DECL
19000 && TREE_STATIC (decl_or_origin
)
19001 && DECL_RTL_SET_P (decl_or_origin
)))
19002 /* When abstract origin already has DW_AT_location attribute, no need
19003 to add it again. */
19004 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
19006 if (TREE_CODE (decl_or_origin
) == VAR_DECL
&& TREE_STATIC (decl_or_origin
)
19007 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin
)))
19008 defer_location (decl_or_origin
, var_die
);
19010 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
19011 decl
== NULL
, DW_AT_location
);
19012 add_pubname (decl_or_origin
, var_die
);
19015 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
19018 /* Generate a DIE to represent a named constant. */
19021 gen_const_die (tree decl
, dw_die_ref context_die
)
19023 dw_die_ref const_die
;
19024 tree type
= TREE_TYPE (decl
);
19026 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
19027 add_name_and_src_coords_attributes (const_die
, decl
);
19028 add_type_attribute (const_die
, type
, 1, 0, context_die
);
19029 if (TREE_PUBLIC (decl
))
19030 add_AT_flag (const_die
, DW_AT_external
, 1);
19031 if (DECL_ARTIFICIAL (decl
))
19032 add_AT_flag (const_die
, DW_AT_artificial
, 1);
19033 tree_add_const_value_attribute_for_decl (const_die
, decl
);
19036 /* Generate a DIE to represent a label identifier. */
19039 gen_label_die (tree decl
, dw_die_ref context_die
)
19041 tree origin
= decl_ultimate_origin (decl
);
19042 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
19044 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
19046 if (origin
!= NULL
)
19047 add_abstract_origin_attribute (lbl_die
, origin
);
19049 add_name_and_src_coords_attributes (lbl_die
, decl
);
19051 if (DECL_ABSTRACT (decl
))
19052 equate_decl_number_to_die (decl
, lbl_die
);
19055 insn
= DECL_RTL_IF_SET (decl
);
19057 /* Deleted labels are programmer specified labels which have been
19058 eliminated because of various optimizations. We still emit them
19059 here so that it is possible to put breakpoints on them. */
19063 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
19065 /* When optimization is enabled (via -O) some parts of the compiler
19066 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19067 represent source-level labels which were explicitly declared by
19068 the user. This really shouldn't be happening though, so catch
19069 it if it ever does happen. */
19070 gcc_assert (!INSN_DELETED_P (insn
));
19072 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
19073 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
19077 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
19078 && CODE_LABEL_NUMBER (insn
) != -1)
19080 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
19081 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
19086 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19087 attributes to the DIE for a block STMT, to describe where the inlined
19088 function was called from. This is similar to add_src_coords_attributes. */
19091 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
19093 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
19095 if (dwarf_version
>= 3 || !dwarf_strict
)
19097 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
19098 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
19103 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19104 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19107 add_high_low_attributes (tree stmt
, dw_die_ref die
)
19109 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
19111 if (BLOCK_FRAGMENT_CHAIN (stmt
)
19112 && (dwarf_version
>= 3 || !dwarf_strict
))
19114 tree chain
, superblock
= NULL_TREE
;
19116 dw_attr_ref attr
= NULL
;
19118 if (inlined_function_outer_scope_p (stmt
))
19120 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19121 BLOCK_NUMBER (stmt
));
19122 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
19125 /* Optimize duplicate .debug_ranges lists or even tails of
19126 lists. If this BLOCK has same ranges as its supercontext,
19127 lookup DW_AT_ranges attribute in the supercontext (and
19128 recursively so), verify that the ranges_table contains the
19129 right values and use it instead of adding a new .debug_range. */
19130 for (chain
= stmt
, pdie
= die
;
19131 BLOCK_SAME_RANGE (chain
);
19132 chain
= BLOCK_SUPERCONTEXT (chain
))
19134 dw_attr_ref new_attr
;
19136 pdie
= pdie
->die_parent
;
19139 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
19141 new_attr
= get_AT (pdie
, DW_AT_ranges
);
19142 if (new_attr
== NULL
19143 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
19146 superblock
= BLOCK_SUPERCONTEXT (chain
);
19149 && (ranges_table
[attr
->dw_attr_val
.v
.val_offset
19150 / 2 / DWARF2_ADDR_SIZE
].num
19151 == BLOCK_NUMBER (superblock
))
19152 && BLOCK_FRAGMENT_CHAIN (superblock
))
19154 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
19155 / 2 / DWARF2_ADDR_SIZE
;
19156 unsigned long supercnt
= 0, thiscnt
= 0;
19157 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
19158 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
19161 gcc_checking_assert (ranges_table
[off
+ supercnt
].num
19162 == BLOCK_NUMBER (chain
));
19164 gcc_checking_assert (ranges_table
[off
+ supercnt
+ 1].num
== 0);
19165 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19166 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
19168 gcc_assert (supercnt
>= thiscnt
);
19169 add_AT_range_list (die
, DW_AT_ranges
,
19170 ((off
+ supercnt
- thiscnt
)
19171 * 2 * DWARF2_ADDR_SIZE
),
19176 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
), false);
19178 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19181 add_ranges (chain
);
19182 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
19189 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
19190 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19191 BLOCK_NUMBER (stmt
));
19192 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
19193 BLOCK_NUMBER (stmt
));
19194 add_AT_low_high_pc (die
, label
, label_high
, false);
19198 /* Generate a DIE for a lexical block. */
19201 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19203 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
19205 if (call_arg_locations
)
19207 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19208 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19209 block_map
[BLOCK_NUMBER (stmt
)] = stmt_die
;
19212 if (! BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
19213 add_high_low_attributes (stmt
, stmt_die
);
19215 decls_for_scope (stmt
, stmt_die
, depth
);
19218 /* Generate a DIE for an inlined subprogram. */
19221 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
19225 /* The instance of function that is effectively being inlined shall not
19227 gcc_assert (! BLOCK_ABSTRACT (stmt
));
19229 decl
= block_ultimate_origin (stmt
);
19231 /* Emit info for the abstract instance first, if we haven't yet. We
19232 must emit this even if the block is abstract, otherwise when we
19233 emit the block below (or elsewhere), we may end up trying to emit
19234 a die whose origin die hasn't been emitted, and crashing. */
19235 dwarf2out_abstract_function (decl
);
19237 if (! BLOCK_ABSTRACT (stmt
))
19239 dw_die_ref subr_die
19240 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
19242 if (call_arg_locations
)
19244 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19245 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19246 block_map
[BLOCK_NUMBER (stmt
)] = subr_die
;
19248 add_abstract_origin_attribute (subr_die
, decl
);
19249 if (TREE_ASM_WRITTEN (stmt
))
19250 add_high_low_attributes (stmt
, subr_die
);
19251 add_call_src_coords_attributes (stmt
, subr_die
);
19253 decls_for_scope (stmt
, subr_die
, depth
);
19254 current_function_has_inlines
= 1;
19258 /* Generate a DIE for a field in a record, or structure. */
19261 gen_field_die (tree decl
, dw_die_ref context_die
)
19263 dw_die_ref decl_die
;
19265 if (TREE_TYPE (decl
) == error_mark_node
)
19268 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
19269 add_name_and_src_coords_attributes (decl_die
, decl
);
19270 add_type_attribute (decl_die
, member_declared_type (decl
),
19271 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
19274 if (DECL_BIT_FIELD_TYPE (decl
))
19276 add_byte_size_attribute (decl_die
, decl
);
19277 add_bit_size_attribute (decl_die
, decl
);
19278 add_bit_offset_attribute (decl_die
, decl
);
19281 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
19282 add_data_member_location_attribute (decl_die
, decl
);
19284 if (DECL_ARTIFICIAL (decl
))
19285 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
19287 add_accessibility_attribute (decl_die
, decl
);
19289 /* Equate decl number to die, so that we can look up this decl later on. */
19290 equate_decl_number_to_die (decl
, decl_die
);
19294 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19295 Use modified_type_die instead.
19296 We keep this code here just in case these types of DIEs may be needed to
19297 represent certain things in other languages (e.g. Pascal) someday. */
19300 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
19303 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
19305 equate_type_number_to_die (type
, ptr_die
);
19306 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19307 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19310 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19311 Use modified_type_die instead.
19312 We keep this code here just in case these types of DIEs may be needed to
19313 represent certain things in other languages (e.g. Pascal) someday. */
19316 gen_reference_type_die (tree type
, dw_die_ref context_die
)
19318 dw_die_ref ref_die
, scope_die
= scope_die_for (type
, context_die
);
19320 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
19321 ref_die
= new_die (DW_TAG_rvalue_reference_type
, scope_die
, type
);
19323 ref_die
= new_die (DW_TAG_reference_type
, scope_die
, type
);
19325 equate_type_number_to_die (type
, ref_die
);
19326 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
19327 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19331 /* Generate a DIE for a pointer to a member type. */
19334 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
19337 = new_die (DW_TAG_ptr_to_member_type
,
19338 scope_die_for (type
, context_die
), type
);
19340 equate_type_number_to_die (type
, ptr_die
);
19341 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
19342 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
19343 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19346 typedef const char *dchar_p
; /* For DEF_VEC_P. */
19348 static char *producer_string
;
19350 /* Return a heap allocated producer string including command line options
19351 if -grecord-gcc-switches. */
19354 gen_producer_string (void)
19357 auto_vec
<dchar_p
> switches
;
19358 const char *language_string
= lang_hooks
.name
;
19359 char *producer
, *tail
;
19361 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
19362 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
19364 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
19365 switch (save_decoded_options
[j
].opt_index
)
19372 case OPT_auxbase_strip
:
19381 case OPT_SPECIAL_unknown
:
19382 case OPT_SPECIAL_ignore
:
19383 case OPT_SPECIAL_program_name
:
19384 case OPT_SPECIAL_input_file
:
19385 case OPT_grecord_gcc_switches
:
19386 case OPT_gno_record_gcc_switches
:
19387 case OPT__output_pch_
:
19388 case OPT_fdiagnostics_show_location_
:
19389 case OPT_fdiagnostics_show_option
:
19390 case OPT_fdiagnostics_show_caret
:
19391 case OPT_fdiagnostics_color_
:
19392 case OPT_fverbose_asm
:
19394 case OPT__sysroot_
:
19396 case OPT_nostdinc__
:
19397 /* Ignore these. */
19400 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
19401 & CL_NO_DWARF_RECORD
)
19403 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
19405 switch (save_decoded_options
[j
].canonical_option
[0][1])
19412 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
19419 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
19420 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
19424 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
19426 sprintf (tail
, "%s %s", language_string
, version_string
);
19429 FOR_EACH_VEC_ELT (switches
, j
, p
)
19433 memcpy (tail
+ 1, p
, len
);
19441 /* Generate the DIE for the compilation unit. */
19444 gen_compile_unit_die (const char *filename
)
19447 const char *language_string
= lang_hooks
.name
;
19450 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
19454 add_name_attribute (die
, filename
);
19455 /* Don't add cwd for <built-in>. */
19456 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
19457 add_comp_dir_attribute (die
);
19460 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
19462 /* If our producer is LTO try to figure out a common language to use
19463 from the global list of translation units. */
19464 if (strcmp (language_string
, "GNU GIMPLE") == 0)
19468 const char *common_lang
= NULL
;
19470 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
19472 if (!TRANSLATION_UNIT_LANGUAGE (t
))
19475 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
19476 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
19478 else if (strncmp (common_lang
, "GNU C", 5) == 0
19479 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
19480 /* Mixing C and C++ is ok, use C++ in that case. */
19481 common_lang
= "GNU C++";
19484 /* Fall back to C. */
19485 common_lang
= NULL
;
19491 language_string
= common_lang
;
19494 language
= DW_LANG_C89
;
19495 if (strcmp (language_string
, "GNU C++") == 0)
19496 language
= DW_LANG_C_plus_plus
;
19497 else if (strcmp (language_string
, "GNU F77") == 0)
19498 language
= DW_LANG_Fortran77
;
19499 else if (strcmp (language_string
, "GNU Pascal") == 0)
19500 language
= DW_LANG_Pascal83
;
19501 else if (dwarf_version
>= 3 || !dwarf_strict
)
19503 if (strcmp (language_string
, "GNU Ada") == 0)
19504 language
= DW_LANG_Ada95
;
19505 else if (strcmp (language_string
, "GNU Fortran") == 0)
19506 language
= DW_LANG_Fortran95
;
19507 else if (strcmp (language_string
, "GNU Java") == 0)
19508 language
= DW_LANG_Java
;
19509 else if (strcmp (language_string
, "GNU Objective-C") == 0)
19510 language
= DW_LANG_ObjC
;
19511 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
19512 language
= DW_LANG_ObjC_plus_plus
;
19513 else if (dwarf_version
>= 5 || !dwarf_strict
)
19515 if (strcmp (language_string
, "GNU Go") == 0)
19516 language
= DW_LANG_Go
;
19519 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
19520 else if (strcmp (language_string
, "GNU Fortran") == 0)
19521 language
= DW_LANG_Fortran90
;
19523 add_AT_unsigned (die
, DW_AT_language
, language
);
19527 case DW_LANG_Fortran77
:
19528 case DW_LANG_Fortran90
:
19529 case DW_LANG_Fortran95
:
19530 /* Fortran has case insensitive identifiers and the front-end
19531 lowercases everything. */
19532 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
19535 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19541 /* Generate the DIE for a base class. */
19544 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
19546 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
19548 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
19549 add_data_member_location_attribute (die
, binfo
);
19551 if (BINFO_VIRTUAL_P (binfo
))
19552 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
19554 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19555 children, otherwise the default is DW_ACCESS_public. In DWARF2
19556 the default has always been DW_ACCESS_private. */
19557 if (access
== access_public_node
)
19559 if (dwarf_version
== 2
19560 || context_die
->die_tag
== DW_TAG_class_type
)
19561 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19563 else if (access
== access_protected_node
)
19564 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19565 else if (dwarf_version
> 2
19566 && context_die
->die_tag
!= DW_TAG_class_type
)
19567 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19570 /* Generate a DIE for a class member. */
19573 gen_member_die (tree type
, dw_die_ref context_die
)
19576 tree binfo
= TYPE_BINFO (type
);
19579 /* If this is not an incomplete type, output descriptions of each of its
19580 members. Note that as we output the DIEs necessary to represent the
19581 members of this record or union type, we will also be trying to output
19582 DIEs to represent the *types* of those members. However the `type'
19583 function (above) will specifically avoid generating type DIEs for member
19584 types *within* the list of member DIEs for this (containing) type except
19585 for those types (of members) which are explicitly marked as also being
19586 members of this (containing) type themselves. The g++ front- end can
19587 force any given type to be treated as a member of some other (containing)
19588 type by setting the TYPE_CONTEXT of the given (member) type to point to
19589 the TREE node representing the appropriate (containing) type. */
19591 /* First output info about the base classes. */
19594 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
19598 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
19599 gen_inheritance_die (base
,
19600 (accesses
? (*accesses
)[i
] : access_public_node
),
19604 /* Now output info about the data members and type members. */
19605 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
19607 /* If we thought we were generating minimal debug info for TYPE
19608 and then changed our minds, some of the member declarations
19609 may have already been defined. Don't define them again, but
19610 do put them in the right order. */
19612 child
= lookup_decl_die (member
);
19614 splice_child_die (context_die
, child
);
19616 gen_decl_die (member
, NULL
, context_die
);
19619 /* Now output info about the function members (if any). */
19620 for (member
= TYPE_METHODS (type
); member
; member
= DECL_CHAIN (member
))
19622 /* Don't include clones in the member list. */
19623 if (DECL_ABSTRACT_ORIGIN (member
))
19626 child
= lookup_decl_die (member
);
19628 splice_child_die (context_die
, child
);
19630 gen_decl_die (member
, NULL
, context_die
);
19634 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19635 is set, we pretend that the type was never defined, so we only get the
19636 member DIEs needed by later specification DIEs. */
19639 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
19640 enum debug_info_usage usage
)
19642 dw_die_ref type_die
= lookup_type_die (type
);
19643 dw_die_ref scope_die
= 0;
19645 int complete
= (TYPE_SIZE (type
)
19646 && (! TYPE_STUB_DECL (type
)
19647 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
19648 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
19649 complete
= complete
&& should_emit_struct_debug (type
, usage
);
19651 if (type_die
&& ! complete
)
19654 if (TYPE_CONTEXT (type
) != NULL_TREE
19655 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19656 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
19659 scope_die
= scope_die_for (type
, context_die
);
19661 /* Generate child dies for template paramaters. */
19662 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
19663 schedule_generic_params_dies_gen (type
);
19665 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
19666 /* First occurrence of type or toplevel definition of nested class. */
19668 dw_die_ref old_die
= type_die
;
19670 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
19671 ? record_type_tag (type
) : DW_TAG_union_type
,
19673 equate_type_number_to_die (type
, type_die
);
19675 add_AT_specification (type_die
, old_die
);
19677 add_name_attribute (type_die
, type_tag (type
));
19680 remove_AT (type_die
, DW_AT_declaration
);
19682 /* If this type has been completed, then give it a byte_size attribute and
19683 then give a list of members. */
19684 if (complete
&& !ns_decl
)
19686 /* Prevent infinite recursion in cases where the type of some member of
19687 this type is expressed in terms of this type itself. */
19688 TREE_ASM_WRITTEN (type
) = 1;
19689 add_byte_size_attribute (type_die
, type
);
19690 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
19692 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
19693 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
19696 /* If the first reference to this type was as the return type of an
19697 inline function, then it may not have a parent. Fix this now. */
19698 if (type_die
->die_parent
== NULL
)
19699 add_child_die (scope_die
, type_die
);
19701 push_decl_scope (type
);
19702 gen_member_die (type
, type_die
);
19705 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
19706 if (TYPE_ARTIFICIAL (type
))
19707 add_AT_flag (type_die
, DW_AT_artificial
, 1);
19709 /* GNU extension: Record what type our vtable lives in. */
19710 if (TYPE_VFIELD (type
))
19712 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
19714 gen_type_die (vtype
, context_die
);
19715 add_AT_die_ref (type_die
, DW_AT_containing_type
,
19716 lookup_type_die (vtype
));
19721 add_AT_flag (type_die
, DW_AT_declaration
, 1);
19723 /* We don't need to do this for function-local types. */
19724 if (TYPE_STUB_DECL (type
)
19725 && ! decl_function_context (TYPE_STUB_DECL (type
)))
19726 vec_safe_push (incomplete_types
, type
);
19729 if (get_AT (type_die
, DW_AT_name
))
19730 add_pubtype (type
, type_die
);
19733 /* Generate a DIE for a subroutine _type_. */
19736 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
19738 tree return_type
= TREE_TYPE (type
);
19739 dw_die_ref subr_die
19740 = new_die (DW_TAG_subroutine_type
,
19741 scope_die_for (type
, context_die
), type
);
19743 equate_type_number_to_die (type
, subr_die
);
19744 add_prototyped_attribute (subr_die
, type
);
19745 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
19746 gen_formal_types_die (type
, subr_die
);
19748 if (get_AT (subr_die
, DW_AT_name
))
19749 add_pubtype (type
, subr_die
);
19752 /* Generate a DIE for a type definition. */
19755 gen_typedef_die (tree decl
, dw_die_ref context_die
)
19757 dw_die_ref type_die
;
19760 if (TREE_ASM_WRITTEN (decl
))
19763 TREE_ASM_WRITTEN (decl
) = 1;
19764 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
19765 origin
= decl_ultimate_origin (decl
);
19766 if (origin
!= NULL
)
19767 add_abstract_origin_attribute (type_die
, origin
);
19772 add_name_and_src_coords_attributes (type_die
, decl
);
19773 if (DECL_ORIGINAL_TYPE (decl
))
19775 type
= DECL_ORIGINAL_TYPE (decl
);
19777 gcc_assert (type
!= TREE_TYPE (decl
));
19778 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
19782 type
= TREE_TYPE (decl
);
19784 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19786 /* Here, we are in the case of decl being a typedef naming
19787 an anonymous type, e.g:
19788 typedef struct {...} foo;
19789 In that case TREE_TYPE (decl) is not a typedef variant
19790 type and TYPE_NAME of the anonymous type is set to the
19791 TYPE_DECL of the typedef. This construct is emitted by
19794 TYPE is the anonymous struct named by the typedef
19795 DECL. As we need the DW_AT_type attribute of the
19796 DW_TAG_typedef to point to the DIE of TYPE, let's
19797 generate that DIE right away. add_type_attribute
19798 called below will then pick (via lookup_type_die) that
19799 anonymous struct DIE. */
19800 if (!TREE_ASM_WRITTEN (type
))
19801 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
19803 /* This is a GNU Extension. We are adding a
19804 DW_AT_linkage_name attribute to the DIE of the
19805 anonymous struct TYPE. The value of that attribute
19806 is the name of the typedef decl naming the anonymous
19807 struct. This greatly eases the work of consumers of
19808 this debug info. */
19809 add_linkage_attr (lookup_type_die (type
), decl
);
19813 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
19814 TREE_THIS_VOLATILE (decl
), context_die
);
19816 if (is_naming_typedef_decl (decl
))
19817 /* We want that all subsequent calls to lookup_type_die with
19818 TYPE in argument yield the DW_TAG_typedef we have just
19820 equate_type_number_to_die (type
, type_die
);
19822 add_accessibility_attribute (type_die
, decl
);
19825 if (DECL_ABSTRACT (decl
))
19826 equate_decl_number_to_die (decl
, type_die
);
19828 if (get_AT (type_die
, DW_AT_name
))
19829 add_pubtype (decl
, type_die
);
19832 /* Generate a DIE for a struct, class, enum or union type. */
19835 gen_tagged_type_die (tree type
,
19836 dw_die_ref context_die
,
19837 enum debug_info_usage usage
)
19841 if (type
== NULL_TREE
19842 || !is_tagged_type (type
))
19845 /* If this is a nested type whose containing class hasn't been written
19846 out yet, writing it out will cover this one, too. This does not apply
19847 to instantiations of member class templates; they need to be added to
19848 the containing class as they are generated. FIXME: This hurts the
19849 idea of combining type decls from multiple TUs, since we can't predict
19850 what set of template instantiations we'll get. */
19851 if (TYPE_CONTEXT (type
)
19852 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19853 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
19855 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
19857 if (TREE_ASM_WRITTEN (type
))
19860 /* If that failed, attach ourselves to the stub. */
19861 push_decl_scope (TYPE_CONTEXT (type
));
19862 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
19865 else if (TYPE_CONTEXT (type
) != NULL_TREE
19866 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
19868 /* If this type is local to a function that hasn't been written
19869 out yet, use a NULL context for now; it will be fixed up in
19870 decls_for_scope. */
19871 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
19872 /* A declaration DIE doesn't count; nested types need to go in the
19874 if (context_die
&& is_declaration_die (context_die
))
19875 context_die
= NULL
;
19880 context_die
= declare_in_namespace (type
, context_die
);
19884 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
19886 /* This might have been written out by the call to
19887 declare_in_namespace. */
19888 if (!TREE_ASM_WRITTEN (type
))
19889 gen_enumeration_type_die (type
, context_die
);
19892 gen_struct_or_union_type_die (type
, context_die
, usage
);
19897 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
19898 it up if it is ever completed. gen_*_type_die will set it for us
19899 when appropriate. */
19902 /* Generate a type description DIE. */
19905 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
19906 enum debug_info_usage usage
)
19908 struct array_descr_info info
;
19910 if (type
== NULL_TREE
|| type
== error_mark_node
)
19913 if (TYPE_NAME (type
) != NULL_TREE
19914 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
19915 && is_redundant_typedef (TYPE_NAME (type
))
19916 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
19917 /* The DECL of this type is a typedef we don't want to emit debug
19918 info for but we want debug info for its underlying typedef.
19919 This can happen for e.g, the injected-class-name of a C++
19921 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
19923 /* If TYPE is a typedef type variant, let's generate debug info
19924 for the parent typedef which TYPE is a type of. */
19925 if (typedef_variant_p (type
))
19927 if (TREE_ASM_WRITTEN (type
))
19930 /* Prevent broken recursion; we can't hand off to the same type. */
19931 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
19933 /* Give typedefs the right scope. */
19934 context_die
= scope_die_for (type
, context_die
);
19936 TREE_ASM_WRITTEN (type
) = 1;
19938 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19942 /* If type is an anonymous tagged type named by a typedef, let's
19943 generate debug info for the typedef. */
19944 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19946 /* Use the DIE of the containing namespace as the parent DIE of
19947 the type description DIE we want to generate. */
19948 if (DECL_CONTEXT (TYPE_NAME (type
))
19949 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
19950 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
19952 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19956 /* If this is an array type with hidden descriptor, handle it first. */
19957 if (!TREE_ASM_WRITTEN (type
)
19958 && lang_hooks
.types
.get_array_descr_info
19959 && lang_hooks
.types
.get_array_descr_info (type
, &info
)
19960 && (dwarf_version
>= 3 || !dwarf_strict
))
19962 gen_descr_array_type_die (type
, &info
, context_die
);
19963 TREE_ASM_WRITTEN (type
) = 1;
19967 /* We are going to output a DIE to represent the unqualified version
19968 of this type (i.e. without any const or volatile qualifiers) so
19969 get the main variant (i.e. the unqualified version) of this type
19970 now. (Vectors are special because the debugging info is in the
19971 cloned type itself). */
19972 if (TREE_CODE (type
) != VECTOR_TYPE
)
19973 type
= type_main_variant (type
);
19975 if (TREE_ASM_WRITTEN (type
))
19978 switch (TREE_CODE (type
))
19984 case REFERENCE_TYPE
:
19985 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
19986 ensures that the gen_type_die recursion will terminate even if the
19987 type is recursive. Recursive types are possible in Ada. */
19988 /* ??? We could perhaps do this for all types before the switch
19990 TREE_ASM_WRITTEN (type
) = 1;
19992 /* For these types, all that is required is that we output a DIE (or a
19993 set of DIEs) to represent the "basis" type. */
19994 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19995 DINFO_USAGE_IND_USE
);
19999 /* This code is used for C++ pointer-to-data-member types.
20000 Output a description of the relevant class type. */
20001 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
20002 DINFO_USAGE_IND_USE
);
20004 /* Output a description of the type of the object pointed to. */
20005 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20006 DINFO_USAGE_IND_USE
);
20008 /* Now output a DIE to represent this pointer-to-data-member type
20010 gen_ptr_to_mbr_type_die (type
, context_die
);
20013 case FUNCTION_TYPE
:
20014 /* Force out return type (in case it wasn't forced out already). */
20015 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20016 DINFO_USAGE_DIR_USE
);
20017 gen_subroutine_type_die (type
, context_die
);
20021 /* Force out return type (in case it wasn't forced out already). */
20022 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20023 DINFO_USAGE_DIR_USE
);
20024 gen_subroutine_type_die (type
, context_die
);
20028 gen_array_type_die (type
, context_die
);
20032 gen_array_type_die (type
, context_die
);
20035 case ENUMERAL_TYPE
:
20038 case QUAL_UNION_TYPE
:
20039 gen_tagged_type_die (type
, context_die
, usage
);
20045 case FIXED_POINT_TYPE
:
20048 /* No DIEs needed for fundamental types. */
20053 /* Just use DW_TAG_unspecified_type. */
20055 dw_die_ref type_die
= lookup_type_die (type
);
20056 if (type_die
== NULL
)
20058 tree name
= TYPE_IDENTIFIER (type
);
20059 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
20061 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
20062 equate_type_number_to_die (type
, type_die
);
20068 if (is_cxx_auto (type
))
20070 tree name
= TYPE_IDENTIFIER (type
);
20071 dw_die_ref
*die
= (name
== get_identifier ("auto")
20072 ? &auto_die
: &decltype_auto_die
);
20075 *die
= new_die (DW_TAG_unspecified_type
,
20076 comp_unit_die (), NULL_TREE
);
20077 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
20079 equate_type_number_to_die (type
, *die
);
20082 gcc_unreachable ();
20085 TREE_ASM_WRITTEN (type
) = 1;
20089 gen_type_die (tree type
, dw_die_ref context_die
)
20091 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
20094 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
20095 things which are local to the given block. */
20098 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
20100 int must_output_die
= 0;
20103 /* Ignore blocks that are NULL. */
20104 if (stmt
== NULL_TREE
)
20107 inlined_func
= inlined_function_outer_scope_p (stmt
);
20109 /* If the block is one fragment of a non-contiguous block, do not
20110 process the variables, since they will have been done by the
20111 origin block. Do process subblocks. */
20112 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
20116 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
20117 gen_block_die (sub
, context_die
, depth
+ 1);
20122 /* Determine if we need to output any Dwarf DIEs at all to represent this
20125 /* The outer scopes for inlinings *must* always be represented. We
20126 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20127 must_output_die
= 1;
20130 /* Determine if this block directly contains any "significant"
20131 local declarations which we will need to output DIEs for. */
20132 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20133 /* We are not in terse mode so *any* local declaration counts
20134 as being a "significant" one. */
20135 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
20136 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
20137 && (TREE_USED (stmt
)
20138 || TREE_ASM_WRITTEN (stmt
)
20139 || BLOCK_ABSTRACT (stmt
)));
20140 else if ((TREE_USED (stmt
)
20141 || TREE_ASM_WRITTEN (stmt
)
20142 || BLOCK_ABSTRACT (stmt
))
20143 && !dwarf2out_ignore_block (stmt
))
20144 must_output_die
= 1;
20147 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20148 DIE for any block which contains no significant local declarations at
20149 all. Rather, in such cases we just call `decls_for_scope' so that any
20150 needed Dwarf info for any sub-blocks will get properly generated. Note
20151 that in terse mode, our definition of what constitutes a "significant"
20152 local declaration gets restricted to include only inlined function
20153 instances and local (nested) function definitions. */
20154 if (must_output_die
)
20158 /* If STMT block is abstract, that means we have been called
20159 indirectly from dwarf2out_abstract_function.
20160 That function rightfully marks the descendent blocks (of
20161 the abstract function it is dealing with) as being abstract,
20162 precisely to prevent us from emitting any
20163 DW_TAG_inlined_subroutine DIE as a descendent
20164 of an abstract function instance. So in that case, we should
20165 not call gen_inlined_subroutine_die.
20167 Later though, when cgraph asks dwarf2out to emit info
20168 for the concrete instance of the function decl into which
20169 the concrete instance of STMT got inlined, the later will lead
20170 to the generation of a DW_TAG_inlined_subroutine DIE. */
20171 if (! BLOCK_ABSTRACT (stmt
))
20172 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
20175 gen_lexical_block_die (stmt
, context_die
, depth
);
20178 decls_for_scope (stmt
, context_die
, depth
);
20181 /* Process variable DECL (or variable with origin ORIGIN) within
20182 block STMT and add it to CONTEXT_DIE. */
20184 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
20187 tree decl_or_origin
= decl
? decl
: origin
;
20189 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
20190 die
= lookup_decl_die (decl_or_origin
);
20191 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
20192 && TYPE_DECL_IS_STUB (decl_or_origin
))
20193 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
20197 if (die
!= NULL
&& die
->die_parent
== NULL
)
20198 add_child_die (context_die
, die
);
20199 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
20200 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
20201 stmt
, context_die
);
20203 gen_decl_die (decl
, origin
, context_die
);
20206 /* Generate all of the decls declared within a given scope and (recursively)
20207 all of its sub-blocks. */
20210 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
20216 /* Ignore NULL blocks. */
20217 if (stmt
== NULL_TREE
)
20220 /* Output the DIEs to represent all of the data objects and typedefs
20221 declared directly within this block but not within any nested
20222 sub-blocks. Also, nested function and tag DIEs have been
20223 generated with a parent of NULL; fix that up now. We don't
20224 have to do this if we're at -g1. */
20225 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20227 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
20228 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
20229 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
20230 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
20234 /* Even if we're at -g1, we need to process the subblocks in order to get
20235 inlined call information. */
20237 /* Output the DIEs to represent all sub-blocks (and the items declared
20238 therein) of this block. */
20239 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
20241 subblocks
= BLOCK_CHAIN (subblocks
))
20242 gen_block_die (subblocks
, context_die
, depth
+ 1);
20245 /* Is this a typedef we can avoid emitting? */
20248 is_redundant_typedef (const_tree decl
)
20250 if (TYPE_DECL_IS_STUB (decl
))
20253 if (DECL_ARTIFICIAL (decl
)
20254 && DECL_CONTEXT (decl
)
20255 && is_tagged_type (DECL_CONTEXT (decl
))
20256 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
20257 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
20258 /* Also ignore the artificial member typedef for the class name. */
20264 /* Return TRUE if TYPE is a typedef that names a type for linkage
20265 purposes. This kind of typedefs is produced by the C++ FE for
20268 typedef struct {...} foo;
20270 In that case, there is no typedef variant type produced for foo.
20271 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20275 is_naming_typedef_decl (const_tree decl
)
20277 if (decl
== NULL_TREE
20278 || TREE_CODE (decl
) != TYPE_DECL
20279 || !is_tagged_type (TREE_TYPE (decl
))
20280 || DECL_IS_BUILTIN (decl
)
20281 || is_redundant_typedef (decl
)
20282 /* It looks like Ada produces TYPE_DECLs that are very similar
20283 to C++ naming typedefs but that have different
20284 semantics. Let's be specific to c++ for now. */
20288 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
20289 && TYPE_NAME (TREE_TYPE (decl
)) == decl
20290 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
20291 != TYPE_NAME (TREE_TYPE (decl
))));
20294 /* Returns the DIE for a context. */
20296 static inline dw_die_ref
20297 get_context_die (tree context
)
20301 /* Find die that represents this context. */
20302 if (TYPE_P (context
))
20304 context
= TYPE_MAIN_VARIANT (context
);
20305 return strip_naming_typedef (context
, force_type_die (context
));
20308 return force_decl_die (context
);
20310 return comp_unit_die ();
20313 /* Returns the DIE for decl. A DIE will always be returned. */
20316 force_decl_die (tree decl
)
20318 dw_die_ref decl_die
;
20319 unsigned saved_external_flag
;
20320 tree save_fn
= NULL_TREE
;
20321 decl_die
= lookup_decl_die (decl
);
20324 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
20326 decl_die
= lookup_decl_die (decl
);
20330 switch (TREE_CODE (decl
))
20332 case FUNCTION_DECL
:
20333 /* Clear current_function_decl, so that gen_subprogram_die thinks
20334 that this is a declaration. At this point, we just want to force
20335 declaration die. */
20336 save_fn
= current_function_decl
;
20337 current_function_decl
= NULL_TREE
;
20338 gen_subprogram_die (decl
, context_die
);
20339 current_function_decl
= save_fn
;
20343 /* Set external flag to force declaration die. Restore it after
20344 gen_decl_die() call. */
20345 saved_external_flag
= DECL_EXTERNAL (decl
);
20346 DECL_EXTERNAL (decl
) = 1;
20347 gen_decl_die (decl
, NULL
, context_die
);
20348 DECL_EXTERNAL (decl
) = saved_external_flag
;
20351 case NAMESPACE_DECL
:
20352 if (dwarf_version
>= 3 || !dwarf_strict
)
20353 dwarf2out_decl (decl
);
20355 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20356 decl_die
= comp_unit_die ();
20359 case TRANSLATION_UNIT_DECL
:
20360 decl_die
= comp_unit_die ();
20364 gcc_unreachable ();
20367 /* We should be able to find the DIE now. */
20369 decl_die
= lookup_decl_die (decl
);
20370 gcc_assert (decl_die
);
20376 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20377 always returned. */
20380 force_type_die (tree type
)
20382 dw_die_ref type_die
;
20384 type_die
= lookup_type_die (type
);
20387 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
20389 type_die
= modified_type_die (type
, TYPE_READONLY (type
),
20390 TYPE_VOLATILE (type
), context_die
);
20391 gcc_assert (type_die
);
20396 /* Force out any required namespaces to be able to output DECL,
20397 and return the new context_die for it, if it's changed. */
20400 setup_namespace_context (tree thing
, dw_die_ref context_die
)
20402 tree context
= (DECL_P (thing
)
20403 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
20404 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
20405 /* Force out the namespace. */
20406 context_die
= force_decl_die (context
);
20408 return context_die
;
20411 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20412 type) within its namespace, if appropriate.
20414 For compatibility with older debuggers, namespace DIEs only contain
20415 declarations; all definitions are emitted at CU scope. */
20418 declare_in_namespace (tree thing
, dw_die_ref context_die
)
20420 dw_die_ref ns_context
;
20422 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20423 return context_die
;
20425 /* If this decl is from an inlined function, then don't try to emit it in its
20426 namespace, as we will get confused. It would have already been emitted
20427 when the abstract instance of the inline function was emitted anyways. */
20428 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
20429 return context_die
;
20431 ns_context
= setup_namespace_context (thing
, context_die
);
20433 if (ns_context
!= context_die
)
20437 if (DECL_P (thing
))
20438 gen_decl_die (thing
, NULL
, ns_context
);
20440 gen_type_die (thing
, ns_context
);
20442 return context_die
;
20445 /* Generate a DIE for a namespace or namespace alias. */
20448 gen_namespace_die (tree decl
, dw_die_ref context_die
)
20450 dw_die_ref namespace_die
;
20452 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20453 they are an alias of. */
20454 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
20456 /* Output a real namespace or module. */
20457 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20458 namespace_die
= new_die (is_fortran ()
20459 ? DW_TAG_module
: DW_TAG_namespace
,
20460 context_die
, decl
);
20461 /* For Fortran modules defined in different CU don't add src coords. */
20462 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
20464 const char *name
= dwarf2_name (decl
, 0);
20466 add_name_attribute (namespace_die
, name
);
20469 add_name_and_src_coords_attributes (namespace_die
, decl
);
20470 if (DECL_EXTERNAL (decl
))
20471 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
20472 equate_decl_number_to_die (decl
, namespace_die
);
20476 /* Output a namespace alias. */
20478 /* Force out the namespace we are an alias of, if necessary. */
20479 dw_die_ref origin_die
20480 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
20482 if (DECL_FILE_SCOPE_P (decl
)
20483 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
20484 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20485 /* Now create the namespace alias DIE. */
20486 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
20487 add_name_and_src_coords_attributes (namespace_die
, decl
);
20488 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
20489 equate_decl_number_to_die (decl
, namespace_die
);
20491 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
20492 if (want_pubnames ())
20493 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
20496 /* Generate Dwarf debug information for a decl described by DECL.
20497 The return value is currently only meaningful for PARM_DECLs,
20498 for all other decls it returns NULL. */
20501 gen_decl_die (tree decl
, tree origin
, dw_die_ref context_die
)
20503 tree decl_or_origin
= decl
? decl
: origin
;
20504 tree class_origin
= NULL
, ultimate_origin
;
20506 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
20509 switch (TREE_CODE (decl_or_origin
))
20515 if (!is_fortran () && !is_ada ())
20517 /* The individual enumerators of an enum type get output when we output
20518 the Dwarf representation of the relevant enum type itself. */
20522 /* Emit its type. */
20523 gen_type_die (TREE_TYPE (decl
), context_die
);
20525 /* And its containing namespace. */
20526 context_die
= declare_in_namespace (decl
, context_die
);
20528 gen_const_die (decl
, context_die
);
20531 case FUNCTION_DECL
:
20532 /* Don't output any DIEs to represent mere function declarations,
20533 unless they are class members or explicit block externs. */
20534 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
20535 && DECL_FILE_SCOPE_P (decl_or_origin
)
20536 && (current_function_decl
== NULL_TREE
20537 || DECL_ARTIFICIAL (decl_or_origin
)))
20542 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20543 on local redeclarations of global functions. That seems broken. */
20544 if (current_function_decl
!= decl
)
20545 /* This is only a declaration. */;
20548 /* If we're emitting a clone, emit info for the abstract instance. */
20549 if (origin
|| DECL_ORIGIN (decl
) != decl
)
20550 dwarf2out_abstract_function (origin
20551 ? DECL_ORIGIN (origin
)
20552 : DECL_ABSTRACT_ORIGIN (decl
));
20554 /* If we're emitting an out-of-line copy of an inline function,
20555 emit info for the abstract instance and set up to refer to it. */
20556 else if (cgraph_function_possibly_inlined_p (decl
)
20557 && ! DECL_ABSTRACT (decl
)
20558 && ! class_or_namespace_scope_p (context_die
)
20559 /* dwarf2out_abstract_function won't emit a die if this is just
20560 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20561 that case, because that works only if we have a die. */
20562 && DECL_INITIAL (decl
) != NULL_TREE
)
20564 dwarf2out_abstract_function (decl
);
20565 set_decl_origin_self (decl
);
20568 /* Otherwise we're emitting the primary DIE for this decl. */
20569 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
20571 /* Before we describe the FUNCTION_DECL itself, make sure that we
20572 have its containing type. */
20574 origin
= decl_class_context (decl
);
20575 if (origin
!= NULL_TREE
)
20576 gen_type_die (origin
, context_die
);
20578 /* And its return type. */
20579 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
20581 /* And its virtual context. */
20582 if (DECL_VINDEX (decl
) != NULL_TREE
)
20583 gen_type_die (DECL_CONTEXT (decl
), context_die
);
20585 /* Make sure we have a member DIE for decl. */
20586 if (origin
!= NULL_TREE
)
20587 gen_type_die_for_member (origin
, decl
, context_die
);
20589 /* And its containing namespace. */
20590 context_die
= declare_in_namespace (decl
, context_die
);
20593 /* Now output a DIE to represent the function itself. */
20595 gen_subprogram_die (decl
, context_die
);
20599 /* If we are in terse mode, don't generate any DIEs to represent any
20600 actual typedefs. */
20601 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20604 /* In the special case of a TYPE_DECL node representing the declaration
20605 of some type tag, if the given TYPE_DECL is marked as having been
20606 instantiated from some other (original) TYPE_DECL node (e.g. one which
20607 was generated within the original definition of an inline function) we
20608 used to generate a special (abbreviated) DW_TAG_structure_type,
20609 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20610 should be actually referencing those DIEs, as variable DIEs with that
20611 type would be emitted already in the abstract origin, so it was always
20612 removed during unused type prunning. Don't add anything in this
20614 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
20617 if (is_redundant_typedef (decl
))
20618 gen_type_die (TREE_TYPE (decl
), context_die
);
20620 /* Output a DIE to represent the typedef itself. */
20621 gen_typedef_die (decl
, context_die
);
20625 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
20626 gen_label_die (decl
, context_die
);
20631 /* If we are in terse mode, don't generate any DIEs to represent any
20632 variable declarations or definitions. */
20633 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20636 /* Output any DIEs that are needed to specify the type of this data
20638 if (decl_by_reference_p (decl_or_origin
))
20639 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20641 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20643 /* And its containing type. */
20644 class_origin
= decl_class_context (decl_or_origin
);
20645 if (class_origin
!= NULL_TREE
)
20646 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
20648 /* And its containing namespace. */
20649 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
20651 /* Now output the DIE to represent the data object itself. This gets
20652 complicated because of the possibility that the VAR_DECL really
20653 represents an inlined instance of a formal parameter for an inline
20655 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
20656 if (ultimate_origin
!= NULL_TREE
20657 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
20658 gen_formal_parameter_die (decl
, origin
,
20659 true /* Emit name attribute. */,
20662 gen_variable_die (decl
, origin
, context_die
);
20666 /* Ignore the nameless fields that are used to skip bits but handle C++
20667 anonymous unions and structs. */
20668 if (DECL_NAME (decl
) != NULL_TREE
20669 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
20670 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
20672 gen_type_die (member_declared_type (decl
), context_die
);
20673 gen_field_die (decl
, context_die
);
20678 if (DECL_BY_REFERENCE (decl_or_origin
))
20679 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20681 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20682 return gen_formal_parameter_die (decl
, origin
,
20683 true /* Emit name attribute. */,
20686 case NAMESPACE_DECL
:
20687 case IMPORTED_DECL
:
20688 if (dwarf_version
>= 3 || !dwarf_strict
)
20689 gen_namespace_die (decl
, context_die
);
20692 case NAMELIST_DECL
:
20693 gen_namelist_decl (DECL_NAME (decl
), context_die
,
20694 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
20698 /* Probably some frontend-internal decl. Assume we don't care. */
20699 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
20706 /* Output debug information for global decl DECL. Called from toplev.c after
20707 compilation proper has finished. */
20710 dwarf2out_global_decl (tree decl
)
20712 /* Output DWARF2 information for file-scope tentative data object
20713 declarations, file-scope (extern) function declarations (which
20714 had no corresponding body) and file-scope tagged type declarations
20715 and definitions which have not yet been forced out. */
20716 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
20717 dwarf2out_decl (decl
);
20720 /* Output debug information for type decl DECL. Called from toplev.c
20721 and from language front ends (to record built-in types). */
20723 dwarf2out_type_decl (tree decl
, int local
)
20726 dwarf2out_decl (decl
);
20729 /* Output debug information for imported module or decl DECL.
20730 NAME is non-NULL name in the lexical block if the decl has been renamed.
20731 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
20732 that DECL belongs to.
20733 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
20735 dwarf2out_imported_module_or_decl_1 (tree decl
,
20737 tree lexical_block
,
20738 dw_die_ref lexical_block_die
)
20740 expanded_location xloc
;
20741 dw_die_ref imported_die
= NULL
;
20742 dw_die_ref at_import_die
;
20744 if (TREE_CODE (decl
) == IMPORTED_DECL
)
20746 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
20747 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
20751 xloc
= expand_location (input_location
);
20753 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
20755 at_import_die
= force_type_die (TREE_TYPE (decl
));
20756 /* For namespace N { typedef void T; } using N::T; base_type_die
20757 returns NULL, but DW_TAG_imported_declaration requires
20758 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
20759 if (!at_import_die
)
20761 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
20762 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
20763 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
20764 gcc_assert (at_import_die
);
20769 at_import_die
= lookup_decl_die (decl
);
20770 if (!at_import_die
)
20772 /* If we're trying to avoid duplicate debug info, we may not have
20773 emitted the member decl for this field. Emit it now. */
20774 if (TREE_CODE (decl
) == FIELD_DECL
)
20776 tree type
= DECL_CONTEXT (decl
);
20778 if (TYPE_CONTEXT (type
)
20779 && TYPE_P (TYPE_CONTEXT (type
))
20780 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
20781 DINFO_USAGE_DIR_USE
))
20783 gen_type_die_for_member (type
, decl
,
20784 get_context_die (TYPE_CONTEXT (type
)));
20786 if (TREE_CODE (decl
) == NAMELIST_DECL
)
20787 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
20788 get_context_die (DECL_CONTEXT (decl
)),
20791 at_import_die
= force_decl_die (decl
);
20795 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
20797 if (dwarf_version
>= 3 || !dwarf_strict
)
20798 imported_die
= new_die (DW_TAG_imported_module
,
20805 imported_die
= new_die (DW_TAG_imported_declaration
,
20809 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
20810 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
20812 add_AT_string (imported_die
, DW_AT_name
,
20813 IDENTIFIER_POINTER (name
));
20814 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
20817 /* Output debug information for imported module or decl DECL.
20818 NAME is non-NULL name in context if the decl has been renamed.
20819 CHILD is true if decl is one of the renamed decls as part of
20820 importing whole module. */
20823 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
20826 /* dw_die_ref at_import_die; */
20827 dw_die_ref scope_die
;
20829 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20834 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
20835 We need decl DIE for reference and scope die. First, get DIE for the decl
20838 /* Get the scope die for decl context. Use comp_unit_die for global module
20839 or decl. If die is not found for non globals, force new die. */
20841 && TYPE_P (context
)
20842 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
20845 if (!(dwarf_version
>= 3 || !dwarf_strict
))
20848 scope_die
= get_context_die (context
);
20852 gcc_assert (scope_die
->die_child
);
20853 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
20854 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
20855 scope_die
= scope_die
->die_child
;
20858 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
20859 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
20863 /* Output debug information for namelists. */
20866 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
20868 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
20872 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20875 gcc_assert (scope_die
!= NULL
);
20876 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
20877 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
20879 /* If there are no item_decls, we have a nondefining namelist, e.g.
20880 with USE association; hence, set DW_AT_declaration. */
20881 if (item_decls
== NULL_TREE
)
20883 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
20887 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
20889 nml_item_ref_die
= lookup_decl_die (value
);
20890 if (!nml_item_ref_die
)
20891 nml_item_ref_die
= force_decl_die (value
);
20893 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
20894 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
20900 /* Write the debugging output for DECL. */
20903 dwarf2out_decl (tree decl
)
20905 dw_die_ref context_die
= comp_unit_die ();
20907 switch (TREE_CODE (decl
))
20912 case FUNCTION_DECL
:
20913 /* What we would really like to do here is to filter out all mere
20914 file-scope declarations of file-scope functions which are never
20915 referenced later within this translation unit (and keep all of ones
20916 that *are* referenced later on) but we aren't clairvoyant, so we have
20917 no idea which functions will be referenced in the future (i.e. later
20918 on within the current translation unit). So here we just ignore all
20919 file-scope function declarations which are not also definitions. If
20920 and when the debugger needs to know something about these functions,
20921 it will have to hunt around and find the DWARF information associated
20922 with the definition of the function.
20924 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
20925 nodes represent definitions and which ones represent mere
20926 declarations. We have to check DECL_INITIAL instead. That's because
20927 the C front-end supports some weird semantics for "extern inline"
20928 function definitions. These can get inlined within the current
20929 translation unit (and thus, we need to generate Dwarf info for their
20930 abstract instances so that the Dwarf info for the concrete inlined
20931 instances can have something to refer to) but the compiler never
20932 generates any out-of-lines instances of such things (despite the fact
20933 that they *are* definitions).
20935 The important point is that the C front-end marks these "extern
20936 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
20937 them anyway. Note that the C++ front-end also plays some similar games
20938 for inline function definitions appearing within include files which
20939 also contain `#pragma interface' pragmas.
20941 If we are called from dwarf2out_abstract_function output a DIE
20942 anyway. We can end up here this way with early inlining and LTO
20943 where the inlined function is output in a different LTRANS unit
20945 if (DECL_INITIAL (decl
) == NULL_TREE
20946 && ! DECL_ABSTRACT (decl
))
20949 /* If we're a nested function, initially use a parent of NULL; if we're
20950 a plain function, this will be fixed up in decls_for_scope. If
20951 we're a method, it will be ignored, since we already have a DIE. */
20952 if (decl_function_context (decl
)
20953 /* But if we're in terse mode, we don't care about scope. */
20954 && debug_info_level
> DINFO_LEVEL_TERSE
)
20955 context_die
= NULL
;
20959 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
20960 declaration and if the declaration was never even referenced from
20961 within this entire compilation unit. We suppress these DIEs in
20962 order to save space in the .debug section (by eliminating entries
20963 which are probably useless). Note that we must not suppress
20964 block-local extern declarations (whether used or not) because that
20965 would screw-up the debugger's name lookup mechanism and cause it to
20966 miss things which really ought to be in scope at a given point. */
20967 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
20970 /* For local statics lookup proper context die. */
20971 if (TREE_STATIC (decl
)
20972 && DECL_CONTEXT (decl
)
20973 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
20974 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20976 /* If we are in terse mode, don't generate any DIEs to represent any
20977 variable declarations or definitions. */
20978 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20983 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20985 if (!is_fortran () && !is_ada ())
20987 if (TREE_STATIC (decl
) && decl_function_context (decl
))
20988 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20991 case NAMESPACE_DECL
:
20992 case IMPORTED_DECL
:
20993 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20995 if (lookup_decl_die (decl
) != NULL
)
21000 /* Don't emit stubs for types unless they are needed by other DIEs. */
21001 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
21004 /* Don't bother trying to generate any DIEs to represent any of the
21005 normal built-in types for the language we are compiling. */
21006 if (DECL_IS_BUILTIN (decl
))
21009 /* If we are in terse mode, don't generate any DIEs for types. */
21010 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
21013 /* If we're a function-scope tag, initially use a parent of NULL;
21014 this will be fixed up in decls_for_scope. */
21015 if (decl_function_context (decl
))
21016 context_die
= NULL
;
21020 case NAMELIST_DECL
:
21027 gen_decl_die (decl
, NULL
, context_die
);
21030 /* Write the debugging output for DECL. */
21033 dwarf2out_function_decl (tree decl
)
21035 dwarf2out_decl (decl
);
21036 call_arg_locations
= NULL
;
21037 call_arg_loc_last
= NULL
;
21038 call_site_count
= -1;
21039 tail_call_site_count
= -1;
21040 block_map
.release ();
21041 htab_empty (decl_loc_table
);
21042 htab_empty (cached_dw_loc_list_table
);
21045 /* Output a marker (i.e. a label) for the beginning of the generated code for
21046 a lexical block. */
21049 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
21050 unsigned int blocknum
)
21052 switch_to_section (current_function_section ());
21053 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
21056 /* Output a marker (i.e. a label) for the end of the generated code for a
21060 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
21062 switch_to_section (current_function_section ());
21063 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
21066 /* Returns nonzero if it is appropriate not to emit any debugging
21067 information for BLOCK, because it doesn't contain any instructions.
21069 Don't allow this for blocks with nested functions or local classes
21070 as we would end up with orphans, and in the presence of scheduling
21071 we may end up calling them anyway. */
21074 dwarf2out_ignore_block (const_tree block
)
21079 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
21080 if (TREE_CODE (decl
) == FUNCTION_DECL
21081 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
21083 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
21085 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
21086 if (TREE_CODE (decl
) == FUNCTION_DECL
21087 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
21094 /* Hash table routines for file_hash. */
21097 file_table_eq (const void *p1_p
, const void *p2_p
)
21099 const struct dwarf_file_data
*const p1
=
21100 (const struct dwarf_file_data
*) p1_p
;
21101 const char *const p2
= (const char *) p2_p
;
21102 return filename_cmp (p1
->filename
, p2
) == 0;
21106 file_table_hash (const void *p_p
)
21108 const struct dwarf_file_data
*const p
= (const struct dwarf_file_data
*) p_p
;
21109 return htab_hash_string (p
->filename
);
21112 /* Lookup FILE_NAME (in the list of filenames that we know about here in
21113 dwarf2out.c) and return its "index". The index of each (known) filename is
21114 just a unique number which is associated with only that one filename. We
21115 need such numbers for the sake of generating labels (in the .debug_sfnames
21116 section) and references to those files numbers (in the .debug_srcinfo
21117 and.debug_macinfo sections). If the filename given as an argument is not
21118 found in our current list, add it to the list and assign it the next
21119 available unique index number. In order to speed up searches, we remember
21120 the index of the filename was looked up last. This handles the majority of
21123 static struct dwarf_file_data
*
21124 lookup_filename (const char *file_name
)
21127 struct dwarf_file_data
* created
;
21129 /* Check to see if the file name that was searched on the previous
21130 call matches this file name. If so, return the index. */
21131 if (file_table_last_lookup
21132 && (file_name
== file_table_last_lookup
->filename
21133 || filename_cmp (file_table_last_lookup
->filename
, file_name
) == 0))
21134 return file_table_last_lookup
;
21136 /* Didn't match the previous lookup, search the table. */
21137 slot
= htab_find_slot_with_hash (file_table
, file_name
,
21138 htab_hash_string (file_name
), INSERT
);
21140 return (struct dwarf_file_data
*) *slot
;
21142 created
= ggc_alloc_dwarf_file_data ();
21143 created
->filename
= file_name
;
21144 created
->emitted_number
= 0;
21149 /* If the assembler will construct the file table, then translate the compiler
21150 internal file table number into the assembler file table number, and emit
21151 a .file directive if we haven't already emitted one yet. The file table
21152 numbers are different because we prune debug info for unused variables and
21153 types, which may include filenames. */
21156 maybe_emit_file (struct dwarf_file_data
* fd
)
21158 if (! fd
->emitted_number
)
21160 if (last_emitted_file
)
21161 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
21163 fd
->emitted_number
= 1;
21164 last_emitted_file
= fd
;
21166 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21168 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
21169 output_quoted_string (asm_out_file
,
21170 remap_debug_filename (fd
->filename
));
21171 fputc ('\n', asm_out_file
);
21175 return fd
->emitted_number
;
21178 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21179 That generation should happen after function debug info has been
21180 generated. The value of the attribute is the constant value of ARG. */
21183 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
21185 die_arg_entry entry
;
21190 if (!tmpl_value_parm_die_table
)
21191 vec_alloc (tmpl_value_parm_die_table
, 32);
21195 vec_safe_push (tmpl_value_parm_die_table
, entry
);
21198 /* Return TRUE if T is an instance of generic type, FALSE
21202 generic_type_p (tree t
)
21204 if (t
== NULL_TREE
|| !TYPE_P (t
))
21206 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
21209 /* Schedule the generation of the generic parameter dies for the
21210 instance of generic type T. The proper generation itself is later
21211 done by gen_scheduled_generic_parms_dies. */
21214 schedule_generic_params_dies_gen (tree t
)
21216 if (!generic_type_p (t
))
21219 if (!generic_type_instances
)
21220 vec_alloc (generic_type_instances
, 256);
21222 vec_safe_push (generic_type_instances
, t
);
21225 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21226 by append_entry_to_tmpl_value_parm_die_table. This function must
21227 be called after function DIEs have been generated. */
21230 gen_remaining_tmpl_value_param_die_attribute (void)
21232 if (tmpl_value_parm_die_table
)
21237 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
21238 tree_add_const_value_attribute (e
->die
, e
->arg
);
21242 /* Generate generic parameters DIEs for instances of generic types
21243 that have been previously scheduled by
21244 schedule_generic_params_dies_gen. This function must be called
21245 after all the types of the CU have been laid out. */
21248 gen_scheduled_generic_parms_dies (void)
21253 if (!generic_type_instances
)
21256 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
21257 if (COMPLETE_TYPE_P (t
))
21258 gen_generic_params_dies (t
);
21262 /* Replace DW_AT_name for the decl with name. */
21265 dwarf2out_set_name (tree decl
, tree name
)
21271 die
= TYPE_SYMTAB_DIE (decl
);
21275 dname
= dwarf2_name (name
, 0);
21279 attr
= get_AT (die
, DW_AT_name
);
21282 struct indirect_string_node
*node
;
21284 node
= find_AT_string (dname
);
21285 /* replace the string. */
21286 attr
->dw_attr_val
.v
.val_str
= node
;
21290 add_name_attribute (die
, dname
);
21293 /* True if before or during processing of the first function being emitted. */
21294 static bool in_first_function_p
= true;
21295 /* True if loc_note during dwarf2out_var_location call might still be
21296 before first real instruction at address equal to .Ltext0. */
21297 static bool maybe_at_text_label_p
= true;
21298 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
21299 static unsigned int first_loclabel_num_not_at_text_label
;
21301 /* Called by the final INSN scan whenever we see a var location. We
21302 use it to drop labels in the right places, and throw the location in
21303 our lookup table. */
21306 dwarf2out_var_location (rtx loc_note
)
21308 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
21309 struct var_loc_node
*newloc
;
21310 rtx next_real
, next_note
;
21311 static const char *last_label
;
21312 static const char *last_postcall_label
;
21313 static bool last_in_cold_section_p
;
21314 static rtx expected_next_loc_note
;
21318 if (!NOTE_P (loc_note
))
21320 if (CALL_P (loc_note
))
21323 if (SIBLING_CALL_P (loc_note
))
21324 tail_call_site_count
++;
21329 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
21330 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
21333 /* Optimize processing a large consecutive sequence of location
21334 notes so we don't spend too much time in next_real_insn. If the
21335 next insn is another location note, remember the next_real_insn
21336 calculation for next time. */
21337 next_real
= cached_next_real_insn
;
21340 if (expected_next_loc_note
!= loc_note
)
21341 next_real
= NULL_RTX
;
21344 next_note
= NEXT_INSN (loc_note
);
21346 || INSN_DELETED_P (next_note
)
21347 || ! NOTE_P (next_note
)
21348 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
21349 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
21350 next_note
= NULL_RTX
;
21353 next_real
= next_real_insn (loc_note
);
21357 expected_next_loc_note
= next_note
;
21358 cached_next_real_insn
= next_real
;
21361 cached_next_real_insn
= NULL_RTX
;
21363 /* If there are no instructions which would be affected by this note,
21364 don't do anything. */
21366 && next_real
== NULL_RTX
21367 && !NOTE_DURING_CALL_P (loc_note
))
21370 if (next_real
== NULL_RTX
)
21371 next_real
= get_last_insn ();
21373 /* If there were any real insns between note we processed last time
21374 and this note (or if it is the first note), clear
21375 last_{,postcall_}label so that they are not reused this time. */
21376 if (last_var_location_insn
== NULL_RTX
21377 || last_var_location_insn
!= next_real
21378 || last_in_cold_section_p
!= in_cold_section_p
)
21381 last_postcall_label
= NULL
;
21386 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
21387 newloc
= add_var_loc_to_decl (decl
, loc_note
,
21388 NOTE_DURING_CALL_P (loc_note
)
21389 ? last_postcall_label
: last_label
);
21390 if (newloc
== NULL
)
21399 /* If there were no real insns between note we processed last time
21400 and this note, use the label we emitted last time. Otherwise
21401 create a new label and emit it. */
21402 if (last_label
== NULL
)
21404 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
21405 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
21407 last_label
= ggc_strdup (loclabel
);
21408 /* See if loclabel might be equal to .Ltext0. If yes,
21409 bump first_loclabel_num_not_at_text_label. */
21410 if (!have_multiple_function_sections
21411 && in_first_function_p
21412 && maybe_at_text_label_p
)
21414 static rtx last_start
;
21416 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
21417 if (insn
== last_start
)
21419 else if (!NONDEBUG_INSN_P (insn
))
21423 rtx body
= PATTERN (insn
);
21424 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
21426 /* Inline asm could occupy zero bytes. */
21427 else if (GET_CODE (body
) == ASM_INPUT
21428 || asm_noperands (body
) >= 0)
21430 #ifdef HAVE_attr_length
21431 else if (get_attr_min_length (insn
) == 0)
21436 /* Assume insn has non-zero length. */
21437 maybe_at_text_label_p
= false;
21441 if (maybe_at_text_label_p
)
21443 last_start
= loc_note
;
21444 first_loclabel_num_not_at_text_label
= loclabel_num
;
21451 struct call_arg_loc_node
*ca_loc
21452 = ggc_alloc_cleared_call_arg_loc_node ();
21453 rtx prev
= prev_real_insn (loc_note
), x
;
21454 ca_loc
->call_arg_loc_note
= loc_note
;
21455 ca_loc
->next
= NULL
;
21456 ca_loc
->label
= last_label
;
21459 || (NONJUMP_INSN_P (prev
)
21460 && GET_CODE (PATTERN (prev
)) == SEQUENCE
21461 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
21462 if (!CALL_P (prev
))
21463 prev
= XVECEXP (PATTERN (prev
), 0, 0);
21464 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
21465 x
= get_call_rtx_from (PATTERN (prev
));
21468 x
= XEXP (XEXP (x
, 0), 0);
21469 if (GET_CODE (x
) == SYMBOL_REF
21470 && SYMBOL_REF_DECL (x
)
21471 && TREE_CODE (SYMBOL_REF_DECL (x
)) == FUNCTION_DECL
)
21472 ca_loc
->symbol_ref
= x
;
21474 ca_loc
->block
= insn_scope (prev
);
21475 if (call_arg_locations
)
21476 call_arg_loc_last
->next
= ca_loc
;
21478 call_arg_locations
= ca_loc
;
21479 call_arg_loc_last
= ca_loc
;
21481 else if (!NOTE_DURING_CALL_P (loc_note
))
21482 newloc
->label
= last_label
;
21485 if (!last_postcall_label
)
21487 sprintf (loclabel
, "%s-1", last_label
);
21488 last_postcall_label
= ggc_strdup (loclabel
);
21490 newloc
->label
= last_postcall_label
;
21493 last_var_location_insn
= next_real
;
21494 last_in_cold_section_p
= in_cold_section_p
;
21497 /* Note in one location list that text section has changed. */
21500 var_location_switch_text_section_1 (void **slot
, void *data ATTRIBUTE_UNUSED
)
21502 var_loc_list
*list
= (var_loc_list
*) *slot
;
21504 list
->last_before_switch
21505 = list
->last
->next
? list
->last
->next
: list
->last
;
21509 /* Note in all location lists that text section has changed. */
21512 var_location_switch_text_section (void)
21514 if (decl_loc_table
== NULL
)
21517 htab_traverse (decl_loc_table
, var_location_switch_text_section_1
, NULL
);
21520 /* Create a new line number table. */
21522 static dw_line_info_table
*
21523 new_line_info_table (void)
21525 dw_line_info_table
*table
;
21527 table
= ggc_alloc_cleared_dw_line_info_table_struct ();
21528 table
->file_num
= 1;
21529 table
->line_num
= 1;
21530 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
21535 /* Lookup the "current" table into which we emit line info, so
21536 that we don't have to do it for every source line. */
21539 set_cur_line_info_table (section
*sec
)
21541 dw_line_info_table
*table
;
21543 if (sec
== text_section
)
21544 table
= text_section_line_info
;
21545 else if (sec
== cold_text_section
)
21547 table
= cold_text_section_line_info
;
21550 cold_text_section_line_info
= table
= new_line_info_table ();
21551 table
->end_label
= cold_end_label
;
21556 const char *end_label
;
21558 if (flag_reorder_blocks_and_partition
)
21560 if (in_cold_section_p
)
21561 end_label
= crtl
->subsections
.cold_section_end_label
;
21563 end_label
= crtl
->subsections
.hot_section_end_label
;
21567 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21568 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
21569 current_function_funcdef_no
);
21570 end_label
= ggc_strdup (label
);
21573 table
= new_line_info_table ();
21574 table
->end_label
= end_label
;
21576 vec_safe_push (separate_line_info
, table
);
21579 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21580 table
->is_stmt
= (cur_line_info_table
21581 ? cur_line_info_table
->is_stmt
21582 : DWARF_LINE_DEFAULT_IS_STMT_START
);
21583 cur_line_info_table
= table
;
21587 /* We need to reset the locations at the beginning of each
21588 function. We can't do this in the end_function hook, because the
21589 declarations that use the locations won't have been output when
21590 that hook is called. Also compute have_multiple_function_sections here. */
21593 dwarf2out_begin_function (tree fun
)
21595 section
*sec
= function_section (fun
);
21597 if (sec
!= text_section
)
21598 have_multiple_function_sections
= true;
21600 if (flag_reorder_blocks_and_partition
&& !cold_text_section
)
21602 gcc_assert (current_function_decl
== fun
);
21603 cold_text_section
= unlikely_text_section ();
21604 switch_to_section (cold_text_section
);
21605 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
21606 switch_to_section (sec
);
21609 dwarf2out_note_section_used ();
21610 call_site_count
= 0;
21611 tail_call_site_count
= 0;
21613 set_cur_line_info_table (sec
);
21616 /* Helper function of dwarf2out_end_function, called only after emitting
21617 the very first function into assembly. Check if some .debug_loc range
21618 might end with a .LVL* label that could be equal to .Ltext0.
21619 In that case we must force using absolute addresses in .debug_loc ranges,
21620 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
21621 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
21623 Set have_multiple_function_sections to true in that case and
21624 terminate htab traversal. */
21627 find_empty_loc_ranges_at_text_label (void **slot
, void *)
21629 var_loc_list
*entry
;
21630 struct var_loc_node
*node
;
21632 entry
= (var_loc_list
*) *slot
;
21633 node
= entry
->first
;
21634 if (node
&& node
->next
&& node
->next
->label
)
21637 const char *label
= node
->next
->label
;
21638 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
21640 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
21642 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
21643 if (strcmp (label
, loclabel
) == 0)
21645 have_multiple_function_sections
= true;
21653 /* Hook called after emitting a function into assembly.
21654 This does something only for the very first function emitted. */
21657 dwarf2out_end_function (unsigned int)
21659 if (in_first_function_p
21660 && !have_multiple_function_sections
21661 && first_loclabel_num_not_at_text_label
21663 htab_traverse (decl_loc_table
, find_empty_loc_ranges_at_text_label
,
21665 in_first_function_p
= false;
21666 maybe_at_text_label_p
= false;
21669 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
21672 push_dw_line_info_entry (dw_line_info_table
*table
,
21673 enum dw_line_info_opcode opcode
, unsigned int val
)
21675 dw_line_info_entry e
;
21678 vec_safe_push (table
->entries
, e
);
21681 /* Output a label to mark the beginning of a source code line entry
21682 and record information relating to this source line, in
21683 'line_info_table' for later output of the .debug_line section. */
21684 /* ??? The discriminator parameter ought to be unsigned. */
21687 dwarf2out_source_line (unsigned int line
, const char *filename
,
21688 int discriminator
, bool is_stmt
)
21690 unsigned int file_num
;
21691 dw_line_info_table
*table
;
21693 if (debug_info_level
< DINFO_LEVEL_TERSE
|| line
== 0)
21696 /* The discriminator column was added in dwarf4. Simplify the below
21697 by simply removing it if we're not supposed to output it. */
21698 if (dwarf_version
< 4 && dwarf_strict
)
21701 table
= cur_line_info_table
;
21702 file_num
= maybe_emit_file (lookup_filename (filename
));
21704 /* ??? TODO: Elide duplicate line number entries. Traditionally,
21705 the debugger has used the second (possibly duplicate) line number
21706 at the beginning of the function to mark the end of the prologue.
21707 We could eliminate any other duplicates within the function. For
21708 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
21709 that second line number entry. */
21710 /* Recall that this end-of-prologue indication is *not* the same thing
21711 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
21712 to which the hook corresponds, follows the last insn that was
21713 emitted by gen_prologue. What we need is to precede the first insn
21714 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
21715 insn that corresponds to something the user wrote. These may be
21716 very different locations once scheduling is enabled. */
21718 if (0 && file_num
== table
->file_num
21719 && line
== table
->line_num
21720 && discriminator
== table
->discrim_num
21721 && is_stmt
== table
->is_stmt
)
21724 switch_to_section (current_function_section ());
21726 /* If requested, emit something human-readable. */
21727 if (flag_debug_asm
)
21728 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
, filename
, line
);
21730 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21732 /* Emit the .loc directive understood by GNU as. */
21733 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
21734 file_num, line, is_stmt, discriminator */
21735 fputs ("\t.loc ", asm_out_file
);
21736 fprint_ul (asm_out_file
, file_num
);
21737 putc (' ', asm_out_file
);
21738 fprint_ul (asm_out_file
, line
);
21739 putc (' ', asm_out_file
);
21740 putc ('0', asm_out_file
);
21742 if (is_stmt
!= table
->is_stmt
)
21744 fputs (" is_stmt ", asm_out_file
);
21745 putc (is_stmt
? '1' : '0', asm_out_file
);
21747 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
21749 gcc_assert (discriminator
> 0);
21750 fputs (" discriminator ", asm_out_file
);
21751 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
21753 putc ('\n', asm_out_file
);
21757 unsigned int label_num
= ++line_info_label_num
;
21759 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
21761 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
21762 if (file_num
!= table
->file_num
)
21763 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
21764 if (discriminator
!= table
->discrim_num
)
21765 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
21766 if (is_stmt
!= table
->is_stmt
)
21767 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
21768 push_dw_line_info_entry (table
, LI_set_line
, line
);
21771 table
->file_num
= file_num
;
21772 table
->line_num
= line
;
21773 table
->discrim_num
= discriminator
;
21774 table
->is_stmt
= is_stmt
;
21775 table
->in_use
= true;
21778 /* Record the beginning of a new source file. */
21781 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
21783 if (flag_eliminate_dwarf2_dups
)
21785 /* Record the beginning of the file for break_out_includes. */
21786 dw_die_ref bincl_die
;
21788 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die (), NULL
);
21789 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
21792 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21795 e
.code
= DW_MACINFO_start_file
;
21797 e
.info
= ggc_strdup (filename
);
21798 vec_safe_push (macinfo_table
, e
);
21802 /* Record the end of a source file. */
21805 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
21807 if (flag_eliminate_dwarf2_dups
)
21808 /* Record the end of the file for break_out_includes. */
21809 new_die (DW_TAG_GNU_EINCL
, comp_unit_die (), NULL
);
21811 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21814 e
.code
= DW_MACINFO_end_file
;
21817 vec_safe_push (macinfo_table
, e
);
21821 /* Called from debug_define in toplev.c. The `buffer' parameter contains
21822 the tail part of the directive line, i.e. the part which is past the
21823 initial whitespace, #, whitespace, directive-name, whitespace part. */
21826 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
21827 const char *buffer ATTRIBUTE_UNUSED
)
21829 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21832 /* Insert a dummy first entry to be able to optimize the whole
21833 predefined macro block using DW_MACRO_GNU_transparent_include. */
21834 if (macinfo_table
->is_empty () && lineno
<= 1)
21839 vec_safe_push (macinfo_table
, e
);
21841 e
.code
= DW_MACINFO_define
;
21843 e
.info
= ggc_strdup (buffer
);
21844 vec_safe_push (macinfo_table
, e
);
21848 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
21849 the tail part of the directive line, i.e. the part which is past the
21850 initial whitespace, #, whitespace, directive-name, whitespace part. */
21853 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
21854 const char *buffer ATTRIBUTE_UNUSED
)
21856 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21859 /* Insert a dummy first entry to be able to optimize the whole
21860 predefined macro block using DW_MACRO_GNU_transparent_include. */
21861 if (macinfo_table
->is_empty () && lineno
<= 1)
21866 vec_safe_push (macinfo_table
, e
);
21868 e
.code
= DW_MACINFO_undef
;
21870 e
.info
= ggc_strdup (buffer
);
21871 vec_safe_push (macinfo_table
, e
);
21875 /* Helpers to manipulate hash table of CUs. */
21877 struct macinfo_entry_hasher
: typed_noop_remove
<macinfo_entry
>
21879 typedef macinfo_entry value_type
;
21880 typedef macinfo_entry compare_type
;
21881 static inline hashval_t
hash (const value_type
*);
21882 static inline bool equal (const value_type
*, const compare_type
*);
21886 macinfo_entry_hasher::hash (const value_type
*entry
)
21888 return htab_hash_string (entry
->info
);
21892 macinfo_entry_hasher::equal (const value_type
*entry1
,
21893 const compare_type
*entry2
)
21895 return !strcmp (entry1
->info
, entry2
->info
);
21898 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
21900 /* Output a single .debug_macinfo entry. */
21903 output_macinfo_op (macinfo_entry
*ref
)
21907 struct indirect_string_node
*node
;
21908 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21909 struct dwarf_file_data
*fd
;
21913 case DW_MACINFO_start_file
:
21914 fd
= lookup_filename (ref
->info
);
21915 file_num
= maybe_emit_file (fd
);
21916 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
21917 dw2_asm_output_data_uleb128 (ref
->lineno
,
21918 "Included from line number %lu",
21919 (unsigned long) ref
->lineno
);
21920 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
21922 case DW_MACINFO_end_file
:
21923 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
21925 case DW_MACINFO_define
:
21926 case DW_MACINFO_undef
:
21927 len
= strlen (ref
->info
) + 1;
21929 && len
> DWARF_OFFSET_SIZE
21930 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
21931 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
21933 ref
->code
= ref
->code
== DW_MACINFO_define
21934 ? DW_MACRO_GNU_define_indirect
21935 : DW_MACRO_GNU_undef_indirect
;
21936 output_macinfo_op (ref
);
21939 dw2_asm_output_data (1, ref
->code
,
21940 ref
->code
== DW_MACINFO_define
21941 ? "Define macro" : "Undefine macro");
21942 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21943 (unsigned long) ref
->lineno
);
21944 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
21946 case DW_MACRO_GNU_define_indirect
:
21947 case DW_MACRO_GNU_undef_indirect
:
21948 node
= find_AT_string (ref
->info
);
21950 && ((node
->form
== DW_FORM_strp
)
21951 || (node
->form
== DW_FORM_GNU_str_index
)));
21952 dw2_asm_output_data (1, ref
->code
,
21953 ref
->code
== DW_MACRO_GNU_define_indirect
21954 ? "Define macro indirect"
21955 : "Undefine macro indirect");
21956 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21957 (unsigned long) ref
->lineno
);
21958 if (node
->form
== DW_FORM_strp
)
21959 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
21960 debug_str_section
, "The macro: \"%s\"",
21963 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
21966 case DW_MACRO_GNU_transparent_include
:
21967 dw2_asm_output_data (1, ref
->code
, "Transparent include");
21968 ASM_GENERATE_INTERNAL_LABEL (label
,
21969 DEBUG_MACRO_SECTION_LABEL
, ref
->lineno
);
21970 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
21973 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
21974 ASM_COMMENT_START
, (unsigned long) ref
->code
);
21979 /* Attempt to make a sequence of define/undef macinfo ops shareable with
21980 other compilation unit .debug_macinfo sections. IDX is the first
21981 index of a define/undef, return the number of ops that should be
21982 emitted in a comdat .debug_macinfo section and emit
21983 a DW_MACRO_GNU_transparent_include entry referencing it.
21984 If the define/undef entry should be emitted normally, return 0. */
21987 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
21988 macinfo_hash_type
*macinfo_htab
)
21990 macinfo_entry
*first
, *second
, *cur
, *inc
;
21991 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
21992 unsigned char checksum
[16];
21993 struct md5_ctx ctx
;
21994 char *grp_name
, *tail
;
21996 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
21997 macinfo_entry
**slot
;
21999 first
= &(*macinfo_table
)[idx
];
22000 second
= &(*macinfo_table
)[idx
+ 1];
22002 /* Optimize only if there are at least two consecutive define/undef ops,
22003 and either all of them are before first DW_MACINFO_start_file
22004 with lineno {0,1} (i.e. predefined macro block), or all of them are
22005 in some included header file. */
22006 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
22008 if (vec_safe_is_empty (files
))
22010 if (first
->lineno
> 1 || second
->lineno
> 1)
22013 else if (first
->lineno
== 0)
22016 /* Find the last define/undef entry that can be grouped together
22017 with first and at the same time compute md5 checksum of their
22018 codes, linenumbers and strings. */
22019 md5_init_ctx (&ctx
);
22020 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
22021 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
22023 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
22027 unsigned char code
= cur
->code
;
22028 md5_process_bytes (&code
, 1, &ctx
);
22029 checksum_uleb128 (cur
->lineno
, &ctx
);
22030 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
22032 md5_finish_ctx (&ctx
, checksum
);
22035 /* From the containing include filename (if any) pick up just
22036 usable characters from its basename. */
22037 if (vec_safe_is_empty (files
))
22040 base
= lbasename (files
->last ().info
);
22041 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
22042 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
22043 encoded_filename_len
++;
22044 /* Count . at the end. */
22045 if (encoded_filename_len
)
22046 encoded_filename_len
++;
22048 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
22049 linebuf_len
= strlen (linebuf
);
22051 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
22052 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
22054 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
22055 tail
= grp_name
+ 4;
22056 if (encoded_filename_len
)
22058 for (i
= 0; base
[i
]; i
++)
22059 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
22063 memcpy (tail
, linebuf
, linebuf_len
);
22064 tail
+= linebuf_len
;
22066 for (i
= 0; i
< 16; i
++)
22067 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
22069 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
22070 in the empty vector entry before the first define/undef. */
22071 inc
= &(*macinfo_table
)[idx
- 1];
22072 inc
->code
= DW_MACRO_GNU_transparent_include
;
22074 inc
->info
= ggc_strdup (grp_name
);
22075 if (!macinfo_htab
->is_created ())
22076 macinfo_htab
->create (10);
22077 /* Avoid emitting duplicates. */
22078 slot
= macinfo_htab
->find_slot (inc
, INSERT
);
22083 /* If such an entry has been used before, just emit
22084 a DW_MACRO_GNU_transparent_include op. */
22086 output_macinfo_op (inc
);
22087 /* And clear all macinfo_entry in the range to avoid emitting them
22088 in the second pass. */
22089 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
22098 inc
->lineno
= macinfo_htab
->elements ();
22099 output_macinfo_op (inc
);
22104 /* Save any strings needed by the macinfo table in the debug str
22105 table. All strings must be collected into the table by the time
22106 index_string is called. */
22109 save_macinfo_strings (void)
22113 macinfo_entry
*ref
;
22115 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
22119 /* Match the logic in output_macinfo_op to decide on
22120 indirect strings. */
22121 case DW_MACINFO_define
:
22122 case DW_MACINFO_undef
:
22123 len
= strlen (ref
->info
) + 1;
22125 && len
> DWARF_OFFSET_SIZE
22126 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22127 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
22128 set_indirect_string (find_AT_string (ref
->info
));
22130 case DW_MACRO_GNU_define_indirect
:
22131 case DW_MACRO_GNU_undef_indirect
:
22132 set_indirect_string (find_AT_string (ref
->info
));
22140 /* Output macinfo section(s). */
22143 output_macinfo (void)
22146 unsigned long length
= vec_safe_length (macinfo_table
);
22147 macinfo_entry
*ref
;
22148 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
22149 macinfo_hash_type macinfo_htab
;
22154 /* output_macinfo* uses these interchangeably. */
22155 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_GNU_define
22156 && (int) DW_MACINFO_undef
== (int) DW_MACRO_GNU_undef
22157 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_GNU_start_file
22158 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_GNU_end_file
);
22160 /* For .debug_macro emit the section header. */
22163 dw2_asm_output_data (2, 4, "DWARF macro version number");
22164 if (DWARF_OFFSET_SIZE
== 8)
22165 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
22167 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
22168 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
22169 (!dwarf_split_debug_info
? debug_line_section_label
22170 : debug_skeleton_line_section_label
),
22171 debug_line_section
, NULL
);
22174 /* In the first loop, it emits the primary .debug_macinfo section
22175 and after each emitted op the macinfo_entry is cleared.
22176 If a longer range of define/undef ops can be optimized using
22177 DW_MACRO_GNU_transparent_include, the
22178 DW_MACRO_GNU_transparent_include op is emitted and kept in
22179 the vector before the first define/undef in the range and the
22180 whole range of define/undef ops is not emitted and kept. */
22181 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22185 case DW_MACINFO_start_file
:
22186 vec_safe_push (files
, *ref
);
22188 case DW_MACINFO_end_file
:
22189 if (!vec_safe_is_empty (files
))
22192 case DW_MACINFO_define
:
22193 case DW_MACINFO_undef
:
22195 && HAVE_COMDAT_GROUP
22196 && vec_safe_length (files
) != 1
22199 && (*macinfo_table
)[i
- 1].code
== 0)
22201 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
22210 /* A dummy entry may be inserted at the beginning to be able
22211 to optimize the whole block of predefined macros. */
22217 output_macinfo_op (ref
);
22222 if (!macinfo_htab
.is_created ())
22225 macinfo_htab
.dispose ();
22227 /* If any DW_MACRO_GNU_transparent_include were used, on those
22228 DW_MACRO_GNU_transparent_include entries terminate the
22229 current chain and switch to a new comdat .debug_macinfo
22230 section and emit the define/undef entries within it. */
22231 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22236 case DW_MACRO_GNU_transparent_include
:
22238 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
22239 tree comdat_key
= get_identifier (ref
->info
);
22240 /* Terminate the previous .debug_macinfo section. */
22241 dw2_asm_output_data (1, 0, "End compilation unit");
22242 targetm
.asm_out
.named_section (DEBUG_MACRO_SECTION
,
22244 | SECTION_LINKONCE
,
22246 ASM_GENERATE_INTERNAL_LABEL (label
,
22247 DEBUG_MACRO_SECTION_LABEL
,
22249 ASM_OUTPUT_LABEL (asm_out_file
, label
);
22252 dw2_asm_output_data (2, 4, "DWARF macro version number");
22253 if (DWARF_OFFSET_SIZE
== 8)
22254 dw2_asm_output_data (1, 1, "Flags: 64-bit");
22256 dw2_asm_output_data (1, 0, "Flags: 32-bit");
22259 case DW_MACINFO_define
:
22260 case DW_MACINFO_undef
:
22261 output_macinfo_op (ref
);
22266 gcc_unreachable ();
22270 /* Set up for Dwarf output at the start of compilation. */
22273 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
22275 /* Allocate the file_table. */
22276 file_table
= htab_create_ggc (50, file_table_hash
,
22277 file_table_eq
, NULL
);
22279 /* Allocate the decl_die_table. */
22280 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
22281 decl_die_table_eq
, NULL
);
22283 /* Allocate the decl_loc_table. */
22284 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
22285 decl_loc_table_eq
, NULL
);
22287 /* Allocate the cached_dw_loc_list_table. */
22288 cached_dw_loc_list_table
22289 = htab_create_ggc (10, cached_dw_loc_list_table_hash
,
22290 cached_dw_loc_list_table_eq
, NULL
);
22292 /* Allocate the initial hunk of the decl_scope_table. */
22293 vec_alloc (decl_scope_table
, 256);
22295 /* Allocate the initial hunk of the abbrev_die_table. */
22296 abbrev_die_table
= ggc_alloc_cleared_vec_dw_die_ref
22297 (ABBREV_DIE_TABLE_INCREMENT
);
22298 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
22299 /* Zero-th entry is allocated, but unused. */
22300 abbrev_die_table_in_use
= 1;
22302 /* Allocate the pubtypes and pubnames vectors. */
22303 vec_alloc (pubname_table
, 32);
22304 vec_alloc (pubtype_table
, 32);
22306 vec_alloc (incomplete_types
, 64);
22308 vec_alloc (used_rtx_array
, 32);
22310 if (!dwarf_split_debug_info
)
22312 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
22313 SECTION_DEBUG
, NULL
);
22314 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22315 SECTION_DEBUG
, NULL
);
22316 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
22317 SECTION_DEBUG
, NULL
);
22321 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
22322 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22323 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
22324 SECTION_DEBUG
| SECTION_EXCLUDE
,
22326 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
22327 SECTION_DEBUG
, NULL
);
22328 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
22329 SECTION_DEBUG
, NULL
);
22330 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22331 SECTION_DEBUG
, NULL
);
22332 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
22333 DEBUG_SKELETON_ABBREV_SECTION_LABEL
, 0);
22335 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
22336 the main .o, but the skeleton_line goes into the split off dwo. */
22337 debug_skeleton_line_section
22338 = get_section (DEBUG_DWO_LINE_SECTION
,
22339 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22340 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
22341 DEBUG_SKELETON_LINE_SECTION_LABEL
, 0);
22342 debug_str_offsets_section
= get_section (DEBUG_STR_OFFSETS_SECTION
,
22343 SECTION_DEBUG
| SECTION_EXCLUDE
,
22345 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
22346 DEBUG_SKELETON_INFO_SECTION_LABEL
, 0);
22347 debug_loc_section
= get_section (DEBUG_DWO_LOC_SECTION
,
22348 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22349 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
22350 DEBUG_STR_DWO_SECTION_FLAGS
, NULL
);
22352 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
22353 SECTION_DEBUG
, NULL
);
22354 debug_macinfo_section
= get_section (dwarf_strict
22355 ? DEBUG_MACINFO_SECTION
22356 : DEBUG_MACRO_SECTION
,
22357 DEBUG_MACRO_SECTION_FLAGS
, NULL
);
22358 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
22359 SECTION_DEBUG
, NULL
);
22360 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
22361 SECTION_DEBUG
, NULL
);
22362 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
22363 SECTION_DEBUG
, NULL
);
22364 debug_str_section
= get_section (DEBUG_STR_SECTION
,
22365 DEBUG_STR_SECTION_FLAGS
, NULL
);
22366 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
22367 SECTION_DEBUG
, NULL
);
22368 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
22369 SECTION_DEBUG
, NULL
);
22371 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
22372 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
22373 DEBUG_ABBREV_SECTION_LABEL
, 0);
22374 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
22375 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
22376 COLD_TEXT_SECTION_LABEL
, 0);
22377 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
22379 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
22380 DEBUG_INFO_SECTION_LABEL
, 0);
22381 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
22382 DEBUG_LINE_SECTION_LABEL
, 0);
22383 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
22384 DEBUG_RANGES_SECTION_LABEL
, 0);
22385 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
22386 DEBUG_ADDR_SECTION_LABEL
, 0);
22387 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
22389 ? DEBUG_MACINFO_SECTION_LABEL
22390 : DEBUG_MACRO_SECTION_LABEL
, 0);
22391 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
, 0);
22393 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22394 vec_alloc (macinfo_table
, 64);
22396 switch_to_section (text_section
);
22397 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
22399 /* Make sure the line number table for .text always exists. */
22400 text_section_line_info
= new_line_info_table ();
22401 text_section_line_info
->end_label
= text_end_label
;
22404 /* Called before compile () starts outputtting functions, variables
22405 and toplevel asms into assembly. */
22408 dwarf2out_assembly_start (void)
22410 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
22411 && dwarf2out_do_cfi_asm ()
22412 && (!(flag_unwind_tables
|| flag_exceptions
)
22413 || targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
))
22414 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
22417 /* A helper function for dwarf2out_finish called through
22418 htab_traverse. Assign a string its index. All strings must be
22419 collected into the table by the time index_string is called,
22420 because the indexing code relies on htab_traverse to traverse nodes
22421 in the same order for each run. */
22424 index_string (void **h
, void *v
)
22426 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22427 unsigned int *index
= (unsigned int *) v
;
22429 find_string_form (node
);
22430 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22432 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
22433 node
->index
= *index
;
22439 /* A helper function for output_indirect_strings called through
22440 htab_traverse. Output the offset to a string and update the
22444 output_index_string_offset (void **h
, void *v
)
22446 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22447 unsigned int *offset
= (unsigned int *) v
;
22449 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22451 /* Assert that this node has been assigned an index. */
22452 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
22453 && node
->index
!= NOT_INDEXED
);
22454 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
22455 "indexed string 0x%x: %s", node
->index
, node
->str
);
22456 *offset
+= strlen (node
->str
) + 1;
22461 /* A helper function for dwarf2out_finish called through
22462 htab_traverse. Output the indexed string. */
22465 output_index_string (void **h
, void *v
)
22467 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22468 unsigned int *cur_idx
= (unsigned int *) v
;
22470 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22472 /* Assert that the strings are output in the same order as their
22473 indexes were assigned. */
22474 gcc_assert (*cur_idx
== node
->index
);
22475 assemble_string (node
->str
, strlen (node
->str
) + 1);
22481 /* A helper function for dwarf2out_finish called through
22482 htab_traverse. Emit one queued .debug_str string. */
22485 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
22487 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22489 node
->form
= find_string_form (node
);
22490 if (node
->form
== DW_FORM_strp
&& node
->refcount
> 0)
22492 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
22493 assemble_string (node
->str
, strlen (node
->str
) + 1);
22499 /* Output the indexed string table. */
22502 output_indirect_strings (void)
22504 switch_to_section (debug_str_section
);
22505 if (!dwarf_split_debug_info
)
22506 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
22509 unsigned int offset
= 0;
22510 unsigned int cur_idx
= 0;
22512 htab_traverse (skeleton_debug_str_hash
, output_indirect_string
, NULL
);
22514 switch_to_section (debug_str_offsets_section
);
22515 htab_traverse_noresize (debug_str_hash
,
22516 output_index_string_offset
,
22518 switch_to_section (debug_str_dwo_section
);
22519 htab_traverse_noresize (debug_str_hash
,
22520 output_index_string
,
22525 /* Callback for htab_traverse to assign an index to an entry in the
22526 table, and to write that entry to the .debug_addr section. */
22529 output_addr_table_entry (void **slot
, void *data
)
22531 addr_table_entry
*entry
= (addr_table_entry
*) *slot
;
22532 unsigned int *cur_index
= (unsigned int *)data
;
22534 if (entry
->refcount
== 0)
22536 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
22537 || entry
->index
== NOT_INDEXED
);
22541 gcc_assert (entry
->index
== *cur_index
);
22544 switch (entry
->kind
)
22547 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
22548 "0x%x", entry
->index
);
22550 case ate_kind_rtx_dtprel
:
22551 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
22552 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
22555 fputc ('\n', asm_out_file
);
22557 case ate_kind_label
:
22558 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
22559 "0x%x", entry
->index
);
22562 gcc_unreachable ();
22567 /* Produce the .debug_addr section. */
22570 output_addr_table (void)
22572 unsigned int index
= 0;
22573 if (addr_index_table
== NULL
|| htab_size (addr_index_table
) == 0)
22576 switch_to_section (debug_addr_section
);
22577 htab_traverse_noresize (addr_index_table
, output_addr_table_entry
, &index
);
22580 #if ENABLE_ASSERT_CHECKING
22581 /* Verify that all marks are clear. */
22584 verify_marks_clear (dw_die_ref die
)
22588 gcc_assert (! die
->die_mark
);
22589 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
22591 #endif /* ENABLE_ASSERT_CHECKING */
22593 /* Clear the marks for a die and its children.
22594 Be cool if the mark isn't set. */
22597 prune_unmark_dies (dw_die_ref die
)
22603 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
22606 /* Given DIE that we're marking as used, find any other dies
22607 it references as attributes and mark them as used. */
22610 prune_unused_types_walk_attribs (dw_die_ref die
)
22615 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22617 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
22619 /* A reference to another DIE.
22620 Make sure that it will get emitted.
22621 If it was broken out into a comdat group, don't follow it. */
22622 if (! AT_ref (a
)->comdat_type_p
22623 || a
->dw_attr
== DW_AT_specification
)
22624 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
22626 /* Set the string's refcount to 0 so that prune_unused_types_mark
22627 accounts properly for it. */
22628 if (AT_class (a
) == dw_val_class_str
)
22629 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
22633 /* Mark the generic parameters and arguments children DIEs of DIE. */
22636 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
22640 if (die
== NULL
|| die
->die_child
== NULL
)
22642 c
= die
->die_child
;
22645 if (is_template_parameter (c
))
22646 prune_unused_types_mark (c
, 1);
22648 } while (c
&& c
!= die
->die_child
);
22651 /* Mark DIE as being used. If DOKIDS is true, then walk down
22652 to DIE's children. */
22655 prune_unused_types_mark (dw_die_ref die
, int dokids
)
22659 if (die
->die_mark
== 0)
22661 /* We haven't done this node yet. Mark it as used. */
22663 /* If this is the DIE of a generic type instantiation,
22664 mark the children DIEs that describe its generic parms and
22666 prune_unused_types_mark_generic_parms_dies (die
);
22668 /* We also have to mark its parents as used.
22669 (But we don't want to mark our parent's kids due to this,
22670 unless it is a class.) */
22671 if (die
->die_parent
)
22672 prune_unused_types_mark (die
->die_parent
,
22673 class_scope_p (die
->die_parent
));
22675 /* Mark any referenced nodes. */
22676 prune_unused_types_walk_attribs (die
);
22678 /* If this node is a specification,
22679 also mark the definition, if it exists. */
22680 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
22681 prune_unused_types_mark (die
->die_definition
, 1);
22684 if (dokids
&& die
->die_mark
!= 2)
22686 /* We need to walk the children, but haven't done so yet.
22687 Remember that we've walked the kids. */
22690 /* If this is an array type, we need to make sure our
22691 kids get marked, even if they're types. If we're
22692 breaking out types into comdat sections, do this
22693 for all type definitions. */
22694 if (die
->die_tag
== DW_TAG_array_type
22695 || (use_debug_types
22696 && is_type_die (die
) && ! is_declaration_die (die
)))
22697 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
22699 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22703 /* For local classes, look if any static member functions were emitted
22704 and if so, mark them. */
22707 prune_unused_types_walk_local_classes (dw_die_ref die
)
22711 if (die
->die_mark
== 2)
22714 switch (die
->die_tag
)
22716 case DW_TAG_structure_type
:
22717 case DW_TAG_union_type
:
22718 case DW_TAG_class_type
:
22721 case DW_TAG_subprogram
:
22722 if (!get_AT_flag (die
, DW_AT_declaration
)
22723 || die
->die_definition
!= NULL
)
22724 prune_unused_types_mark (die
, 1);
22731 /* Mark children. */
22732 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
22735 /* Walk the tree DIE and mark types that we actually use. */
22738 prune_unused_types_walk (dw_die_ref die
)
22742 /* Don't do anything if this node is already marked and
22743 children have been marked as well. */
22744 if (die
->die_mark
== 2)
22747 switch (die
->die_tag
)
22749 case DW_TAG_structure_type
:
22750 case DW_TAG_union_type
:
22751 case DW_TAG_class_type
:
22752 if (die
->die_perennial_p
)
22755 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
22756 if (c
->die_tag
== DW_TAG_subprogram
)
22759 /* Finding used static member functions inside of classes
22760 is needed just for local classes, because for other classes
22761 static member function DIEs with DW_AT_specification
22762 are emitted outside of the DW_TAG_*_type. If we ever change
22763 it, we'd need to call this even for non-local classes. */
22765 prune_unused_types_walk_local_classes (die
);
22767 /* It's a type node --- don't mark it. */
22770 case DW_TAG_const_type
:
22771 case DW_TAG_packed_type
:
22772 case DW_TAG_pointer_type
:
22773 case DW_TAG_reference_type
:
22774 case DW_TAG_rvalue_reference_type
:
22775 case DW_TAG_volatile_type
:
22776 case DW_TAG_typedef
:
22777 case DW_TAG_array_type
:
22778 case DW_TAG_interface_type
:
22779 case DW_TAG_friend
:
22780 case DW_TAG_variant_part
:
22781 case DW_TAG_enumeration_type
:
22782 case DW_TAG_subroutine_type
:
22783 case DW_TAG_string_type
:
22784 case DW_TAG_set_type
:
22785 case DW_TAG_subrange_type
:
22786 case DW_TAG_ptr_to_member_type
:
22787 case DW_TAG_file_type
:
22788 if (die
->die_perennial_p
)
22791 /* It's a type node --- don't mark it. */
22795 /* Mark everything else. */
22799 if (die
->die_mark
== 0)
22803 /* Now, mark any dies referenced from here. */
22804 prune_unused_types_walk_attribs (die
);
22809 /* Mark children. */
22810 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22813 /* Increment the string counts on strings referred to from DIE's
22817 prune_unused_types_update_strings (dw_die_ref die
)
22822 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22823 if (AT_class (a
) == dw_val_class_str
)
22825 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
22827 /* Avoid unnecessarily putting strings that are used less than
22828 twice in the hash table. */
22830 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
22833 slot
= htab_find_slot_with_hash (debug_str_hash
, s
->str
,
22834 htab_hash_string (s
->str
),
22836 gcc_assert (*slot
== NULL
);
22842 /* Remove from the tree DIE any dies that aren't marked. */
22845 prune_unused_types_prune (dw_die_ref die
)
22849 gcc_assert (die
->die_mark
);
22850 prune_unused_types_update_strings (die
);
22852 if (! die
->die_child
)
22855 c
= die
->die_child
;
22857 dw_die_ref prev
= c
;
22858 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
22859 if (c
== die
->die_child
)
22861 /* No marked children between 'prev' and the end of the list. */
22863 /* No marked children at all. */
22864 die
->die_child
= NULL
;
22867 prev
->die_sib
= c
->die_sib
;
22868 die
->die_child
= prev
;
22873 if (c
!= prev
->die_sib
)
22875 prune_unused_types_prune (c
);
22876 } while (c
!= die
->die_child
);
22879 /* Remove dies representing declarations that we never use. */
22882 prune_unused_types (void)
22885 limbo_die_node
*node
;
22886 comdat_type_node
*ctnode
;
22888 dw_die_ref base_type
;
22890 #if ENABLE_ASSERT_CHECKING
22891 /* All the marks should already be clear. */
22892 verify_marks_clear (comp_unit_die ());
22893 for (node
= limbo_die_list
; node
; node
= node
->next
)
22894 verify_marks_clear (node
->die
);
22895 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22896 verify_marks_clear (ctnode
->root_die
);
22897 #endif /* ENABLE_ASSERT_CHECKING */
22899 /* Mark types that are used in global variables. */
22900 premark_types_used_by_global_vars ();
22902 /* Set the mark on nodes that are actually used. */
22903 prune_unused_types_walk (comp_unit_die ());
22904 for (node
= limbo_die_list
; node
; node
= node
->next
)
22905 prune_unused_types_walk (node
->die
);
22906 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22908 prune_unused_types_walk (ctnode
->root_die
);
22909 prune_unused_types_mark (ctnode
->type_die
, 1);
22912 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
22913 are unusual in that they are pubnames that are the children of pubtypes.
22914 They should only be marked via their parent DW_TAG_enumeration_type die,
22915 not as roots in themselves. */
22916 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
22917 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
22918 prune_unused_types_mark (pub
->die
, 1);
22919 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
22920 prune_unused_types_mark (base_type
, 1);
22922 if (debug_str_hash
)
22923 htab_empty (debug_str_hash
);
22924 if (skeleton_debug_str_hash
)
22925 htab_empty (skeleton_debug_str_hash
);
22926 prune_unused_types_prune (comp_unit_die ());
22927 for (node
= limbo_die_list
; node
; node
= node
->next
)
22928 prune_unused_types_prune (node
->die
);
22929 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22930 prune_unused_types_prune (ctnode
->root_die
);
22932 /* Leave the marks clear. */
22933 prune_unmark_dies (comp_unit_die ());
22934 for (node
= limbo_die_list
; node
; node
= node
->next
)
22935 prune_unmark_dies (node
->die
);
22936 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22937 prune_unmark_dies (ctnode
->root_die
);
22940 /* Set the parameter to true if there are any relative pathnames in
22943 file_table_relative_p (void ** slot
, void *param
)
22945 bool *p
= (bool *) param
;
22946 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
22947 if (!IS_ABSOLUTE_PATH (d
->filename
))
22955 /* Helpers to manipulate hash table of comdat type units. */
22957 struct comdat_type_hasher
: typed_noop_remove
<comdat_type_node
>
22959 typedef comdat_type_node value_type
;
22960 typedef comdat_type_node compare_type
;
22961 static inline hashval_t
hash (const value_type
*);
22962 static inline bool equal (const value_type
*, const compare_type
*);
22966 comdat_type_hasher::hash (const value_type
*type_node
)
22969 memcpy (&h
, type_node
->signature
, sizeof (h
));
22974 comdat_type_hasher::equal (const value_type
*type_node_1
,
22975 const compare_type
*type_node_2
)
22977 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
22978 DWARF_TYPE_SIGNATURE_SIZE
));
22981 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
22982 to the location it would have been added, should we know its
22983 DECL_ASSEMBLER_NAME when we added other attributes. This will
22984 probably improve compactness of debug info, removing equivalent
22985 abbrevs, and hide any differences caused by deferring the
22986 computation of the assembler name, triggered by e.g. PCH. */
22989 move_linkage_attr (dw_die_ref die
)
22991 unsigned ix
= vec_safe_length (die
->die_attr
);
22992 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
22994 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
22995 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
22999 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
23001 if (prev
->dw_attr
== DW_AT_decl_line
|| prev
->dw_attr
== DW_AT_name
)
23005 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
23007 die
->die_attr
->pop ();
23008 die
->die_attr
->quick_insert (ix
, linkage
);
23012 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
23013 referenced from typed stack ops and count how often they are used. */
23016 mark_base_types (dw_loc_descr_ref loc
)
23018 dw_die_ref base_type
= NULL
;
23020 for (; loc
; loc
= loc
->dw_loc_next
)
23022 switch (loc
->dw_loc_opc
)
23024 case DW_OP_GNU_regval_type
:
23025 case DW_OP_GNU_deref_type
:
23026 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
23028 case DW_OP_GNU_convert
:
23029 case DW_OP_GNU_reinterpret
:
23030 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
23033 case DW_OP_GNU_const_type
:
23034 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23036 case DW_OP_GNU_entry_value
:
23037 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
23042 gcc_assert (base_type
->die_parent
== comp_unit_die ());
23043 if (base_type
->die_mark
)
23044 base_type
->die_mark
++;
23047 base_types
.safe_push (base_type
);
23048 base_type
->die_mark
= 1;
23053 /* Comparison function for sorting marked base types. */
23056 base_type_cmp (const void *x
, const void *y
)
23058 dw_die_ref dx
= *(const dw_die_ref
*) x
;
23059 dw_die_ref dy
= *(const dw_die_ref
*) y
;
23060 unsigned int byte_size1
, byte_size2
;
23061 unsigned int encoding1
, encoding2
;
23062 if (dx
->die_mark
> dy
->die_mark
)
23064 if (dx
->die_mark
< dy
->die_mark
)
23066 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
23067 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
23068 if (byte_size1
< byte_size2
)
23070 if (byte_size1
> byte_size2
)
23072 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
23073 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
23074 if (encoding1
< encoding2
)
23076 if (encoding1
> encoding2
)
23081 /* Move base types marked by mark_base_types as early as possible
23082 in the CU, sorted by decreasing usage count both to make the
23083 uleb128 references as small as possible and to make sure they
23084 will have die_offset already computed by calc_die_sizes when
23085 sizes of typed stack loc ops is computed. */
23088 move_marked_base_types (void)
23091 dw_die_ref base_type
, die
, c
;
23093 if (base_types
.is_empty ())
23096 /* Sort by decreasing usage count, they will be added again in that
23098 base_types
.qsort (base_type_cmp
);
23099 die
= comp_unit_die ();
23100 c
= die
->die_child
;
23103 dw_die_ref prev
= c
;
23105 while (c
->die_mark
)
23107 remove_child_with_prev (c
, prev
);
23108 /* As base types got marked, there must be at least
23109 one node other than DW_TAG_base_type. */
23110 gcc_assert (c
!= c
->die_sib
);
23114 while (c
!= die
->die_child
);
23115 gcc_assert (die
->die_child
);
23116 c
= die
->die_child
;
23117 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
23119 base_type
->die_mark
= 0;
23120 base_type
->die_sib
= c
->die_sib
;
23121 c
->die_sib
= base_type
;
23126 /* Helper function for resolve_addr, attempt to resolve
23127 one CONST_STRING, return non-zero if not successful. Similarly verify that
23128 SYMBOL_REFs refer to variables emitted in the current CU. */
23131 resolve_one_addr (rtx
*addr
, void *data ATTRIBUTE_UNUSED
)
23135 if (GET_CODE (rtl
) == CONST_STRING
)
23137 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
23138 tree t
= build_string (len
, XSTR (rtl
, 0));
23139 tree tlen
= size_int (len
- 1);
23141 = build_array_type (char_type_node
, build_index_type (tlen
));
23142 rtl
= lookup_constant_def (t
);
23143 if (!rtl
|| !MEM_P (rtl
))
23145 rtl
= XEXP (rtl
, 0);
23146 if (GET_CODE (rtl
) == SYMBOL_REF
23147 && SYMBOL_REF_DECL (rtl
)
23148 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
23150 vec_safe_push (used_rtx_array
, rtl
);
23155 if (GET_CODE (rtl
) == SYMBOL_REF
23156 && SYMBOL_REF_DECL (rtl
))
23158 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
23160 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
23163 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
23167 if (GET_CODE (rtl
) == CONST
23168 && for_each_rtx (&XEXP (rtl
, 0), resolve_one_addr
, NULL
))
23174 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
23175 if possible, and create DW_TAG_dwarf_procedure that can be referenced
23176 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
23179 string_cst_pool_decl (tree t
)
23181 rtx rtl
= output_constant_def (t
, 1);
23182 unsigned char *array
;
23183 dw_loc_descr_ref l
;
23188 if (!rtl
|| !MEM_P (rtl
))
23190 rtl
= XEXP (rtl
, 0);
23191 if (GET_CODE (rtl
) != SYMBOL_REF
23192 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
23195 decl
= SYMBOL_REF_DECL (rtl
);
23196 if (!lookup_decl_die (decl
))
23198 len
= TREE_STRING_LENGTH (t
);
23199 vec_safe_push (used_rtx_array
, rtl
);
23200 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
23201 array
= (unsigned char *) ggc_alloc_atomic (len
);
23202 memcpy (array
, TREE_STRING_POINTER (t
), len
);
23203 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
23204 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
23205 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
23206 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
23207 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
23208 add_AT_loc (ref
, DW_AT_location
, l
);
23209 equate_decl_number_to_die (decl
, ref
);
23214 /* Helper function of resolve_addr_in_expr. LOC is
23215 a DW_OP_addr followed by DW_OP_stack_value, either at the start
23216 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
23217 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
23218 with DW_OP_GNU_implicit_pointer if possible
23219 and return true, if unsuccessful, return false. */
23222 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
23224 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
23225 HOST_WIDE_INT offset
= 0;
23226 dw_die_ref ref
= NULL
;
23229 if (GET_CODE (rtl
) == CONST
23230 && GET_CODE (XEXP (rtl
, 0)) == PLUS
23231 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
23233 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
23234 rtl
= XEXP (XEXP (rtl
, 0), 0);
23236 if (GET_CODE (rtl
) == CONST_STRING
)
23238 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
23239 tree t
= build_string (len
, XSTR (rtl
, 0));
23240 tree tlen
= size_int (len
- 1);
23243 = build_array_type (char_type_node
, build_index_type (tlen
));
23244 rtl
= string_cst_pool_decl (t
);
23248 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
23250 decl
= SYMBOL_REF_DECL (rtl
);
23251 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
23253 ref
= lookup_decl_die (decl
);
23254 if (ref
&& (get_AT (ref
, DW_AT_location
)
23255 || get_AT (ref
, DW_AT_const_value
)))
23257 loc
->dw_loc_opc
= DW_OP_GNU_implicit_pointer
;
23258 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23259 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
23260 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23261 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23262 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23263 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
23271 /* Helper function for resolve_addr, handle one location
23272 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23273 the location list couldn't be resolved. */
23276 resolve_addr_in_expr (dw_loc_descr_ref loc
)
23278 dw_loc_descr_ref keep
= NULL
;
23279 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
23280 switch (loc
->dw_loc_opc
)
23283 if (resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
23286 || prev
->dw_loc_opc
== DW_OP_piece
23287 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
23288 && loc
->dw_loc_next
23289 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
23291 && optimize_one_addr_into_implicit_ptr (loc
))
23296 case DW_OP_GNU_addr_index
:
23297 case DW_OP_GNU_const_index
:
23298 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
23299 || (loc
->dw_loc_opc
== DW_OP_GNU_const_index
&& loc
->dtprel
))
23300 && resolve_one_addr (&loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
,
23304 case DW_OP_const4u
:
23305 case DW_OP_const8u
:
23307 && resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
23310 case DW_OP_plus_uconst
:
23311 if (size_of_loc_descr (loc
)
23312 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
23314 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
23316 dw_loc_descr_ref repl
23317 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
23318 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
23319 add_loc_descr (&repl
, loc
->dw_loc_next
);
23323 case DW_OP_implicit_value
:
23324 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
23325 && resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
, NULL
))
23328 case DW_OP_GNU_implicit_pointer
:
23329 case DW_OP_GNU_parameter_ref
:
23330 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
23333 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
23336 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23337 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23338 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23341 case DW_OP_GNU_const_type
:
23342 case DW_OP_GNU_regval_type
:
23343 case DW_OP_GNU_deref_type
:
23344 case DW_OP_GNU_convert
:
23345 case DW_OP_GNU_reinterpret
:
23346 while (loc
->dw_loc_next
23347 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
)
23349 dw_die_ref base1
, base2
;
23350 unsigned enc1
, enc2
, size1
, size2
;
23351 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23352 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23353 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
23354 else if (loc
->dw_loc_oprnd1
.val_class
23355 == dw_val_class_unsigned_const
)
23358 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23359 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
23360 == dw_val_class_unsigned_const
)
23362 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23363 gcc_assert (base1
->die_tag
== DW_TAG_base_type
23364 && base2
->die_tag
== DW_TAG_base_type
);
23365 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
23366 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
23367 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
23368 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
23370 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
23371 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
23375 /* Optimize away next DW_OP_GNU_convert after
23376 adjusting LOC's base type die reference. */
23377 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23378 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23379 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
23381 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
23382 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23385 /* Don't change integer DW_OP_GNU_convert after e.g. floating
23386 point typed stack entry. */
23387 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
23388 keep
= loc
->dw_loc_next
;
23398 /* Helper function of resolve_addr. DIE had DW_AT_location of
23399 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
23400 and DW_OP_addr couldn't be resolved. resolve_addr has already
23401 removed the DW_AT_location attribute. This function attempts to
23402 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
23403 to it or DW_AT_const_value attribute, if possible. */
23406 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
23408 if (TREE_CODE (decl
) != VAR_DECL
23409 || lookup_decl_die (decl
) != die
23410 || DECL_EXTERNAL (decl
)
23411 || !TREE_STATIC (decl
)
23412 || DECL_INITIAL (decl
) == NULL_TREE
23413 || DECL_P (DECL_INITIAL (decl
))
23414 || get_AT (die
, DW_AT_const_value
))
23417 tree init
= DECL_INITIAL (decl
);
23418 HOST_WIDE_INT offset
= 0;
23419 /* For variables that have been optimized away and thus
23420 don't have a memory location, see if we can emit
23421 DW_AT_const_value instead. */
23422 if (tree_add_const_value_attribute (die
, init
))
23426 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
23427 and ADDR_EXPR refers to a decl that has DW_AT_location or
23428 DW_AT_const_value (but isn't addressable, otherwise
23429 resolving the original DW_OP_addr wouldn't fail), see if
23430 we can add DW_OP_GNU_implicit_pointer. */
23432 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
23433 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
23435 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
23436 init
= TREE_OPERAND (init
, 0);
23439 if (TREE_CODE (init
) != ADDR_EXPR
)
23441 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
23442 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
23443 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
23444 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
23445 && TREE_OPERAND (init
, 0) != decl
))
23448 dw_loc_descr_ref l
;
23450 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
23452 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
23455 decl
= SYMBOL_REF_DECL (rtl
);
23458 decl
= TREE_OPERAND (init
, 0);
23459 ref
= lookup_decl_die (decl
);
23461 || (!get_AT (ref
, DW_AT_location
)
23462 && !get_AT (ref
, DW_AT_const_value
)))
23464 l
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
23465 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23466 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23467 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23468 add_AT_loc (die
, DW_AT_location
, l
);
23472 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23473 an address in .rodata section if the string literal is emitted there,
23474 or remove the containing location list or replace DW_AT_const_value
23475 with DW_AT_location and empty location expression, if it isn't found
23476 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23477 to something that has been emitted in the current CU. */
23480 resolve_addr (dw_die_ref die
)
23484 dw_loc_list_ref
*curr
, *start
, loc
;
23487 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23488 switch (AT_class (a
))
23490 case dw_val_class_loc_list
:
23491 start
= curr
= AT_loc_list_ptr (a
);
23494 /* The same list can be referenced more than once. See if we have
23495 already recorded the result from a previous pass. */
23497 *curr
= loc
->dw_loc_next
;
23498 else if (!loc
->resolved_addr
)
23500 /* As things stand, we do not expect or allow one die to
23501 reference a suffix of another die's location list chain.
23502 References must be identical or completely separate.
23503 There is therefore no need to cache the result of this
23504 pass on any list other than the first; doing so
23505 would lead to unnecessary writes. */
23508 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
23509 if (!resolve_addr_in_expr ((*curr
)->expr
))
23511 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
23512 dw_loc_descr_ref l
= (*curr
)->expr
;
23514 if (next
&& (*curr
)->ll_symbol
)
23516 gcc_assert (!next
->ll_symbol
);
23517 next
->ll_symbol
= (*curr
)->ll_symbol
;
23519 if (dwarf_split_debug_info
)
23520 remove_loc_list_addr_table_entries (l
);
23525 mark_base_types ((*curr
)->expr
);
23526 curr
= &(*curr
)->dw_loc_next
;
23530 loc
->resolved_addr
= 1;
23534 loc
->dw_loc_next
= *start
;
23539 remove_AT (die
, a
->dw_attr
);
23543 case dw_val_class_loc
:
23545 dw_loc_descr_ref l
= AT_loc (a
);
23546 /* For -gdwarf-2 don't attempt to optimize
23547 DW_AT_data_member_location containing
23548 DW_OP_plus_uconst - older consumers might
23549 rely on it being that op instead of a more complex,
23550 but shorter, location description. */
23551 if ((dwarf_version
> 2
23552 || a
->dw_attr
!= DW_AT_data_member_location
23554 || l
->dw_loc_opc
!= DW_OP_plus_uconst
23555 || l
->dw_loc_next
!= NULL
)
23556 && !resolve_addr_in_expr (l
))
23558 if (dwarf_split_debug_info
)
23559 remove_loc_list_addr_table_entries (l
);
23561 && l
->dw_loc_next
== NULL
23562 && l
->dw_loc_opc
== DW_OP_addr
23563 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
23564 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
23565 && a
->dw_attr
== DW_AT_location
)
23567 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
23568 remove_AT (die
, a
->dw_attr
);
23570 optimize_location_into_implicit_ptr (die
, decl
);
23573 remove_AT (die
, a
->dw_attr
);
23577 mark_base_types (l
);
23580 case dw_val_class_addr
:
23581 if (a
->dw_attr
== DW_AT_const_value
23582 && resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
, NULL
))
23584 if (AT_index (a
) != NOT_INDEXED
)
23585 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23586 remove_AT (die
, a
->dw_attr
);
23589 if (die
->die_tag
== DW_TAG_GNU_call_site
23590 && a
->dw_attr
== DW_AT_abstract_origin
)
23592 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
23593 dw_die_ref tdie
= lookup_decl_die (tdecl
);
23595 && DECL_EXTERNAL (tdecl
)
23596 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
)
23598 force_decl_die (tdecl
);
23599 tdie
= lookup_decl_die (tdecl
);
23603 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
23604 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
23605 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
23609 if (AT_index (a
) != NOT_INDEXED
)
23610 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23611 remove_AT (die
, a
->dw_attr
);
23620 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
23623 /* Helper routines for optimize_location_lists.
23624 This pass tries to share identical local lists in .debug_loc
23627 /* Iteratively hash operands of LOC opcode. */
23630 hash_loc_operands (dw_loc_descr_ref loc
, hashval_t hash
)
23632 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
23633 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
23635 switch (loc
->dw_loc_opc
)
23637 case DW_OP_const4u
:
23638 case DW_OP_const8u
:
23642 case DW_OP_const1u
:
23643 case DW_OP_const1s
:
23644 case DW_OP_const2u
:
23645 case DW_OP_const2s
:
23646 case DW_OP_const4s
:
23647 case DW_OP_const8s
:
23651 case DW_OP_plus_uconst
:
23687 case DW_OP_deref_size
:
23688 case DW_OP_xderef_size
:
23689 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23696 gcc_assert (val1
->val_class
== dw_val_class_loc
);
23697 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
23698 hash
= iterative_hash_object (offset
, hash
);
23701 case DW_OP_implicit_value
:
23702 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
23703 switch (val2
->val_class
)
23705 case dw_val_class_const
:
23706 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23708 case dw_val_class_vec
:
23710 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23711 unsigned int len
= val2
->v
.val_vec
.length
;
23713 hash
= iterative_hash_object (elt_size
, hash
);
23714 hash
= iterative_hash_object (len
, hash
);
23715 hash
= iterative_hash (val2
->v
.val_vec
.array
,
23716 len
* elt_size
, hash
);
23719 case dw_val_class_const_double
:
23720 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
23721 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
23723 case dw_val_class_wide_int
:
23724 hash
= iterative_hash_object (*val2
->v
.val_wide
, hash
);
23726 case dw_val_class_addr
:
23727 hash
= iterative_hash_rtx (val2
->v
.val_addr
, hash
);
23730 gcc_unreachable ();
23734 case DW_OP_bit_piece
:
23735 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23736 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23742 unsigned char dtprel
= 0xd1;
23743 hash
= iterative_hash_object (dtprel
, hash
);
23745 hash
= iterative_hash_rtx (val1
->v
.val_addr
, hash
);
23747 case DW_OP_GNU_addr_index
:
23748 case DW_OP_GNU_const_index
:
23752 unsigned char dtprel
= 0xd1;
23753 hash
= iterative_hash_object (dtprel
, hash
);
23755 hash
= iterative_hash_rtx (val1
->val_entry
->addr
.rtl
, hash
);
23758 case DW_OP_GNU_implicit_pointer
:
23759 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23761 case DW_OP_GNU_entry_value
:
23762 hash
= hash_loc_operands (val1
->v
.val_loc
, hash
);
23764 case DW_OP_GNU_regval_type
:
23765 case DW_OP_GNU_deref_type
:
23767 unsigned int byte_size
23768 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23769 unsigned int encoding
23770 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
23771 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23772 hash
= iterative_hash_object (byte_size
, hash
);
23773 hash
= iterative_hash_object (encoding
, hash
);
23776 case DW_OP_GNU_convert
:
23777 case DW_OP_GNU_reinterpret
:
23778 if (val1
->val_class
== dw_val_class_unsigned_const
)
23780 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
23784 case DW_OP_GNU_const_type
:
23786 unsigned int byte_size
23787 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23788 unsigned int encoding
23789 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
23790 hash
= iterative_hash_object (byte_size
, hash
);
23791 hash
= iterative_hash_object (encoding
, hash
);
23792 if (loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
23794 hash
= iterative_hash_object (val2
->val_class
, hash
);
23795 switch (val2
->val_class
)
23797 case dw_val_class_const
:
23798 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23800 case dw_val_class_vec
:
23802 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23803 unsigned int len
= val2
->v
.val_vec
.length
;
23805 hash
= iterative_hash_object (elt_size
, hash
);
23806 hash
= iterative_hash_object (len
, hash
);
23807 hash
= iterative_hash (val2
->v
.val_vec
.array
,
23808 len
* elt_size
, hash
);
23811 case dw_val_class_const_double
:
23812 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
23813 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
23815 case dw_val_class_wide_int
:
23816 hash
= iterative_hash_object (*val2
->v
.val_wide
, hash
);
23819 gcc_unreachable ();
23825 /* Other codes have no operands. */
23831 /* Iteratively hash the whole DWARF location expression LOC. */
23833 static inline hashval_t
23834 hash_locs (dw_loc_descr_ref loc
, hashval_t hash
)
23836 dw_loc_descr_ref l
;
23837 bool sizes_computed
= false;
23838 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
23839 size_of_locs (loc
);
23841 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
23843 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
23844 hash
= iterative_hash_object (opc
, hash
);
23845 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
23847 size_of_locs (loc
);
23848 sizes_computed
= true;
23850 hash
= hash_loc_operands (l
, hash
);
23855 /* Compute hash of the whole location list LIST_HEAD. */
23858 hash_loc_list (dw_loc_list_ref list_head
)
23860 dw_loc_list_ref curr
= list_head
;
23861 hashval_t hash
= 0;
23863 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
23865 hash
= iterative_hash (curr
->begin
, strlen (curr
->begin
) + 1, hash
);
23866 hash
= iterative_hash (curr
->end
, strlen (curr
->end
) + 1, hash
);
23868 hash
= iterative_hash (curr
->section
, strlen (curr
->section
) + 1,
23870 hash
= hash_locs (curr
->expr
, hash
);
23872 list_head
->hash
= hash
;
23875 /* Return true if X and Y opcodes have the same operands. */
23878 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
23880 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
23881 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
23882 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
23883 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
23885 switch (x
->dw_loc_opc
)
23887 case DW_OP_const4u
:
23888 case DW_OP_const8u
:
23892 case DW_OP_const1u
:
23893 case DW_OP_const1s
:
23894 case DW_OP_const2u
:
23895 case DW_OP_const2s
:
23896 case DW_OP_const4s
:
23897 case DW_OP_const8s
:
23901 case DW_OP_plus_uconst
:
23937 case DW_OP_deref_size
:
23938 case DW_OP_xderef_size
:
23939 return valx1
->v
.val_int
== valy1
->v
.val_int
;
23942 /* If splitting debug info, the use of DW_OP_GNU_addr_index
23943 can cause irrelevant differences in dw_loc_addr. */
23944 gcc_assert (valx1
->val_class
== dw_val_class_loc
23945 && valy1
->val_class
== dw_val_class_loc
23946 && (dwarf_split_debug_info
23947 || x
->dw_loc_addr
== y
->dw_loc_addr
));
23948 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
23949 case DW_OP_implicit_value
:
23950 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
23951 || valx2
->val_class
!= valy2
->val_class
)
23953 switch (valx2
->val_class
)
23955 case dw_val_class_const
:
23956 return valx2
->v
.val_int
== valy2
->v
.val_int
;
23957 case dw_val_class_vec
:
23958 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
23959 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
23960 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
23961 valx2
->v
.val_vec
.elt_size
23962 * valx2
->v
.val_vec
.length
) == 0;
23963 case dw_val_class_const_double
:
23964 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
23965 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
23966 case dw_val_class_wide_int
:
23967 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
23968 case dw_val_class_addr
:
23969 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
23971 gcc_unreachable ();
23974 case DW_OP_bit_piece
:
23975 return valx1
->v
.val_int
== valy1
->v
.val_int
23976 && valx2
->v
.val_int
== valy2
->v
.val_int
;
23979 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
23980 case DW_OP_GNU_addr_index
:
23981 case DW_OP_GNU_const_index
:
23983 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
23984 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
23985 return rtx_equal_p (ax1
, ay1
);
23987 case DW_OP_GNU_implicit_pointer
:
23988 return valx1
->val_class
== dw_val_class_die_ref
23989 && valx1
->val_class
== valy1
->val_class
23990 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
23991 && valx2
->v
.val_int
== valy2
->v
.val_int
;
23992 case DW_OP_GNU_entry_value
:
23993 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
23994 case DW_OP_GNU_const_type
:
23995 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
23996 || valx2
->val_class
!= valy2
->val_class
)
23998 switch (valx2
->val_class
)
24000 case dw_val_class_const
:
24001 return valx2
->v
.val_int
== valy2
->v
.val_int
;
24002 case dw_val_class_vec
:
24003 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
24004 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
24005 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
24006 valx2
->v
.val_vec
.elt_size
24007 * valx2
->v
.val_vec
.length
) == 0;
24008 case dw_val_class_const_double
:
24009 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
24010 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
24011 case dw_val_class_wide_int
:
24012 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
24014 gcc_unreachable ();
24016 case DW_OP_GNU_regval_type
:
24017 case DW_OP_GNU_deref_type
:
24018 return valx1
->v
.val_int
== valy1
->v
.val_int
24019 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
24020 case DW_OP_GNU_convert
:
24021 case DW_OP_GNU_reinterpret
:
24022 if (valx1
->val_class
!= valy1
->val_class
)
24024 if (valx1
->val_class
== dw_val_class_unsigned_const
)
24025 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
24026 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
24027 case DW_OP_GNU_parameter_ref
:
24028 return valx1
->val_class
== dw_val_class_die_ref
24029 && valx1
->val_class
== valy1
->val_class
24030 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
24032 /* Other codes have no operands. */
24037 /* Return true if DWARF location expressions X and Y are the same. */
24040 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
24042 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
24043 if (x
->dw_loc_opc
!= y
->dw_loc_opc
24044 || x
->dtprel
!= y
->dtprel
24045 || !compare_loc_operands (x
, y
))
24047 return x
== NULL
&& y
== NULL
;
24050 /* Hashtable helpers. */
24052 struct loc_list_hasher
: typed_noop_remove
<dw_loc_list_struct
>
24054 typedef dw_loc_list_struct value_type
;
24055 typedef dw_loc_list_struct compare_type
;
24056 static inline hashval_t
hash (const value_type
*);
24057 static inline bool equal (const value_type
*, const compare_type
*);
24060 /* Return precomputed hash of location list X. */
24063 loc_list_hasher::hash (const value_type
*x
)
24068 /* Return true if location lists A and B are the same. */
24071 loc_list_hasher::equal (const value_type
*a
, const compare_type
*b
)
24075 if (a
->hash
!= b
->hash
)
24077 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
24078 if (strcmp (a
->begin
, b
->begin
) != 0
24079 || strcmp (a
->end
, b
->end
) != 0
24080 || (a
->section
== NULL
) != (b
->section
== NULL
)
24081 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
24082 || !compare_locs (a
->expr
, b
->expr
))
24084 return a
== NULL
&& b
== NULL
;
24087 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
24090 /* Recursively optimize location lists referenced from DIE
24091 children and share them whenever possible. */
24094 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type htab
)
24099 dw_loc_list_struct
**slot
;
24101 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
24102 if (AT_class (a
) == dw_val_class_loc_list
)
24104 dw_loc_list_ref list
= AT_loc_list (a
);
24105 /* TODO: perform some optimizations here, before hashing
24106 it and storing into the hash table. */
24107 hash_loc_list (list
);
24108 slot
= htab
.find_slot_with_hash (list
, list
->hash
, INSERT
);
24112 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
24115 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
24119 /* Recursively assign each location list a unique index into the debug_addr
24123 index_location_lists (dw_die_ref die
)
24129 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
24130 if (AT_class (a
) == dw_val_class_loc_list
)
24132 dw_loc_list_ref list
= AT_loc_list (a
);
24133 dw_loc_list_ref curr
;
24134 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
24136 /* Don't index an entry that has already been indexed
24137 or won't be output. */
24138 if (curr
->begin_entry
!= NULL
24139 || (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
))
24143 = add_addr_table_entry (xstrdup (curr
->begin
),
24148 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
24151 /* Optimize location lists referenced from DIE
24152 children and share them whenever possible. */
24155 optimize_location_lists (dw_die_ref die
)
24157 loc_list_hash_type htab
;
24159 optimize_location_lists_1 (die
, htab
);
24163 /* Output stuff that dwarf requires at the end of every file,
24164 and generate the DWARF-2 debugging info. */
24167 dwarf2out_finish (const char *filename
)
24169 limbo_die_node
*node
, *next_node
;
24170 comdat_type_node
*ctnode
;
24171 hash_table
<comdat_type_hasher
> comdat_type_table
;
24173 dw_die_ref main_comp_unit_die
;
24175 /* PCH might result in DW_AT_producer string being restored from the
24176 header compilation, so always fill it with empty string initially
24177 and overwrite only here. */
24178 dw_attr_ref producer
= get_AT (comp_unit_die (), DW_AT_producer
);
24179 producer_string
= gen_producer_string ();
24180 producer
->dw_attr_val
.v
.val_str
->refcount
--;
24181 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
24183 gen_scheduled_generic_parms_dies ();
24184 gen_remaining_tmpl_value_param_die_attribute ();
24186 /* Add the name for the main input file now. We delayed this from
24187 dwarf2out_init to avoid complications with PCH. */
24188 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
24189 if (!IS_ABSOLUTE_PATH (filename
) || targetm
.force_at_comp_dir
)
24190 add_comp_dir_attribute (comp_unit_die ());
24191 else if (get_AT (comp_unit_die (), DW_AT_comp_dir
) == NULL
)
24194 htab_traverse (file_table
, file_table_relative_p
, &p
);
24196 add_comp_dir_attribute (comp_unit_die ());
24199 if (deferred_locations_list
)
24200 for (i
= 0; i
< deferred_locations_list
->length (); i
++)
24202 add_location_or_const_value_attribute (
24203 (*deferred_locations_list
)[i
].die
,
24204 (*deferred_locations_list
)[i
].variable
,
24209 /* Traverse the limbo die list, and add parent/child links. The only
24210 dies without parents that should be here are concrete instances of
24211 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
24212 For concrete instances, we can get the parent die from the abstract
24214 for (node
= limbo_die_list
; node
; node
= next_node
)
24216 dw_die_ref die
= node
->die
;
24217 next_node
= node
->next
;
24219 if (die
->die_parent
== NULL
)
24221 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
24223 if (origin
&& origin
->die_parent
)
24224 add_child_die (origin
->die_parent
, die
);
24225 else if (is_cu_die (die
))
24227 else if (seen_error ())
24228 /* It's OK to be confused by errors in the input. */
24229 add_child_die (comp_unit_die (), die
);
24232 /* In certain situations, the lexical block containing a
24233 nested function can be optimized away, which results
24234 in the nested function die being orphaned. Likewise
24235 with the return type of that nested function. Force
24236 this to be a child of the containing function.
24238 It may happen that even the containing function got fully
24239 inlined and optimized out. In that case we are lost and
24240 assign the empty child. This should not be big issue as
24241 the function is likely unreachable too. */
24242 gcc_assert (node
->created_for
);
24244 if (DECL_P (node
->created_for
))
24245 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
24246 else if (TYPE_P (node
->created_for
))
24247 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
24249 origin
= comp_unit_die ();
24251 add_child_die (origin
, die
);
24256 limbo_die_list
= NULL
;
24258 #if ENABLE_ASSERT_CHECKING
24260 dw_die_ref die
= comp_unit_die (), c
;
24261 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
24264 resolve_addr (comp_unit_die ());
24265 move_marked_base_types ();
24267 for (node
= deferred_asm_name
; node
; node
= node
->next
)
24269 tree decl
= node
->created_for
;
24270 /* When generating LTO bytecode we can not generate new assembler
24271 names at this point and all important decls got theirs via
24273 if ((!flag_generate_lto
|| DECL_ASSEMBLER_NAME_SET_P (decl
))
24274 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
24276 add_linkage_attr (node
->die
, decl
);
24277 move_linkage_attr (node
->die
);
24281 deferred_asm_name
= NULL
;
24283 /* Walk through the list of incomplete types again, trying once more to
24284 emit full debugging info for them. */
24285 retry_incomplete_types ();
24287 if (flag_eliminate_unused_debug_types
)
24288 prune_unused_types ();
24290 /* Generate separate COMDAT sections for type DIEs. */
24291 if (use_debug_types
)
24293 break_out_comdat_types (comp_unit_die ());
24295 /* Each new type_unit DIE was added to the limbo die list when created.
24296 Since these have all been added to comdat_type_list, clear the
24298 limbo_die_list
= NULL
;
24300 /* For each new comdat type unit, copy declarations for incomplete
24301 types to make the new unit self-contained (i.e., no direct
24302 references to the main compile unit). */
24303 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24304 copy_decls_for_unworthy_types (ctnode
->root_die
);
24305 copy_decls_for_unworthy_types (comp_unit_die ());
24307 /* In the process of copying declarations from one unit to another,
24308 we may have left some declarations behind that are no longer
24309 referenced. Prune them. */
24310 prune_unused_types ();
24313 /* Generate separate CUs for each of the include files we've seen.
24314 They will go into limbo_die_list. */
24315 if (flag_eliminate_dwarf2_dups
)
24316 break_out_includes (comp_unit_die ());
24318 /* Traverse the DIE's and add add sibling attributes to those DIE's
24319 that have children. */
24320 add_sibling_attributes (comp_unit_die ());
24321 for (node
= limbo_die_list
; node
; node
= node
->next
)
24322 add_sibling_attributes (node
->die
);
24323 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24324 add_sibling_attributes (ctnode
->root_die
);
24326 /* When splitting DWARF info, we put some attributes in the
24327 skeleton compile_unit DIE that remains in the .o, while
24328 most attributes go in the DWO compile_unit_die. */
24329 if (dwarf_split_debug_info
)
24330 main_comp_unit_die
= gen_compile_unit_die (NULL
);
24332 main_comp_unit_die
= comp_unit_die ();
24334 /* Output a terminator label for the .text section. */
24335 switch_to_section (text_section
);
24336 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
24337 if (cold_text_section
)
24339 switch_to_section (cold_text_section
);
24340 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
24343 /* We can only use the low/high_pc attributes if all of the code was
24345 if (!have_multiple_function_sections
24346 || (dwarf_version
< 3 && dwarf_strict
))
24348 /* Don't add if the CU has no associated code. */
24349 if (text_section_used
)
24350 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
24351 text_end_label
, true);
24357 bool range_list_added
= false;
24359 if (text_section_used
)
24360 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
24361 text_end_label
, &range_list_added
, true);
24362 if (cold_text_section_used
)
24363 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
24364 cold_end_label
, &range_list_added
, true);
24366 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
24368 if (DECL_IGNORED_P (fde
->decl
))
24370 if (!fde
->in_std_section
)
24371 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
24372 fde
->dw_fde_end
, &range_list_added
,
24374 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
24375 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
24376 fde
->dw_fde_second_end
, &range_list_added
,
24380 if (range_list_added
)
24382 /* We need to give .debug_loc and .debug_ranges an appropriate
24383 "base address". Use zero so that these addresses become
24384 absolute. Historically, we've emitted the unexpected
24385 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24386 Emit both to give time for other tools to adapt. */
24387 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
24388 if (! dwarf_strict
&& dwarf_version
< 4)
24389 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
24395 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24396 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
24397 debug_line_section_label
);
24400 add_AT_macptr (comp_unit_die (),
24401 dwarf_strict
? DW_AT_macro_info
: DW_AT_GNU_macros
,
24402 macinfo_section_label
);
24404 if (dwarf_split_debug_info
&& addr_index_table
!= NULL
)
24406 /* optimize_location_lists calculates the size of the lists,
24407 so index them first, and assign indices to the entries.
24408 Although optimize_location_lists will remove entries from
24409 the table, it only does so for duplicates, and therefore
24410 only reduces ref_counts to 1. */
24411 unsigned int index
= 0;
24412 index_location_lists (comp_unit_die ());
24413 htab_traverse_noresize (addr_index_table
,
24414 index_addr_table_entry
, &index
);
24416 if (have_location_lists
)
24417 optimize_location_lists (comp_unit_die ());
24419 save_macinfo_strings ();
24421 if (dwarf_split_debug_info
)
24423 unsigned int index
= 0;
24425 /* Add attributes common to skeleton compile_units and
24426 type_units. Because these attributes include strings, it
24427 must be done before freezing the string table. Top-level
24428 skeleton die attrs are added when the skeleton type unit is
24429 created, so ensure it is created by this point. */
24430 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
24431 (void) get_skeleton_type_unit ();
24432 htab_traverse_noresize (debug_str_hash
, index_string
, &index
);
24435 /* Output all of the compilation units. We put the main one last so that
24436 the offsets are available to output_pubnames. */
24437 for (node
= limbo_die_list
; node
; node
= node
->next
)
24438 output_comp_unit (node
->die
, 0);
24440 comdat_type_table
.create (100);
24441 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24443 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
24445 /* Don't output duplicate types. */
24446 if (*slot
!= HTAB_EMPTY_ENTRY
)
24449 /* Add a pointer to the line table for the main compilation unit
24450 so that the debugger can make sense of DW_AT_decl_file
24452 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24453 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
24454 (!dwarf_split_debug_info
24455 ? debug_line_section_label
24456 : debug_skeleton_line_section_label
));
24458 output_comdat_type_unit (ctnode
);
24461 comdat_type_table
.dispose ();
24463 /* The AT_pubnames attribute needs to go in all skeleton dies, including
24464 both the main_cu and all skeleton TUs. Making this call unconditional
24465 would end up either adding a second copy of the AT_pubnames attribute, or
24466 requiring a special case in add_top_level_skeleton_die_attrs. */
24467 if (!dwarf_split_debug_info
)
24468 add_AT_pubnames (comp_unit_die ());
24470 if (dwarf_split_debug_info
)
24473 unsigned char checksum
[16];
24474 struct md5_ctx ctx
;
24476 /* Compute a checksum of the comp_unit to use as the dwo_id. */
24477 md5_init_ctx (&ctx
);
24479 die_checksum (comp_unit_die (), &ctx
, &mark
);
24480 unmark_all_dies (comp_unit_die ());
24481 md5_finish_ctx (&ctx
, checksum
);
24483 /* Use the first 8 bytes of the checksum as the dwo_id,
24484 and add it to both comp-unit DIEs. */
24485 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
24486 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
24488 /* Add the base offset of the ranges table to the skeleton
24490 if (ranges_table_in_use
)
24491 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
24492 ranges_section_label
);
24494 switch_to_section (debug_addr_section
);
24495 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
24496 output_addr_table ();
24499 /* Output the main compilation unit if non-empty or if .debug_macinfo
24500 or .debug_macro will be emitted. */
24501 output_comp_unit (comp_unit_die (), have_macinfo
);
24503 if (dwarf_split_debug_info
&& info_section_emitted
)
24504 output_skeleton_debug_sections (main_comp_unit_die
);
24506 /* Output the abbreviation table. */
24507 if (abbrev_die_table_in_use
!= 1)
24509 switch_to_section (debug_abbrev_section
);
24510 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
24511 output_abbrev_section ();
24514 /* Output location list section if necessary. */
24515 if (have_location_lists
)
24517 /* Output the location lists info. */
24518 switch_to_section (debug_loc_section
);
24519 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
24520 output_location_lists (comp_unit_die ());
24523 output_pubtables ();
24525 /* Output the address range information if a CU (.debug_info section)
24526 was emitted. We output an empty table even if we had no functions
24527 to put in it. This because the consumer has no way to tell the
24528 difference between an empty table that we omitted and failure to
24529 generate a table that would have contained data. */
24530 if (info_section_emitted
)
24532 unsigned long aranges_length
= size_of_aranges ();
24534 switch_to_section (debug_aranges_section
);
24535 output_aranges (aranges_length
);
24538 /* Output ranges section if necessary. */
24539 if (ranges_table_in_use
)
24541 switch_to_section (debug_ranges_section
);
24542 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
24546 /* Have to end the macro section. */
24549 switch_to_section (debug_macinfo_section
);
24550 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
24552 dw2_asm_output_data (1, 0, "End compilation unit");
24555 /* Output the source line correspondence table. We must do this
24556 even if there is no line information. Otherwise, on an empty
24557 translation unit, we will generate a present, but empty,
24558 .debug_info section. IRIX 6.5 `nm' will then complain when
24559 examining the file. This is done late so that any filenames
24560 used by the debug_info section are marked as 'used'. */
24561 switch_to_section (debug_line_section
);
24562 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
24563 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
24564 output_line_info (false);
24566 if (dwarf_split_debug_info
&& info_section_emitted
)
24568 switch_to_section (debug_skeleton_line_section
);
24569 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
24570 output_line_info (true);
24573 /* If we emitted any indirect strings, output the string table too. */
24574 if (debug_str_hash
|| skeleton_debug_str_hash
)
24575 output_indirect_strings ();
24578 #include "gt-dwarf2out.h"