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"
75 #include "insn-config.h"
82 #include "dwarf2out.h"
83 #include "dwarf2asm.h"
87 #include "diagnostic.h"
88 #include "tree-pretty-print.h"
91 #include "common/common-target.h"
92 #include "langhooks.h"
100 #include "gdb/gdb-index.h"
101 #include "rtl-iter.h"
103 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
104 static rtx_insn
*last_var_location_insn
;
105 static rtx_insn
*cached_next_real_insn
;
106 static void dwarf2out_decl (tree
);
108 #ifdef VMS_DEBUGGING_INFO
109 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
111 /* Define this macro to be a nonzero value if the directory specifications
112 which are output in the debug info should end with a separator. */
113 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
114 /* Define this macro to evaluate to a nonzero value if GCC should refrain
115 from generating indirect strings in DWARF2 debug information, for instance
116 if your target is stuck with an old version of GDB that is unable to
117 process them properly or uses VMS Debug. */
118 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
120 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
121 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
124 /* ??? Poison these here until it can be done generically. They've been
125 totally replaced in this file; make sure it stays that way. */
126 #undef DWARF2_UNWIND_INFO
127 #undef DWARF2_FRAME_INFO
128 #if (GCC_VERSION >= 3000)
129 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
132 /* The size of the target's pointer type. */
134 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
137 /* Array of RTXes referenced by the debugging information, which therefore
138 must be kept around forever. */
139 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
141 /* A pointer to the base of a list of incomplete types which might be
142 completed at some later time. incomplete_types_list needs to be a
143 vec<tree, va_gc> *because we want to tell the garbage collector about
145 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
147 /* A pointer to the base of a table of references to declaration
148 scopes. This table is a display which tracks the nesting
149 of declaration scopes at the current scope and containing
150 scopes. This table is used to find the proper place to
151 define type declaration DIE's. */
152 static GTY(()) vec
<tree
, va_gc
> *decl_scope_table
;
154 /* Pointers to various DWARF2 sections. */
155 static GTY(()) section
*debug_info_section
;
156 static GTY(()) section
*debug_skeleton_info_section
;
157 static GTY(()) section
*debug_abbrev_section
;
158 static GTY(()) section
*debug_skeleton_abbrev_section
;
159 static GTY(()) section
*debug_aranges_section
;
160 static GTY(()) section
*debug_addr_section
;
161 static GTY(()) section
*debug_macinfo_section
;
162 static GTY(()) section
*debug_line_section
;
163 static GTY(()) section
*debug_skeleton_line_section
;
164 static GTY(()) section
*debug_loc_section
;
165 static GTY(()) section
*debug_pubnames_section
;
166 static GTY(()) section
*debug_pubtypes_section
;
167 static GTY(()) section
*debug_str_section
;
168 static GTY(()) section
*debug_str_dwo_section
;
169 static GTY(()) section
*debug_str_offsets_section
;
170 static GTY(()) section
*debug_ranges_section
;
171 static GTY(()) section
*debug_frame_section
;
173 /* Maximum size (in bytes) of an artificially generated label. */
174 #define MAX_ARTIFICIAL_LABEL_BYTES 30
176 /* According to the (draft) DWARF 3 specification, the initial length
177 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
178 bytes are 0xffffffff, followed by the length stored in the next 8
181 However, the SGI/MIPS ABI uses an initial length which is equal to
182 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
184 #ifndef DWARF_INITIAL_LENGTH_SIZE
185 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
188 /* Round SIZE up to the nearest BOUNDARY. */
189 #define DWARF_ROUND(SIZE,BOUNDARY) \
190 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
192 /* CIE identifier. */
193 #if HOST_BITS_PER_WIDE_INT >= 64
194 #define DWARF_CIE_ID \
195 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
197 #define DWARF_CIE_ID DW_CIE_ID
201 /* A vector for a table that contains frame description
202 information for each routine. */
203 #define NOT_INDEXED (-1U)
204 #define NO_INDEX_ASSIGNED (-2U)
206 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
208 struct GTY(()) indirect_string_node
{
210 unsigned int refcount
;
211 enum dwarf_form form
;
216 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
218 /* With split_debug_info, both the comp_dir and dwo_name go in the
219 main object file, rather than the dwo, similar to the force_direct
220 parameter elsewhere but with additional complications:
222 1) The string is needed in both the main object file and the dwo.
223 That is, the comp_dir and dwo_name will appear in both places.
225 2) Strings can use three forms: DW_FORM_string, DW_FORM_strp or
226 DW_FORM_GNU_str_index.
228 3) GCC chooses the form to use late, depending on the size and
231 Rather than forcing the all debug string handling functions and
232 callers to deal with these complications, simply use a separate,
233 special-cased string table for any attribute that should go in the
234 main object file. This limits the complexity to just the places
237 static GTY ((param_is (struct indirect_string_node
)))
238 htab_t skeleton_debug_str_hash
;
240 static GTY(()) int dw2_string_counter
;
242 /* True if the compilation unit places functions in more than one section. */
243 static GTY(()) bool have_multiple_function_sections
= false;
245 /* Whether the default text and cold text sections have been used at all. */
247 static GTY(()) bool text_section_used
= false;
248 static GTY(()) bool cold_text_section_used
= false;
250 /* The default cold text section. */
251 static GTY(()) section
*cold_text_section
;
253 /* The DIE for C++14 'auto' in a function return type. */
254 static GTY(()) dw_die_ref auto_die
;
256 /* The DIE for C++14 'decltype(auto)' in a function return type. */
257 static GTY(()) dw_die_ref decltype_auto_die
;
259 /* Forward declarations for functions defined in this file. */
261 static char *stripattributes (const char *);
262 static void output_call_frame_info (int);
263 static void dwarf2out_note_section_used (void);
265 /* Personality decl of current unit. Used only when assembler does not support
267 static GTY(()) rtx current_unit_personality
;
269 /* Data and reference forms for relocatable data. */
270 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
271 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
273 #ifndef DEBUG_FRAME_SECTION
274 #define DEBUG_FRAME_SECTION ".debug_frame"
277 #ifndef FUNC_BEGIN_LABEL
278 #define FUNC_BEGIN_LABEL "LFB"
281 #ifndef FUNC_END_LABEL
282 #define FUNC_END_LABEL "LFE"
285 #ifndef PROLOGUE_END_LABEL
286 #define PROLOGUE_END_LABEL "LPE"
289 #ifndef EPILOGUE_BEGIN_LABEL
290 #define EPILOGUE_BEGIN_LABEL "LEB"
293 #ifndef FRAME_BEGIN_LABEL
294 #define FRAME_BEGIN_LABEL "Lframe"
296 #define CIE_AFTER_SIZE_LABEL "LSCIE"
297 #define CIE_END_LABEL "LECIE"
298 #define FDE_LABEL "LSFDE"
299 #define FDE_AFTER_SIZE_LABEL "LASFDE"
300 #define FDE_END_LABEL "LEFDE"
301 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
302 #define LINE_NUMBER_END_LABEL "LELT"
303 #define LN_PROLOG_AS_LABEL "LASLTP"
304 #define LN_PROLOG_END_LABEL "LELTP"
305 #define DIE_LABEL_PREFIX "DW"
307 /* Match the base name of a file to the base name of a compilation unit. */
310 matches_main_base (const char *path
)
312 /* Cache the last query. */
313 static const char *last_path
= NULL
;
314 static int last_match
= 0;
315 if (path
!= last_path
)
318 int length
= base_of_path (path
, &base
);
320 last_match
= (length
== main_input_baselength
321 && memcmp (base
, main_input_basename
, length
) == 0);
326 #ifdef DEBUG_DEBUG_STRUCT
329 dump_struct_debug (tree type
, enum debug_info_usage usage
,
330 enum debug_struct_file criterion
, int generic
,
331 int matches
, int result
)
333 /* Find the type name. */
334 tree type_decl
= TYPE_STUB_DECL (type
);
336 const char *name
= 0;
337 if (TREE_CODE (t
) == TYPE_DECL
)
340 name
= IDENTIFIER_POINTER (t
);
342 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
344 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
345 matches
? "bas" : "hdr",
346 generic
? "gen" : "ord",
347 usage
== DINFO_USAGE_DFN
? ";" :
348 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
350 (void*) type_decl
, name
);
353 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
354 dump_struct_debug (type, usage, criterion, generic, matches, result)
358 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
363 /* Get the number of HOST_WIDE_INTs needed to represent the precision
367 get_full_len (const wide_int
&op
)
369 return ((op
.get_precision () + HOST_BITS_PER_WIDE_INT
- 1)
370 / HOST_BITS_PER_WIDE_INT
);
374 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
376 enum debug_struct_file criterion
;
378 bool generic
= lang_hooks
.types
.generic_p (type
);
381 criterion
= debug_struct_generic
[usage
];
383 criterion
= debug_struct_ordinary
[usage
];
385 if (criterion
== DINFO_STRUCT_FILE_NONE
)
386 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
387 if (criterion
== DINFO_STRUCT_FILE_ANY
)
388 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
390 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
392 if (type_decl
!= NULL
)
394 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
395 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
397 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
398 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
401 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
404 /* Return a pointer to a copy of the section string name S with all
405 attributes stripped off, and an asterisk prepended (for assemble_name). */
408 stripattributes (const char *s
)
410 char *stripped
= XNEWVEC (char, strlen (s
) + 2);
415 while (*s
&& *s
!= ',')
422 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
423 switch to the data section instead, and write out a synthetic start label
424 for collect2 the first time around. */
427 switch_to_eh_frame_section (bool back
)
431 #ifdef EH_FRAME_SECTION_NAME
432 if (eh_frame_section
== 0)
436 if (EH_TABLES_CAN_BE_READ_ONLY
)
442 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
444 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
446 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
449 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
450 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
451 && (per_encoding
& 0x70) != DW_EH_PE_absptr
452 && (per_encoding
& 0x70) != DW_EH_PE_aligned
453 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
454 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
455 ? 0 : SECTION_WRITE
);
458 flags
= SECTION_WRITE
;
459 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
461 #endif /* EH_FRAME_SECTION_NAME */
463 if (eh_frame_section
)
464 switch_to_section (eh_frame_section
);
467 /* We have no special eh_frame section. Put the information in
468 the data section and emit special labels to guide collect2. */
469 switch_to_section (data_section
);
473 label
= get_file_function_name ("F");
474 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
475 targetm
.asm_out
.globalize_label (asm_out_file
,
476 IDENTIFIER_POINTER (label
));
477 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
482 /* Switch [BACK] to the eh or debug frame table section, depending on
486 switch_to_frame_table_section (int for_eh
, bool back
)
489 switch_to_eh_frame_section (back
);
492 if (!debug_frame_section
)
493 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
494 SECTION_DEBUG
, NULL
);
495 switch_to_section (debug_frame_section
);
499 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
501 enum dw_cfi_oprnd_type
502 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
507 case DW_CFA_GNU_window_save
:
508 case DW_CFA_remember_state
:
509 case DW_CFA_restore_state
:
510 return dw_cfi_oprnd_unused
;
513 case DW_CFA_advance_loc1
:
514 case DW_CFA_advance_loc2
:
515 case DW_CFA_advance_loc4
:
516 case DW_CFA_MIPS_advance_loc8
:
517 return dw_cfi_oprnd_addr
;
520 case DW_CFA_offset_extended
:
522 case DW_CFA_offset_extended_sf
:
523 case DW_CFA_def_cfa_sf
:
525 case DW_CFA_restore_extended
:
526 case DW_CFA_undefined
:
527 case DW_CFA_same_value
:
528 case DW_CFA_def_cfa_register
:
529 case DW_CFA_register
:
530 case DW_CFA_expression
:
531 return dw_cfi_oprnd_reg_num
;
533 case DW_CFA_def_cfa_offset
:
534 case DW_CFA_GNU_args_size
:
535 case DW_CFA_def_cfa_offset_sf
:
536 return dw_cfi_oprnd_offset
;
538 case DW_CFA_def_cfa_expression
:
539 return dw_cfi_oprnd_loc
;
546 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
548 enum dw_cfi_oprnd_type
549 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
554 case DW_CFA_def_cfa_sf
:
556 case DW_CFA_offset_extended_sf
:
557 case DW_CFA_offset_extended
:
558 return dw_cfi_oprnd_offset
;
560 case DW_CFA_register
:
561 return dw_cfi_oprnd_reg_num
;
563 case DW_CFA_expression
:
564 return dw_cfi_oprnd_loc
;
567 return dw_cfi_oprnd_unused
;
571 /* Output one FDE. */
574 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
575 char *section_start_label
, int fde_encoding
, char *augmentation
,
576 bool any_lsda_needed
, int lsda_encoding
)
578 const char *begin
, *end
;
579 static unsigned int j
;
582 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
584 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
586 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
587 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
588 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
589 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
590 " indicating 64-bit DWARF extension");
591 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
593 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
596 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
598 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
599 debug_frame_section
, "FDE CIE offset");
601 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
602 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
606 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
607 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
608 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
609 "FDE initial location");
610 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
611 end
, begin
, "FDE address range");
615 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
616 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
623 int size
= size_of_encoded_value (lsda_encoding
);
625 if (lsda_encoding
== DW_EH_PE_aligned
)
627 int offset
= ( 4 /* Length */
629 + 2 * size_of_encoded_value (fde_encoding
)
630 + 1 /* Augmentation size */ );
631 int pad
= -offset
& (PTR_SIZE
- 1);
634 gcc_assert (size_of_uleb128 (size
) == 1);
637 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
639 if (fde
->uses_eh_lsda
)
641 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
642 fde
->funcdef_number
);
643 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
644 gen_rtx_SYMBOL_REF (Pmode
, l1
),
646 "Language Specific Data Area");
650 if (lsda_encoding
== DW_EH_PE_aligned
)
651 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
652 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
653 "Language Specific Data Area (none)");
657 dw2_asm_output_data_uleb128 (0, "Augmentation size");
660 /* Loop through the Call Frame Instructions associated with this FDE. */
661 fde
->dw_fde_current_label
= begin
;
663 size_t from
, until
, i
;
666 until
= vec_safe_length (fde
->dw_fde_cfi
);
668 if (fde
->dw_fde_second_begin
== NULL
)
671 until
= fde
->dw_fde_switch_cfi_index
;
673 from
= fde
->dw_fde_switch_cfi_index
;
675 for (i
= from
; i
< until
; i
++)
676 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
679 /* If we are to emit a ref/link from function bodies to their frame tables,
680 do it now. This is typically performed to make sure that tables
681 associated with functions are dragged with them and not discarded in
682 garbage collecting links. We need to do this on a per function basis to
683 cope with -ffunction-sections. */
685 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
686 /* Switch to the function section, emit the ref to the tables, and
687 switch *back* into the table section. */
688 switch_to_section (function_section (fde
->decl
));
689 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
690 switch_to_frame_table_section (for_eh
, true);
693 /* Pad the FDE out to an address sized boundary. */
694 ASM_OUTPUT_ALIGN (asm_out_file
,
695 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
696 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
701 /* Return true if frame description entry FDE is needed for EH. */
704 fde_needed_for_eh_p (dw_fde_ref fde
)
706 if (flag_asynchronous_unwind_tables
)
709 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
712 if (fde
->uses_eh_lsda
)
715 /* If exceptions are enabled, we have collected nothrow info. */
716 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
722 /* Output the call frame information used to record information
723 that relates to calculating the frame pointer, and records the
724 location of saved registers. */
727 output_call_frame_info (int for_eh
)
732 char l1
[20], l2
[20], section_start_label
[20];
733 bool any_lsda_needed
= false;
734 char augmentation
[6];
735 int augmentation_size
;
736 int fde_encoding
= DW_EH_PE_absptr
;
737 int per_encoding
= DW_EH_PE_absptr
;
738 int lsda_encoding
= DW_EH_PE_absptr
;
740 rtx personality
= NULL
;
743 /* Don't emit a CIE if there won't be any FDEs. */
747 /* Nothing to do if the assembler's doing it all. */
748 if (dwarf2out_do_cfi_asm ())
751 /* If we don't have any functions we'll want to unwind out of, don't emit
752 any EH unwind information. If we make FDEs linkonce, we may have to
753 emit an empty label for an FDE that wouldn't otherwise be emitted. We
754 want to avoid having an FDE kept around when the function it refers to
755 is discarded. Example where this matters: a primary function template
756 in C++ requires EH information, an explicit specialization doesn't. */
759 bool any_eh_needed
= false;
761 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
763 if (fde
->uses_eh_lsda
)
764 any_eh_needed
= any_lsda_needed
= true;
765 else if (fde_needed_for_eh_p (fde
))
766 any_eh_needed
= true;
767 else if (TARGET_USES_WEAK_UNWIND_INFO
)
768 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
775 /* We're going to be generating comments, so turn on app. */
779 /* Switch to the proper frame section, first time. */
780 switch_to_frame_table_section (for_eh
, false);
782 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
783 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
785 /* Output the CIE. */
786 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
787 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
788 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
789 dw2_asm_output_data (4, 0xffffffff,
790 "Initial length escape value indicating 64-bit DWARF extension");
791 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
792 "Length of Common Information Entry");
793 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
795 /* Now that the CIE pointer is PC-relative for EH,
796 use 0 to identify the CIE. */
797 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
798 (for_eh
? 0 : DWARF_CIE_ID
),
799 "CIE Identifier Tag");
801 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
802 use CIE version 1, unless that would produce incorrect results
803 due to overflowing the return register column. */
804 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
806 if (return_reg
>= 256 || dwarf_version
> 2)
808 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
811 augmentation_size
= 0;
813 personality
= current_unit_personality
;
819 z Indicates that a uleb128 is present to size the
820 augmentation section.
821 L Indicates the encoding (and thus presence) of
822 an LSDA pointer in the FDE augmentation.
823 R Indicates a non-default pointer encoding for
825 P Indicates the presence of an encoding + language
826 personality routine in the CIE augmentation. */
828 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
829 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
830 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
832 p
= augmentation
+ 1;
836 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
837 assemble_external_libcall (personality
);
842 augmentation_size
+= 1;
844 if (fde_encoding
!= DW_EH_PE_absptr
)
847 augmentation_size
+= 1;
849 if (p
> augmentation
+ 1)
851 augmentation
[0] = 'z';
855 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
856 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
858 int offset
= ( 4 /* Length */
860 + 1 /* CIE version */
861 + strlen (augmentation
) + 1 /* Augmentation */
862 + size_of_uleb128 (1) /* Code alignment */
863 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
865 + 1 /* Augmentation size */
866 + 1 /* Personality encoding */ );
867 int pad
= -offset
& (PTR_SIZE
- 1);
869 augmentation_size
+= pad
;
871 /* Augmentations should be small, so there's scarce need to
872 iterate for a solution. Die if we exceed one uleb128 byte. */
873 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
877 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
878 if (dw_cie_version
>= 4)
880 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
881 dw2_asm_output_data (1, 0, "CIE Segment Size");
883 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
884 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
885 "CIE Data Alignment Factor");
887 if (dw_cie_version
== 1)
888 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
890 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
894 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
897 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
898 eh_data_format_name (per_encoding
));
899 dw2_asm_output_encoded_addr_rtx (per_encoding
,
905 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
906 eh_data_format_name (lsda_encoding
));
908 if (fde_encoding
!= DW_EH_PE_absptr
)
909 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
910 eh_data_format_name (fde_encoding
));
913 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
914 output_cfi (cfi
, NULL
, for_eh
);
916 /* Pad the CIE out to an address sized boundary. */
917 ASM_OUTPUT_ALIGN (asm_out_file
,
918 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
919 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
921 /* Loop through all of the FDE's. */
922 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
926 /* Don't emit EH unwind info for leaf functions that don't need it. */
927 if (for_eh
&& !fde_needed_for_eh_p (fde
))
930 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
931 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
932 augmentation
, any_lsda_needed
, lsda_encoding
);
935 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
936 dw2_asm_output_data (4, 0, "End of Table");
938 /* Turn off app to make assembly quicker. */
943 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
946 dwarf2out_do_cfi_startproc (bool second
)
950 rtx personality
= get_personality_function (current_function_decl
);
952 fprintf (asm_out_file
, "\t.cfi_startproc\n");
956 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
959 /* ??? The GAS support isn't entirely consistent. We have to
960 handle indirect support ourselves, but PC-relative is done
961 in the assembler. Further, the assembler can't handle any
962 of the weirder relocation types. */
963 if (enc
& DW_EH_PE_indirect
)
964 ref
= dw2_force_const_mem (ref
, true);
966 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
967 output_addr_const (asm_out_file
, ref
);
968 fputc ('\n', asm_out_file
);
971 if (crtl
->uses_eh_lsda
)
975 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
976 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
977 current_function_funcdef_no
);
978 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
979 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
981 if (enc
& DW_EH_PE_indirect
)
982 ref
= dw2_force_const_mem (ref
, true);
984 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
985 output_addr_const (asm_out_file
, ref
);
986 fputc ('\n', asm_out_file
);
990 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
991 this allocation may be done before pass_final. */
994 dwarf2out_alloc_current_fde (void)
998 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
999 fde
->decl
= current_function_decl
;
1000 fde
->funcdef_number
= current_function_funcdef_no
;
1001 fde
->fde_index
= vec_safe_length (fde_vec
);
1002 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1003 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1004 fde
->nothrow
= crtl
->nothrow
;
1005 fde
->drap_reg
= INVALID_REGNUM
;
1006 fde
->vdrap_reg
= INVALID_REGNUM
;
1008 /* Record the FDE associated with this function. */
1010 vec_safe_push (fde_vec
, fde
);
1015 /* Output a marker (i.e. a label) for the beginning of a function, before
1019 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1020 const char *file ATTRIBUTE_UNUSED
)
1022 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1028 current_function_func_begin_label
= NULL
;
1030 do_frame
= dwarf2out_do_frame ();
1032 /* ??? current_function_func_begin_label is also used by except.c for
1033 call-site information. We must emit this label if it might be used. */
1035 && (!flag_exceptions
1036 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1039 fnsec
= function_section (current_function_decl
);
1040 switch_to_section (fnsec
);
1041 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1042 current_function_funcdef_no
);
1043 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1044 current_function_funcdef_no
);
1045 dup_label
= xstrdup (label
);
1046 current_function_func_begin_label
= dup_label
;
1048 /* We can elide the fde allocation if we're not emitting debug info. */
1052 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1053 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1054 would include pass_dwarf2_frame. If we've not created the FDE yet,
1058 fde
= dwarf2out_alloc_current_fde ();
1060 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1061 fde
->dw_fde_begin
= dup_label
;
1062 fde
->dw_fde_current_label
= dup_label
;
1063 fde
->in_std_section
= (fnsec
== text_section
1064 || (cold_text_section
&& fnsec
== cold_text_section
));
1066 /* We only want to output line number information for the genuine dwarf2
1067 prologue case, not the eh frame case. */
1068 #ifdef DWARF2_DEBUGGING_INFO
1070 dwarf2out_source_line (line
, file
, 0, true);
1073 if (dwarf2out_do_cfi_asm ())
1074 dwarf2out_do_cfi_startproc (false);
1077 rtx personality
= get_personality_function (current_function_decl
);
1078 if (!current_unit_personality
)
1079 current_unit_personality
= personality
;
1081 /* We cannot keep a current personality per function as without CFI
1082 asm, at the point where we emit the CFI data, there is no current
1083 function anymore. */
1084 if (personality
&& current_unit_personality
!= personality
)
1085 sorry ("multiple EH personalities are supported only with assemblers "
1086 "supporting .cfi_personality directive");
1090 /* Output a marker (i.e. a label) for the end of the generated code
1091 for a function prologue. This gets called *after* the prologue code has
1095 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1096 const char *file ATTRIBUTE_UNUSED
)
1098 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1100 /* Output a label to mark the endpoint of the code generated for this
1102 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1103 current_function_funcdef_no
);
1104 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1105 current_function_funcdef_no
);
1106 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1109 /* Output a marker (i.e. a label) for the beginning of the generated code
1110 for a function epilogue. This gets called *before* the prologue code has
1114 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1115 const char *file ATTRIBUTE_UNUSED
)
1117 dw_fde_ref fde
= cfun
->fde
;
1118 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1120 if (fde
->dw_fde_vms_begin_epilogue
)
1123 /* Output a label to mark the endpoint of the code generated for this
1125 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1126 current_function_funcdef_no
);
1127 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1128 current_function_funcdef_no
);
1129 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1132 /* Output a marker (i.e. a label) for the absolute end of the generated code
1133 for a function definition. This gets called *after* the epilogue code has
1137 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1138 const char *file ATTRIBUTE_UNUSED
)
1141 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1143 last_var_location_insn
= NULL
;
1144 cached_next_real_insn
= NULL
;
1146 if (dwarf2out_do_cfi_asm ())
1147 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1149 /* Output a label to mark the endpoint of the code generated for this
1151 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1152 current_function_funcdef_no
);
1153 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1155 gcc_assert (fde
!= NULL
);
1156 if (fde
->dw_fde_second_begin
== NULL
)
1157 fde
->dw_fde_end
= xstrdup (label
);
1161 dwarf2out_frame_finish (void)
1163 /* Output call frame information. */
1164 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1165 output_call_frame_info (0);
1167 /* Output another copy for the unwinder. */
1168 if ((flag_unwind_tables
|| flag_exceptions
)
1169 && targetm_common
.except_unwind_info (&global_options
) == UI_DWARF2
)
1170 output_call_frame_info (1);
1173 /* Note that the current function section is being used for code. */
1176 dwarf2out_note_section_used (void)
1178 section
*sec
= current_function_section ();
1179 if (sec
== text_section
)
1180 text_section_used
= true;
1181 else if (sec
== cold_text_section
)
1182 cold_text_section_used
= true;
1185 static void var_location_switch_text_section (void);
1186 static void set_cur_line_info_table (section
*);
1189 dwarf2out_switch_text_section (void)
1192 dw_fde_ref fde
= cfun
->fde
;
1194 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1196 if (!in_cold_section_p
)
1198 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1199 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1200 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1204 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1205 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1206 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1208 have_multiple_function_sections
= true;
1210 /* There is no need to mark used sections when not debugging. */
1211 if (cold_text_section
!= NULL
)
1212 dwarf2out_note_section_used ();
1214 if (dwarf2out_do_cfi_asm ())
1215 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1217 /* Now do the real section switch. */
1218 sect
= current_function_section ();
1219 switch_to_section (sect
);
1221 fde
->second_in_std_section
1222 = (sect
== text_section
1223 || (cold_text_section
&& sect
== cold_text_section
));
1225 if (dwarf2out_do_cfi_asm ())
1226 dwarf2out_do_cfi_startproc (true);
1228 var_location_switch_text_section ();
1230 if (cold_text_section
!= NULL
)
1231 set_cur_line_info_table (sect
);
1234 /* And now, the subset of the debugging information support code necessary
1235 for emitting location expressions. */
1237 /* Data about a single source file. */
1238 struct GTY(()) dwarf_file_data
{
1239 const char * filename
;
1243 typedef struct GTY(()) deferred_locations_struct
1247 } deferred_locations
;
1250 static GTY(()) vec
<deferred_locations
, va_gc
> *deferred_locations_list
;
1253 /* Describe an entry into the .debug_addr section. */
1257 ate_kind_rtx_dtprel
,
1261 typedef struct GTY(()) addr_table_entry_struct
{
1263 unsigned int refcount
;
1265 union addr_table_entry_struct_union
1267 rtx
GTY ((tag ("0"))) rtl
;
1268 char * GTY ((tag ("1"))) label
;
1270 GTY ((desc ("%1.kind"))) addr
;
1274 /* Location lists are ranges + location descriptions for that range,
1275 so you can track variables that are in different places over
1276 their entire life. */
1277 typedef struct GTY(()) dw_loc_list_struct
{
1278 dw_loc_list_ref dw_loc_next
;
1279 const char *begin
; /* Label and addr_entry for start of range */
1280 addr_table_entry
*begin_entry
;
1281 const char *end
; /* Label for end of range */
1282 char *ll_symbol
; /* Label for beginning of location list.
1283 Only on head of list */
1284 const char *section
; /* Section this loclist is relative to */
1285 dw_loc_descr_ref expr
;
1287 /* True if all addresses in this and subsequent lists are known to be
1290 /* True if this list has been replaced by dw_loc_next. */
1293 /* True if the range should be emitted even if begin and end
1298 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
1300 /* Convert a DWARF stack opcode into its string name. */
1303 dwarf_stack_op_name (unsigned int op
)
1305 const char *name
= get_DW_OP_name (op
);
1310 return "OP_<unknown>";
1313 /* Return a pointer to a newly allocated location description. Location
1314 descriptions are simple expression terms that can be strung
1315 together to form more complicated location (address) descriptions. */
1317 static inline dw_loc_descr_ref
1318 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1319 unsigned HOST_WIDE_INT oprnd2
)
1321 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1323 descr
->dw_loc_opc
= op
;
1324 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1325 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1326 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1327 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1328 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1329 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1334 /* Return a pointer to a newly allocated location description for
1337 static inline dw_loc_descr_ref
1338 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
1341 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1344 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
1347 /* Add a location description term to a location description expression. */
1350 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1352 dw_loc_descr_ref
*d
;
1354 /* Find the end of the chain. */
1355 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1361 /* Compare two location operands for exact equality. */
1364 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1366 if (a
->val_class
!= b
->val_class
)
1368 switch (a
->val_class
)
1370 case dw_val_class_none
:
1372 case dw_val_class_addr
:
1373 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1375 case dw_val_class_offset
:
1376 case dw_val_class_unsigned_const
:
1377 case dw_val_class_const
:
1378 case dw_val_class_range_list
:
1379 case dw_val_class_lineptr
:
1380 case dw_val_class_macptr
:
1381 /* These are all HOST_WIDE_INT, signed or unsigned. */
1382 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1384 case dw_val_class_loc
:
1385 return a
->v
.val_loc
== b
->v
.val_loc
;
1386 case dw_val_class_loc_list
:
1387 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1388 case dw_val_class_die_ref
:
1389 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1390 case dw_val_class_fde_ref
:
1391 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1392 case dw_val_class_lbl_id
:
1393 case dw_val_class_high_pc
:
1394 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1395 case dw_val_class_str
:
1396 return a
->v
.val_str
== b
->v
.val_str
;
1397 case dw_val_class_flag
:
1398 return a
->v
.val_flag
== b
->v
.val_flag
;
1399 case dw_val_class_file
:
1400 return a
->v
.val_file
== b
->v
.val_file
;
1401 case dw_val_class_decl_ref
:
1402 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1404 case dw_val_class_const_double
:
1405 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1406 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1408 case dw_val_class_wide_int
:
1409 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1411 case dw_val_class_vec
:
1413 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1414 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1416 return (a_len
== b_len
1417 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1420 case dw_val_class_data8
:
1421 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1423 case dw_val_class_vms_delta
:
1424 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1425 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1430 /* Compare two location atoms for exact equality. */
1433 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1435 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1438 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1439 address size, but since we always allocate cleared storage it
1440 should be zero for other types of locations. */
1441 if (a
->dtprel
!= b
->dtprel
)
1444 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1445 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1448 /* Compare two complete location expressions for exact equality. */
1451 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1457 if (a
== NULL
|| b
== NULL
)
1459 if (!loc_descr_equal_p_1 (a
, b
))
1468 /* Add a constant OFFSET to a location expression. */
1471 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
1473 dw_loc_descr_ref loc
;
1476 gcc_assert (*list_head
!= NULL
);
1481 /* Find the end of the chain. */
1482 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1486 if (loc
->dw_loc_opc
== DW_OP_fbreg
1487 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1488 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1489 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1490 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1492 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1493 offset. Don't optimize if an signed integer overflow would happen. */
1495 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1496 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1499 else if (offset
> 0)
1500 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1504 loc
->dw_loc_next
= int_loc_descriptor (-offset
);
1505 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1509 /* Add a constant OFFSET to a location list. */
1512 loc_list_plus_const (dw_loc_list_ref list_head
, HOST_WIDE_INT offset
)
1515 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1516 loc_descr_plus_const (&d
->expr
, offset
);
1519 #define DWARF_REF_SIZE \
1520 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1522 static unsigned long int get_base_type_offset (dw_die_ref
);
1524 /* Return the size of a location descriptor. */
1526 static unsigned long
1527 size_of_loc_descr (dw_loc_descr_ref loc
)
1529 unsigned long size
= 1;
1531 switch (loc
->dw_loc_opc
)
1534 size
+= DWARF2_ADDR_SIZE
;
1536 case DW_OP_GNU_addr_index
:
1537 case DW_OP_GNU_const_index
:
1538 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1539 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1558 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1561 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1566 case DW_OP_plus_uconst
:
1567 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1605 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1608 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1611 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1614 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1615 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1618 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1620 case DW_OP_bit_piece
:
1621 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1622 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1624 case DW_OP_deref_size
:
1625 case DW_OP_xderef_size
:
1634 case DW_OP_call_ref
:
1635 size
+= DWARF_REF_SIZE
;
1637 case DW_OP_implicit_value
:
1638 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1639 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1641 case DW_OP_GNU_implicit_pointer
:
1642 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1644 case DW_OP_GNU_entry_value
:
1646 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1647 size
+= size_of_uleb128 (op_size
) + op_size
;
1650 case DW_OP_GNU_const_type
:
1653 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1654 size
+= size_of_uleb128 (o
) + 1;
1655 switch (loc
->dw_loc_oprnd2
.val_class
)
1657 case dw_val_class_vec
:
1658 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1659 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1661 case dw_val_class_const
:
1662 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1664 case dw_val_class_const_double
:
1665 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1667 case dw_val_class_wide_int
:
1668 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1669 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1676 case DW_OP_GNU_regval_type
:
1679 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1680 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1681 + size_of_uleb128 (o
);
1684 case DW_OP_GNU_deref_type
:
1687 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1688 size
+= 1 + size_of_uleb128 (o
);
1691 case DW_OP_GNU_convert
:
1692 case DW_OP_GNU_reinterpret
:
1693 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1694 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1698 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1699 size
+= size_of_uleb128 (o
);
1702 case DW_OP_GNU_parameter_ref
:
1712 /* Return the size of a series of location descriptors. */
1715 size_of_locs (dw_loc_descr_ref loc
)
1720 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1721 field, to avoid writing to a PCH file. */
1722 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1724 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1726 size
+= size_of_loc_descr (l
);
1731 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1733 l
->dw_loc_addr
= size
;
1734 size
+= size_of_loc_descr (l
);
1740 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
1741 static void get_ref_die_offset_label (char *, dw_die_ref
);
1742 static unsigned long int get_ref_die_offset (dw_die_ref
);
1744 /* Output location description stack opcode's operands (if any).
1745 The for_eh_or_skip parameter controls whether register numbers are
1746 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1747 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1748 info). This should be suppressed for the cases that have not been converted
1749 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1752 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
1754 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
1755 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
1757 switch (loc
->dw_loc_opc
)
1759 #ifdef DWARF2_DEBUGGING_INFO
1762 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
1767 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1768 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
1770 fputc ('\n', asm_out_file
);
1775 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
1780 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1781 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
1783 fputc ('\n', asm_out_file
);
1788 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
1789 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
1796 gcc_assert (val1
->val_class
== dw_val_class_loc
);
1797 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
1799 dw2_asm_output_data (2, offset
, NULL
);
1802 case DW_OP_implicit_value
:
1803 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1804 switch (val2
->val_class
)
1806 case dw_val_class_const
:
1807 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
1809 case dw_val_class_vec
:
1811 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
1812 unsigned int len
= val2
->v
.val_vec
.length
;
1816 if (elt_size
> sizeof (HOST_WIDE_INT
))
1821 for (i
= 0, p
= val2
->v
.val_vec
.array
;
1824 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
1825 "fp or vector constant word %u", i
);
1828 case dw_val_class_const_double
:
1830 unsigned HOST_WIDE_INT first
, second
;
1832 if (WORDS_BIG_ENDIAN
)
1834 first
= val2
->v
.val_double
.high
;
1835 second
= val2
->v
.val_double
.low
;
1839 first
= val2
->v
.val_double
.low
;
1840 second
= val2
->v
.val_double
.high
;
1842 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1844 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1848 case dw_val_class_wide_int
:
1851 int len
= get_full_len (*val2
->v
.val_wide
);
1852 if (WORDS_BIG_ENDIAN
)
1853 for (i
= len
- 1; i
>= 0; --i
)
1854 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1855 val2
->v
.val_wide
->elt (i
), NULL
);
1857 for (i
= 0; i
< len
; ++i
)
1858 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1859 val2
->v
.val_wide
->elt (i
), NULL
);
1862 case dw_val_class_addr
:
1863 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
1864 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
1879 case DW_OP_implicit_value
:
1880 /* We currently don't make any attempt to make sure these are
1881 aligned properly like we do for the main unwind info, so
1882 don't support emitting things larger than a byte if we're
1883 only doing unwinding. */
1888 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1891 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1894 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1897 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1899 case DW_OP_plus_uconst
:
1900 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1934 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1938 unsigned r
= val1
->v
.val_unsigned
;
1939 if (for_eh_or_skip
>= 0)
1940 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1941 gcc_assert (size_of_uleb128 (r
)
1942 == size_of_uleb128 (val1
->v
.val_unsigned
));
1943 dw2_asm_output_data_uleb128 (r
, NULL
);
1947 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1951 unsigned r
= val1
->v
.val_unsigned
;
1952 if (for_eh_or_skip
>= 0)
1953 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1954 gcc_assert (size_of_uleb128 (r
)
1955 == size_of_uleb128 (val1
->v
.val_unsigned
));
1956 dw2_asm_output_data_uleb128 (r
, NULL
);
1957 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
1961 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1963 case DW_OP_bit_piece
:
1964 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1965 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
1967 case DW_OP_deref_size
:
1968 case DW_OP_xderef_size
:
1969 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1975 if (targetm
.asm_out
.output_dwarf_dtprel
)
1977 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
1980 fputc ('\n', asm_out_file
);
1987 #ifdef DWARF2_DEBUGGING_INFO
1988 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
1995 case DW_OP_GNU_addr_index
:
1996 case DW_OP_GNU_const_index
:
1997 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1998 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
1999 "(index into .debug_addr)");
2002 case DW_OP_GNU_implicit_pointer
:
2004 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2005 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2006 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2007 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2008 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2009 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2013 case DW_OP_GNU_entry_value
:
2014 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2015 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2018 case DW_OP_GNU_const_type
:
2020 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2022 dw2_asm_output_data_uleb128 (o
, NULL
);
2023 switch (val2
->val_class
)
2025 case dw_val_class_const
:
2026 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2027 dw2_asm_output_data (1, l
, NULL
);
2028 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2030 case dw_val_class_vec
:
2032 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2033 unsigned int len
= val2
->v
.val_vec
.length
;
2038 dw2_asm_output_data (1, l
, NULL
);
2039 if (elt_size
> sizeof (HOST_WIDE_INT
))
2044 for (i
= 0, p
= val2
->v
.val_vec
.array
;
2047 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2048 "fp or vector constant word %u", i
);
2051 case dw_val_class_const_double
:
2053 unsigned HOST_WIDE_INT first
, second
;
2054 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2056 dw2_asm_output_data (1, 2 * l
, NULL
);
2057 if (WORDS_BIG_ENDIAN
)
2059 first
= val2
->v
.val_double
.high
;
2060 second
= val2
->v
.val_double
.low
;
2064 first
= val2
->v
.val_double
.low
;
2065 second
= val2
->v
.val_double
.high
;
2067 dw2_asm_output_data (l
, first
, NULL
);
2068 dw2_asm_output_data (l
, second
, NULL
);
2071 case dw_val_class_wide_int
:
2074 int len
= get_full_len (*val2
->v
.val_wide
);
2075 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2077 dw2_asm_output_data (1, len
* l
, NULL
);
2078 if (WORDS_BIG_ENDIAN
)
2079 for (i
= len
- 1; i
>= 0; --i
)
2080 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2082 for (i
= 0; i
< len
; ++i
)
2083 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2091 case DW_OP_GNU_regval_type
:
2093 unsigned r
= val1
->v
.val_unsigned
;
2094 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2096 if (for_eh_or_skip
>= 0)
2098 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2099 gcc_assert (size_of_uleb128 (r
)
2100 == size_of_uleb128 (val1
->v
.val_unsigned
));
2102 dw2_asm_output_data_uleb128 (r
, NULL
);
2103 dw2_asm_output_data_uleb128 (o
, NULL
);
2106 case DW_OP_GNU_deref_type
:
2108 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2110 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2111 dw2_asm_output_data_uleb128 (o
, NULL
);
2114 case DW_OP_GNU_convert
:
2115 case DW_OP_GNU_reinterpret
:
2116 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2117 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2120 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2122 dw2_asm_output_data_uleb128 (o
, NULL
);
2126 case DW_OP_GNU_parameter_ref
:
2129 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2130 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2131 dw2_asm_output_data (4, o
, NULL
);
2136 /* Other codes have no operands. */
2141 /* Output a sequence of location operations.
2142 The for_eh_or_skip parameter controls whether register numbers are
2143 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2144 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2145 info). This should be suppressed for the cases that have not been converted
2146 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2149 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2151 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2153 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2154 /* Output the opcode. */
2155 if (for_eh_or_skip
>= 0
2156 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2158 unsigned r
= (opc
- DW_OP_breg0
);
2159 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2160 gcc_assert (r
<= 31);
2161 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2163 else if (for_eh_or_skip
>= 0
2164 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2166 unsigned r
= (opc
- DW_OP_reg0
);
2167 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2168 gcc_assert (r
<= 31);
2169 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2172 dw2_asm_output_data (1, opc
,
2173 "%s", dwarf_stack_op_name (opc
));
2175 /* Output the operand(s) (if any). */
2176 output_loc_operands (loc
, for_eh_or_skip
);
2180 /* Output location description stack opcode's operands (if any).
2181 The output is single bytes on a line, suitable for .cfi_escape. */
2184 output_loc_operands_raw (dw_loc_descr_ref loc
)
2186 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2187 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2189 switch (loc
->dw_loc_opc
)
2192 case DW_OP_GNU_addr_index
:
2193 case DW_OP_GNU_const_index
:
2194 case DW_OP_implicit_value
:
2195 /* We cannot output addresses in .cfi_escape, only bytes. */
2201 case DW_OP_deref_size
:
2202 case DW_OP_xderef_size
:
2203 fputc (',', asm_out_file
);
2204 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2209 fputc (',', asm_out_file
);
2210 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2215 fputc (',', asm_out_file
);
2216 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2221 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2222 fputc (',', asm_out_file
);
2223 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2231 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2232 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2234 fputc (',', asm_out_file
);
2235 dw2_asm_output_data_raw (2, offset
);
2241 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2242 gcc_assert (size_of_uleb128 (r
)
2243 == size_of_uleb128 (val1
->v
.val_unsigned
));
2244 fputc (',', asm_out_file
);
2245 dw2_asm_output_data_uleb128_raw (r
);
2250 case DW_OP_plus_uconst
:
2252 fputc (',', asm_out_file
);
2253 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2256 case DW_OP_bit_piece
:
2257 fputc (',', asm_out_file
);
2258 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2259 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2296 fputc (',', asm_out_file
);
2297 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2302 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2303 gcc_assert (size_of_uleb128 (r
)
2304 == size_of_uleb128 (val1
->v
.val_unsigned
));
2305 fputc (',', asm_out_file
);
2306 dw2_asm_output_data_uleb128_raw (r
);
2307 fputc (',', asm_out_file
);
2308 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2312 case DW_OP_GNU_implicit_pointer
:
2313 case DW_OP_GNU_entry_value
:
2314 case DW_OP_GNU_const_type
:
2315 case DW_OP_GNU_regval_type
:
2316 case DW_OP_GNU_deref_type
:
2317 case DW_OP_GNU_convert
:
2318 case DW_OP_GNU_reinterpret
:
2319 case DW_OP_GNU_parameter_ref
:
2324 /* Other codes have no operands. */
2330 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2334 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2335 /* Output the opcode. */
2336 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2338 unsigned r
= (opc
- DW_OP_breg0
);
2339 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2340 gcc_assert (r
<= 31);
2341 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2343 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2345 unsigned r
= (opc
- DW_OP_reg0
);
2346 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2347 gcc_assert (r
<= 31);
2348 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2350 /* Output the opcode. */
2351 fprintf (asm_out_file
, "%#x", opc
);
2352 output_loc_operands_raw (loc
);
2354 if (!loc
->dw_loc_next
)
2356 loc
= loc
->dw_loc_next
;
2358 fputc (',', asm_out_file
);
2362 /* This function builds a dwarf location descriptor sequence from a
2363 dw_cfa_location, adding the given OFFSET to the result of the
2366 struct dw_loc_descr_node
*
2367 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
2369 struct dw_loc_descr_node
*head
, *tmp
;
2371 offset
+= cfa
->offset
;
2375 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2376 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2377 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2378 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2379 add_loc_descr (&head
, tmp
);
2382 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
2383 add_loc_descr (&head
, tmp
);
2387 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2392 /* This function builds a dwarf location descriptor sequence for
2393 the address at OFFSET from the CFA when stack is aligned to
2396 struct dw_loc_descr_node
*
2397 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2398 HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
2400 struct dw_loc_descr_node
*head
;
2401 unsigned int dwarf_fp
2402 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2404 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2405 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2407 head
= new_reg_loc_descr (dwarf_fp
, 0);
2408 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2409 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2410 loc_descr_plus_const (&head
, offset
);
2413 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2417 /* And now, the support for symbolic debugging information. */
2419 /* .debug_str support. */
2420 static int output_indirect_string (void **, void *);
2422 static void dwarf2out_init (const char *);
2423 static void dwarf2out_finish (const char *);
2424 static void dwarf2out_assembly_start (void);
2425 static void dwarf2out_define (unsigned int, const char *);
2426 static void dwarf2out_undef (unsigned int, const char *);
2427 static void dwarf2out_start_source_file (unsigned, const char *);
2428 static void dwarf2out_end_source_file (unsigned);
2429 static void dwarf2out_function_decl (tree
);
2430 static void dwarf2out_begin_block (unsigned, unsigned);
2431 static void dwarf2out_end_block (unsigned, unsigned);
2432 static bool dwarf2out_ignore_block (const_tree
);
2433 static void dwarf2out_global_decl (tree
);
2434 static void dwarf2out_type_decl (tree
, int);
2435 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool);
2436 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2438 static void dwarf2out_abstract_function (tree
);
2439 static void dwarf2out_var_location (rtx_insn
*);
2440 static void dwarf2out_begin_function (tree
);
2441 static void dwarf2out_end_function (unsigned int);
2442 static void dwarf2out_set_name (tree
, tree
);
2444 /* The debug hooks structure. */
2446 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2450 dwarf2out_assembly_start
,
2453 dwarf2out_start_source_file
,
2454 dwarf2out_end_source_file
,
2455 dwarf2out_begin_block
,
2456 dwarf2out_end_block
,
2457 dwarf2out_ignore_block
,
2458 dwarf2out_source_line
,
2459 dwarf2out_begin_prologue
,
2460 #if VMS_DEBUGGING_INFO
2461 dwarf2out_vms_end_prologue
,
2462 dwarf2out_vms_begin_epilogue
,
2464 debug_nothing_int_charstar
,
2465 debug_nothing_int_charstar
,
2467 dwarf2out_end_epilogue
,
2468 dwarf2out_begin_function
,
2469 dwarf2out_end_function
, /* end_function */
2470 dwarf2out_function_decl
, /* function_decl */
2471 dwarf2out_global_decl
,
2472 dwarf2out_type_decl
, /* type_decl */
2473 dwarf2out_imported_module_or_decl
,
2474 debug_nothing_tree
, /* deferred_inline_function */
2475 /* The DWARF 2 backend tries to reduce debugging bloat by not
2476 emitting the abstract description of inline functions until
2477 something tries to reference them. */
2478 dwarf2out_abstract_function
, /* outlining_inline_function */
2479 debug_nothing_rtx_code_label
, /* label */
2480 debug_nothing_int
, /* handle_pch */
2481 dwarf2out_var_location
,
2482 dwarf2out_switch_text_section
,
2484 1, /* start_end_main_source_file */
2485 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2488 /* NOTE: In the comments in this file, many references are made to
2489 "Debugging Information Entries". This term is abbreviated as `DIE'
2490 throughout the remainder of this file. */
2492 /* An internal representation of the DWARF output is built, and then
2493 walked to generate the DWARF debugging info. The walk of the internal
2494 representation is done after the entire program has been compiled.
2495 The types below are used to describe the internal representation. */
2497 /* Whether to put type DIEs into their own section .debug_types instead
2498 of making them part of the .debug_info section. Only supported for
2499 Dwarf V4 or higher and the user didn't disable them through
2500 -fno-debug-types-section. It is more efficient to put them in a
2501 separate comdat sections since the linker will then be able to
2502 remove duplicates. But not all tools support .debug_types sections
2505 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2507 /* Various DIE's use offsets relative to the beginning of the
2508 .debug_info section to refer to each other. */
2510 typedef long int dw_offset
;
2512 /* Define typedefs here to avoid circular dependencies. */
2514 typedef struct dw_attr_struct
*dw_attr_ref
;
2515 typedef struct dw_line_info_struct
*dw_line_info_ref
;
2516 typedef struct pubname_struct
*pubname_ref
;
2517 typedef struct dw_ranges_struct
*dw_ranges_ref
;
2518 typedef struct dw_ranges_by_label_struct
*dw_ranges_by_label_ref
;
2519 typedef struct comdat_type_struct
*comdat_type_node_ref
;
2521 /* The entries in the line_info table more-or-less mirror the opcodes
2522 that are used in the real dwarf line table. Arrays of these entries
2523 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2526 enum dw_line_info_opcode
{
2527 /* Emit DW_LNE_set_address; the operand is the label index. */
2530 /* Emit a row to the matrix with the given line. This may be done
2531 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2535 /* Emit a DW_LNS_set_file. */
2538 /* Emit a DW_LNS_set_column. */
2541 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2544 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2545 LI_set_prologue_end
,
2546 LI_set_epilogue_begin
,
2548 /* Emit a DW_LNE_set_discriminator. */
2549 LI_set_discriminator
2552 typedef struct GTY(()) dw_line_info_struct
{
2553 enum dw_line_info_opcode opcode
;
2555 } dw_line_info_entry
;
2558 typedef struct GTY(()) dw_line_info_table_struct
{
2559 /* The label that marks the end of this section. */
2560 const char *end_label
;
2562 /* The values for the last row of the matrix, as collected in the table.
2563 These are used to minimize the changes to the next row. */
2564 unsigned int file_num
;
2565 unsigned int line_num
;
2566 unsigned int column_num
;
2571 vec
<dw_line_info_entry
, va_gc
> *entries
;
2572 } dw_line_info_table
;
2574 typedef dw_line_info_table
*dw_line_info_table_p
;
2577 /* Each DIE attribute has a field specifying the attribute kind,
2578 a link to the next attribute in the chain, and an attribute value.
2579 Attributes are typically linked below the DIE they modify. */
2581 typedef struct GTY(()) dw_attr_struct
{
2582 enum dwarf_attribute dw_attr
;
2583 dw_val_node dw_attr_val
;
2588 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2589 The children of each node form a circular list linked by
2590 die_sib. die_child points to the node *before* the "first" child node. */
2592 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct
{
2593 union die_symbol_or_type_node
2595 const char * GTY ((tag ("0"))) die_symbol
;
2596 comdat_type_node_ref
GTY ((tag ("1"))) die_type_node
;
2598 GTY ((desc ("%0.comdat_type_p"))) die_id
;
2599 vec
<dw_attr_node
, va_gc
> *die_attr
;
2600 dw_die_ref die_parent
;
2601 dw_die_ref die_child
;
2603 dw_die_ref die_definition
; /* ref from a specification to its definition */
2604 dw_offset die_offset
;
2605 unsigned long die_abbrev
;
2607 unsigned int decl_id
;
2608 enum dwarf_tag die_tag
;
2609 /* Die is used and must not be pruned as unused. */
2610 BOOL_BITFIELD die_perennial_p
: 1;
2611 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
2612 /* Lots of spare bits. */
2616 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2617 #define FOR_EACH_CHILD(die, c, expr) do { \
2618 c = die->die_child; \
2622 } while (c != die->die_child); \
2625 /* The pubname structure */
2627 typedef struct GTY(()) pubname_struct
{
2634 struct GTY(()) dw_ranges_struct
{
2635 /* If this is positive, it's a block number, otherwise it's a
2636 bitwise-negated index into dw_ranges_by_label. */
2640 /* A structure to hold a macinfo entry. */
2642 typedef struct GTY(()) macinfo_struct
{
2644 unsigned HOST_WIDE_INT lineno
;
2650 struct GTY(()) dw_ranges_by_label_struct
{
2655 /* The comdat type node structure. */
2656 typedef struct GTY(()) comdat_type_struct
2658 dw_die_ref root_die
;
2659 dw_die_ref type_die
;
2660 dw_die_ref skeleton_die
;
2661 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
2662 struct comdat_type_struct
*next
;
2666 /* The limbo die list structure. */
2667 typedef struct GTY(()) limbo_die_struct
{
2670 struct limbo_die_struct
*next
;
2674 typedef struct skeleton_chain_struct
2678 struct skeleton_chain_struct
*parent
;
2680 skeleton_chain_node
;
2682 /* Define a macro which returns nonzero for a TYPE_DECL which was
2683 implicitly generated for a type.
2685 Note that, unlike the C front-end (which generates a NULL named
2686 TYPE_DECL node for each complete tagged type, each array type,
2687 and each function type node created) the C++ front-end generates
2688 a _named_ TYPE_DECL node for each tagged type node created.
2689 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2690 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2691 front-end, but for each type, tagged or not. */
2693 #define TYPE_DECL_IS_STUB(decl) \
2694 (DECL_NAME (decl) == NULL_TREE \
2695 || (DECL_ARTIFICIAL (decl) \
2696 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2697 /* This is necessary for stub decls that \
2698 appear in nested inline functions. */ \
2699 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2700 && (decl_ultimate_origin (decl) \
2701 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2703 /* Information concerning the compilation unit's programming
2704 language, and compiler version. */
2706 /* Fixed size portion of the DWARF compilation unit header. */
2707 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2708 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2710 /* Fixed size portion of the DWARF comdat type unit header. */
2711 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2712 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2713 + DWARF_OFFSET_SIZE)
2715 /* Fixed size portion of public names info. */
2716 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2718 /* Fixed size portion of the address range info. */
2719 #define DWARF_ARANGES_HEADER_SIZE \
2720 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2721 DWARF2_ADDR_SIZE * 2) \
2722 - DWARF_INITIAL_LENGTH_SIZE)
2724 /* Size of padding portion in the address range info. It must be
2725 aligned to twice the pointer size. */
2726 #define DWARF_ARANGES_PAD_SIZE \
2727 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2728 DWARF2_ADDR_SIZE * 2) \
2729 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2731 /* Use assembler line directives if available. */
2732 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2733 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2734 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2736 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2740 /* Minimum line offset in a special line info. opcode.
2741 This value was chosen to give a reasonable range of values. */
2742 #define DWARF_LINE_BASE -10
2744 /* First special line opcode - leave room for the standard opcodes. */
2745 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2747 /* Range of line offsets in a special line info. opcode. */
2748 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2750 /* Flag that indicates the initial value of the is_stmt_start flag.
2751 In the present implementation, we do not mark any lines as
2752 the beginning of a source statement, because that information
2753 is not made available by the GCC front-end. */
2754 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2756 /* Maximum number of operations per instruction bundle. */
2757 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2758 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2761 /* This location is used by calc_die_sizes() to keep track
2762 the offset of each DIE within the .debug_info section. */
2763 static unsigned long next_die_offset
;
2765 /* Record the root of the DIE's built for the current compilation unit. */
2766 static GTY(()) dw_die_ref single_comp_unit_die
;
2768 /* A list of type DIEs that have been separated into comdat sections. */
2769 static GTY(()) comdat_type_node
*comdat_type_list
;
2771 /* A list of DIEs with a NULL parent waiting to be relocated. */
2772 static GTY(()) limbo_die_node
*limbo_die_list
;
2774 /* A list of DIEs for which we may have to generate
2775 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2776 static GTY(()) limbo_die_node
*deferred_asm_name
;
2778 /* Filenames referenced by this compilation unit. */
2779 static GTY((param_is (struct dwarf_file_data
))) htab_t file_table
;
2781 /* A hash table of references to DIE's that describe declarations.
2782 The key is a DECL_UID() which is a unique number identifying each decl. */
2783 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
2785 /* A hash table of references to DIE's that describe COMMON blocks.
2786 The key is DECL_UID() ^ die_parent. */
2787 static GTY ((param_is (struct die_struct
))) htab_t common_block_die_table
;
2789 typedef struct GTY(()) die_arg_entry_struct
{
2795 /* Node of the variable location list. */
2796 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
2797 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2798 EXPR_LIST chain. For small bitsizes, bitsize is encoded
2799 in mode of the EXPR_LIST node and first EXPR_LIST operand
2800 is either NOTE_INSN_VAR_LOCATION for a piece with a known
2801 location or NULL for padding. For larger bitsizes,
2802 mode is 0 and first operand is a CONCAT with bitsize
2803 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2804 NULL as second operand. */
2806 const char * GTY (()) label
;
2807 struct var_loc_node
* GTY (()) next
;
2810 /* Variable location list. */
2811 struct GTY (()) var_loc_list_def
{
2812 struct var_loc_node
* GTY (()) first
;
2814 /* Pointer to the last but one or last element of the
2815 chained list. If the list is empty, both first and
2816 last are NULL, if the list contains just one node
2817 or the last node certainly is not redundant, it points
2818 to the last node, otherwise points to the last but one.
2819 Do not mark it for GC because it is marked through the chain. */
2820 struct var_loc_node
* GTY ((skip ("%h"))) last
;
2822 /* Pointer to the last element before section switch,
2823 if NULL, either sections weren't switched or first
2824 is after section switch. */
2825 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
2827 /* DECL_UID of the variable decl. */
2828 unsigned int decl_id
;
2830 typedef struct var_loc_list_def var_loc_list
;
2832 /* Call argument location list. */
2833 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
2834 rtx
GTY (()) call_arg_loc_note
;
2835 const char * GTY (()) label
;
2836 tree
GTY (()) block
;
2838 rtx
GTY (()) symbol_ref
;
2839 struct call_arg_loc_node
* GTY (()) next
;
2843 /* Table of decl location linked lists. */
2844 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
2846 /* Head and tail of call_arg_loc chain. */
2847 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
2848 static struct call_arg_loc_node
*call_arg_loc_last
;
2850 /* Number of call sites in the current function. */
2851 static int call_site_count
= -1;
2852 /* Number of tail call sites in the current function. */
2853 static int tail_call_site_count
= -1;
2855 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
2857 static vec
<dw_die_ref
> block_map
;
2859 /* A cached location list. */
2860 struct GTY (()) cached_dw_loc_list_def
{
2861 /* The DECL_UID of the decl that this entry describes. */
2862 unsigned int decl_id
;
2864 /* The cached location list. */
2865 dw_loc_list_ref loc_list
;
2867 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
2869 /* Table of cached location lists. */
2870 static GTY ((param_is (cached_dw_loc_list
))) htab_t cached_dw_loc_list_table
;
2872 /* A pointer to the base of a list of references to DIE's that
2873 are uniquely identified by their tag, presence/absence of
2874 children DIE's, and list of attribute/value pairs. */
2875 static GTY((length ("abbrev_die_table_allocated")))
2876 dw_die_ref
*abbrev_die_table
;
2878 /* Number of elements currently allocated for abbrev_die_table. */
2879 static GTY(()) unsigned abbrev_die_table_allocated
;
2881 /* Number of elements in type_die_table currently in use. */
2882 static GTY(()) unsigned abbrev_die_table_in_use
;
2884 /* Size (in elements) of increments by which we may expand the
2885 abbrev_die_table. */
2886 #define ABBREV_DIE_TABLE_INCREMENT 256
2888 /* A global counter for generating labels for line number data. */
2889 static unsigned int line_info_label_num
;
2891 /* The current table to which we should emit line number information
2892 for the current function. This will be set up at the beginning of
2893 assembly for the function. */
2894 static dw_line_info_table
*cur_line_info_table
;
2896 /* The two default tables of line number info. */
2897 static GTY(()) dw_line_info_table
*text_section_line_info
;
2898 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
2900 /* The set of all non-default tables of line number info. */
2901 static GTY(()) vec
<dw_line_info_table_p
, va_gc
> *separate_line_info
;
2903 /* A flag to tell pubnames/types export if there is an info section to
2905 static bool info_section_emitted
;
2907 /* A pointer to the base of a table that contains a list of publicly
2908 accessible names. */
2909 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
2911 /* A pointer to the base of a table that contains a list of publicly
2912 accessible types. */
2913 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
2915 /* A pointer to the base of a table that contains a list of macro
2916 defines/undefines (and file start/end markers). */
2917 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
2919 /* True if .debug_macinfo or .debug_macros section is going to be
2921 #define have_macinfo \
2922 (debug_info_level >= DINFO_LEVEL_VERBOSE \
2923 && !macinfo_table->is_empty ())
2925 /* Array of dies for which we should generate .debug_ranges info. */
2926 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
2928 /* Number of elements currently allocated for ranges_table. */
2929 static GTY(()) unsigned ranges_table_allocated
;
2931 /* Number of elements in ranges_table currently in use. */
2932 static GTY(()) unsigned ranges_table_in_use
;
2934 /* Array of pairs of labels referenced in ranges_table. */
2935 static GTY ((length ("ranges_by_label_allocated")))
2936 dw_ranges_by_label_ref ranges_by_label
;
2938 /* Number of elements currently allocated for ranges_by_label. */
2939 static GTY(()) unsigned ranges_by_label_allocated
;
2941 /* Number of elements in ranges_by_label currently in use. */
2942 static GTY(()) unsigned ranges_by_label_in_use
;
2944 /* Size (in elements) of increments by which we may expand the
2946 #define RANGES_TABLE_INCREMENT 64
2948 /* Whether we have location lists that need outputting */
2949 static GTY(()) bool have_location_lists
;
2951 /* Unique label counter. */
2952 static GTY(()) unsigned int loclabel_num
;
2954 /* Unique label counter for point-of-call tables. */
2955 static GTY(()) unsigned int poc_label_num
;
2957 /* Record whether the function being analyzed contains inlined functions. */
2958 static int current_function_has_inlines
;
2960 /* The last file entry emitted by maybe_emit_file(). */
2961 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
2963 /* Number of internal labels generated by gen_internal_sym(). */
2964 static GTY(()) int label_num
;
2966 /* Cached result of previous call to lookup_filename. */
2967 static GTY(()) struct dwarf_file_data
* file_table_last_lookup
;
2969 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
2971 /* Instances of generic types for which we need to generate debug
2972 info that describe their generic parameters and arguments. That
2973 generation needs to happen once all types are properly laid out so
2974 we do it at the end of compilation. */
2975 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
2977 /* Offset from the "steady-state frame pointer" to the frame base,
2978 within the current function. */
2979 static HOST_WIDE_INT frame_pointer_fb_offset
;
2980 static bool frame_pointer_fb_offset_valid
;
2982 static vec
<dw_die_ref
> base_types
;
2984 /* Forward declarations for functions defined in this file. */
2986 static int is_pseudo_reg (const_rtx
);
2987 static tree
type_main_variant (tree
);
2988 static int is_tagged_type (const_tree
);
2989 static const char *dwarf_tag_name (unsigned);
2990 static const char *dwarf_attr_name (unsigned);
2991 static const char *dwarf_form_name (unsigned);
2992 static tree
decl_ultimate_origin (const_tree
);
2993 static tree
decl_class_context (tree
);
2994 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
2995 static inline enum dw_val_class
AT_class (dw_attr_ref
);
2996 static inline unsigned int AT_index (dw_attr_ref
);
2997 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
2998 static inline unsigned AT_flag (dw_attr_ref
);
2999 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3000 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
3001 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3002 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
3003 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3004 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3005 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3006 unsigned int, unsigned char *);
3007 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3008 static hashval_t
debug_str_do_hash (const void *);
3009 static int debug_str_eq (const void *, const void *);
3010 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3011 static inline const char *AT_string (dw_attr_ref
);
3012 static enum dwarf_form
AT_string_form (dw_attr_ref
);
3013 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3014 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3015 static inline dw_die_ref
AT_ref (dw_attr_ref
);
3016 static inline int AT_ref_external (dw_attr_ref
);
3017 static inline void set_AT_ref_external (dw_attr_ref
, int);
3018 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3019 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3020 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
3021 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3023 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
3024 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3025 static void remove_addr_table_entry (addr_table_entry
*);
3026 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3027 static inline rtx
AT_addr (dw_attr_ref
);
3028 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3029 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3030 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3031 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3032 unsigned HOST_WIDE_INT
);
3033 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3034 unsigned long, bool);
3035 static inline const char *AT_lbl (dw_attr_ref
);
3036 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
3037 static const char *get_AT_low_pc (dw_die_ref
);
3038 static const char *get_AT_hi_pc (dw_die_ref
);
3039 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3040 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3041 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3042 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3043 static bool is_cxx (void);
3044 static bool is_fortran (void);
3045 static bool is_ada (void);
3046 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
3047 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3048 static void add_child_die (dw_die_ref
, dw_die_ref
);
3049 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3050 static dw_die_ref
lookup_type_die (tree
);
3051 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3052 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3053 static void equate_type_number_to_die (tree
, dw_die_ref
);
3054 static hashval_t
decl_die_table_hash (const void *);
3055 static int decl_die_table_eq (const void *, const void *);
3056 static dw_die_ref
lookup_decl_die (tree
);
3057 static hashval_t
common_block_die_table_hash (const void *);
3058 static int common_block_die_table_eq (const void *, const void *);
3059 static hashval_t
decl_loc_table_hash (const void *);
3060 static int decl_loc_table_eq (const void *, const void *);
3061 static var_loc_list
*lookup_decl_loc (const_tree
);
3062 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3063 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *);
3064 static void print_spaces (FILE *);
3065 static void print_die (dw_die_ref
, FILE *);
3066 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
3067 static dw_die_ref
pop_compile_unit (dw_die_ref
);
3068 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3069 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
3070 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3071 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3072 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3073 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3074 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_ref
,
3075 struct md5_ctx
*, int *);
3076 struct checksum_attributes
;
3077 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3078 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3079 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3080 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3081 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3082 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3083 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
3084 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3085 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
3086 static void compute_section_prefix (dw_die_ref
);
3087 static int is_type_die (dw_die_ref
);
3088 static int is_comdat_die (dw_die_ref
);
3089 static int is_symbol_die (dw_die_ref
);
3090 static inline bool is_template_instantiation (dw_die_ref
);
3091 static void assign_symbol_names (dw_die_ref
);
3092 static void break_out_includes (dw_die_ref
);
3093 static int is_declaration_die (dw_die_ref
);
3094 static int should_move_die_to_comdat (dw_die_ref
);
3095 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3096 static dw_die_ref
clone_die (dw_die_ref
);
3097 static dw_die_ref
clone_tree (dw_die_ref
);
3098 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3099 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3100 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3101 static dw_die_ref
generate_skeleton (dw_die_ref
);
3102 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3105 static void break_out_comdat_types (dw_die_ref
);
3106 static void copy_decls_for_unworthy_types (dw_die_ref
);
3108 static void add_sibling_attributes (dw_die_ref
);
3109 static void output_location_lists (dw_die_ref
);
3110 static int constant_size (unsigned HOST_WIDE_INT
);
3111 static unsigned long size_of_die (dw_die_ref
);
3112 static void calc_die_sizes (dw_die_ref
);
3113 static void calc_base_type_die_sizes (void);
3114 static void mark_dies (dw_die_ref
);
3115 static void unmark_dies (dw_die_ref
);
3116 static void unmark_all_dies (dw_die_ref
);
3117 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3118 static unsigned long size_of_aranges (void);
3119 static enum dwarf_form
value_format (dw_attr_ref
);
3120 static void output_value_format (dw_attr_ref
);
3121 static void output_abbrev_section (void);
3122 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3123 static void output_die_symbol (dw_die_ref
);
3124 static void output_die (dw_die_ref
);
3125 static void output_compilation_unit_header (void);
3126 static void output_comp_unit (dw_die_ref
, int);
3127 static void output_comdat_type_unit (comdat_type_node
*);
3128 static const char *dwarf2_name (tree
, int);
3129 static void add_pubname (tree
, dw_die_ref
);
3130 static void add_enumerator_pubname (const char *, dw_die_ref
);
3131 static void add_pubname_string (const char *, dw_die_ref
);
3132 static void add_pubtype (tree
, dw_die_ref
);
3133 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3134 static void output_aranges (unsigned long);
3135 static unsigned int add_ranges_num (int);
3136 static unsigned int add_ranges (const_tree
);
3137 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3139 static void output_ranges (void);
3140 static dw_line_info_table
*new_line_info_table (void);
3141 static void output_line_info (bool);
3142 static void output_file_names (void);
3143 static dw_die_ref
base_type_die (tree
);
3144 static int is_base_type (tree
);
3145 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, dw_die_ref
);
3146 static int decl_quals (const_tree
);
3147 static dw_die_ref
modified_type_die (tree
, int, dw_die_ref
);
3148 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3149 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3150 static int type_is_enum (const_tree
);
3151 static unsigned int dbx_reg_number (const_rtx
);
3152 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3153 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3154 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3155 enum var_init_status
);
3156 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3157 enum var_init_status
);
3158 static dw_loc_descr_ref
based_loc_descr (rtx
, HOST_WIDE_INT
,
3159 enum var_init_status
);
3160 static int is_based_loc (const_rtx
);
3161 static bool resolve_one_addr (rtx
*);
3162 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3163 enum var_init_status
);
3164 static dw_loc_descr_ref
loc_descriptor (rtx
, enum machine_mode mode
,
3165 enum var_init_status
);
3166 static dw_loc_list_ref
loc_list_from_tree (tree
, int);
3167 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int);
3168 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3169 static tree
field_type (const_tree
);
3170 static unsigned int simple_type_align_in_bits (const_tree
);
3171 static unsigned int simple_decl_align_in_bits (const_tree
);
3172 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3173 static HOST_WIDE_INT
field_byte_offset (const_tree
);
3174 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3176 static void add_data_member_location_attribute (dw_die_ref
, tree
);
3177 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3178 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3179 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3180 static void insert_float (const_rtx
, unsigned char *);
3181 static rtx
rtl_for_decl_location (tree
);
3182 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool,
3183 enum dwarf_attribute
);
3184 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3185 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3186 static void add_name_attribute (dw_die_ref
, const char *);
3187 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3188 static void add_comp_dir_attribute (dw_die_ref
);
3189 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
3190 static void add_subscript_info (dw_die_ref
, tree
, bool);
3191 static void add_byte_size_attribute (dw_die_ref
, tree
);
3192 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3193 static void add_bit_size_attribute (dw_die_ref
, tree
);
3194 static void add_prototyped_attribute (dw_die_ref
, tree
);
3195 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3196 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3197 static void add_src_coords_attributes (dw_die_ref
, tree
);
3198 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
3199 static void push_decl_scope (tree
);
3200 static void pop_decl_scope (void);
3201 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3202 static inline int local_scope_p (dw_die_ref
);
3203 static inline int class_scope_p (dw_die_ref
);
3204 static inline int class_or_namespace_scope_p (dw_die_ref
);
3205 static void add_type_attribute (dw_die_ref
, tree
, int, dw_die_ref
);
3206 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3207 static const char *type_tag (const_tree
);
3208 static tree
member_declared_type (const_tree
);
3210 static const char *decl_start_label (tree
);
3212 static void gen_array_type_die (tree
, dw_die_ref
);
3213 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3215 static void gen_entry_point_die (tree
, dw_die_ref
);
3217 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3218 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3219 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3220 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3221 static void gen_formal_types_die (tree
, dw_die_ref
);
3222 static void gen_subprogram_die (tree
, dw_die_ref
);
3223 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3224 static void gen_const_die (tree
, dw_die_ref
);
3225 static void gen_label_die (tree
, dw_die_ref
);
3226 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
3227 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
3228 static void gen_field_die (tree
, dw_die_ref
);
3229 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3230 static dw_die_ref
gen_compile_unit_die (const char *);
3231 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
3232 static void gen_member_die (tree
, dw_die_ref
);
3233 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3234 enum debug_info_usage
);
3235 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3236 static void gen_typedef_die (tree
, dw_die_ref
);
3237 static void gen_type_die (tree
, dw_die_ref
);
3238 static void gen_block_die (tree
, dw_die_ref
, int);
3239 static void decls_for_scope (tree
, dw_die_ref
, int);
3240 static inline int is_redundant_typedef (const_tree
);
3241 static bool is_naming_typedef_decl (const_tree
);
3242 static inline dw_die_ref
get_context_die (tree
);
3243 static void gen_namespace_die (tree
, dw_die_ref
);
3244 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3245 static dw_die_ref
gen_decl_die (tree
, tree
, dw_die_ref
);
3246 static dw_die_ref
force_decl_die (tree
);
3247 static dw_die_ref
force_type_die (tree
);
3248 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3249 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3250 static struct dwarf_file_data
* lookup_filename (const char *);
3251 static void retry_incomplete_types (void);
3252 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3253 static void gen_generic_params_dies (tree
);
3254 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3255 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3256 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3257 static int file_info_cmp (const void *, const void *);
3258 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3259 const char *, const char *);
3260 static void output_loc_list (dw_loc_list_ref
);
3261 static char *gen_internal_sym (const char *);
3262 static bool want_pubnames (void);
3264 static void prune_unmark_dies (dw_die_ref
);
3265 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3266 static void prune_unused_types_mark (dw_die_ref
, int);
3267 static void prune_unused_types_walk (dw_die_ref
);
3268 static void prune_unused_types_walk_attribs (dw_die_ref
);
3269 static void prune_unused_types_prune (dw_die_ref
);
3270 static void prune_unused_types (void);
3271 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3272 static inline const char *AT_vms_delta1 (dw_attr_ref
);
3273 static inline const char *AT_vms_delta2 (dw_attr_ref
);
3274 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3275 const char *, const char *);
3276 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3277 static void gen_remaining_tmpl_value_param_die_attribute (void);
3278 static bool generic_type_p (tree
);
3279 static void schedule_generic_params_dies_gen (tree t
);
3280 static void gen_scheduled_generic_parms_dies (void);
3282 static const char *comp_dir_string (void);
3284 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
3286 /* enum for tracking thread-local variables whose address is really an offset
3287 relative to the TLS pointer, which will need link-time relocation, but will
3288 not need relocation by the DWARF consumer. */
3296 /* Return the operator to use for an address of a variable. For dtprel_true, we
3297 use DW_OP_const*. For regular variables, which need both link-time
3298 relocation and consumer-level relocation (e.g., to account for shared objects
3299 loaded at a random address), we use DW_OP_addr*. */
3301 static inline enum dwarf_location_atom
3302 dw_addr_op (enum dtprel_bool dtprel
)
3304 if (dtprel
== dtprel_true
)
3305 return (dwarf_split_debug_info
? DW_OP_GNU_const_index
3306 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3308 return dwarf_split_debug_info
? DW_OP_GNU_addr_index
: DW_OP_addr
;
3311 /* Return a pointer to a newly allocated address location description. If
3312 dwarf_split_debug_info is true, then record the address with the appropriate
3314 static inline dw_loc_descr_ref
3315 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3317 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3319 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3320 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3321 ref
->dtprel
= dtprel
;
3322 if (dwarf_split_debug_info
)
3323 ref
->dw_loc_oprnd1
.val_entry
3324 = add_addr_table_entry (addr
,
3325 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3327 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3332 /* Section names used to hold DWARF debugging information. */
3334 #ifndef DEBUG_INFO_SECTION
3335 #define DEBUG_INFO_SECTION ".debug_info"
3337 #ifndef DEBUG_DWO_INFO_SECTION
3338 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3340 #ifndef DEBUG_ABBREV_SECTION
3341 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3343 #ifndef DEBUG_DWO_ABBREV_SECTION
3344 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3346 #ifndef DEBUG_ARANGES_SECTION
3347 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3349 #ifndef DEBUG_ADDR_SECTION
3350 #define DEBUG_ADDR_SECTION ".debug_addr"
3352 #ifndef DEBUG_NORM_MACINFO_SECTION
3353 #define DEBUG_NORM_MACINFO_SECTION ".debug_macinfo"
3355 #ifndef DEBUG_DWO_MACINFO_SECTION
3356 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3358 #ifndef DEBUG_MACINFO_SECTION
3359 #define DEBUG_MACINFO_SECTION \
3360 (!dwarf_split_debug_info \
3361 ? (DEBUG_NORM_MACINFO_SECTION) : (DEBUG_DWO_MACINFO_SECTION))
3363 #ifndef DEBUG_NORM_MACRO_SECTION
3364 #define DEBUG_NORM_MACRO_SECTION ".debug_macro"
3366 #ifndef DEBUG_DWO_MACRO_SECTION
3367 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3369 #ifndef DEBUG_MACRO_SECTION
3370 #define DEBUG_MACRO_SECTION \
3371 (!dwarf_split_debug_info \
3372 ? (DEBUG_NORM_MACRO_SECTION) : (DEBUG_DWO_MACRO_SECTION))
3374 #ifndef DEBUG_LINE_SECTION
3375 #define DEBUG_LINE_SECTION ".debug_line"
3377 #ifndef DEBUG_DWO_LINE_SECTION
3378 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3380 #ifndef DEBUG_LOC_SECTION
3381 #define DEBUG_LOC_SECTION ".debug_loc"
3383 #ifndef DEBUG_DWO_LOC_SECTION
3384 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3386 #ifndef DEBUG_PUBNAMES_SECTION
3387 #define DEBUG_PUBNAMES_SECTION \
3388 ((debug_generate_pub_sections == 2) \
3389 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3391 #ifndef DEBUG_PUBTYPES_SECTION
3392 #define DEBUG_PUBTYPES_SECTION \
3393 ((debug_generate_pub_sections == 2) \
3394 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3396 #define DEBUG_NORM_STR_OFFSETS_SECTION ".debug_str_offsets"
3397 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3398 #ifndef DEBUG_STR_OFFSETS_SECTION
3399 #define DEBUG_STR_OFFSETS_SECTION \
3400 (!dwarf_split_debug_info \
3401 ? (DEBUG_NORM_STR_OFFSETS_SECTION) : (DEBUG_DWO_STR_OFFSETS_SECTION))
3403 #ifndef DEBUG_STR_DWO_SECTION
3404 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3406 #ifndef DEBUG_STR_SECTION
3407 #define DEBUG_STR_SECTION ".debug_str"
3409 #ifndef DEBUG_RANGES_SECTION
3410 #define DEBUG_RANGES_SECTION ".debug_ranges"
3413 /* Standard ELF section names for compiled code and data. */
3414 #ifndef TEXT_SECTION_NAME
3415 #define TEXT_SECTION_NAME ".text"
3418 /* Section flags for .debug_macinfo/.debug_macro section. */
3419 #define DEBUG_MACRO_SECTION_FLAGS \
3420 (dwarf_split_debug_info ? SECTION_DEBUG | SECTION_EXCLUDE : SECTION_DEBUG)
3422 /* Section flags for .debug_str section. */
3423 #define DEBUG_STR_SECTION_FLAGS \
3424 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3425 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3428 /* Section flags for .debug_str.dwo section. */
3429 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3431 /* Labels we insert at beginning sections we can reference instead of
3432 the section names themselves. */
3434 #ifndef TEXT_SECTION_LABEL
3435 #define TEXT_SECTION_LABEL "Ltext"
3437 #ifndef COLD_TEXT_SECTION_LABEL
3438 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3440 #ifndef DEBUG_LINE_SECTION_LABEL
3441 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3443 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3444 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3446 #ifndef DEBUG_INFO_SECTION_LABEL
3447 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3449 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3450 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3452 #ifndef DEBUG_ABBREV_SECTION_LABEL
3453 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3455 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3456 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3458 #ifndef DEBUG_ADDR_SECTION_LABEL
3459 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3461 #ifndef DEBUG_LOC_SECTION_LABEL
3462 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3464 #ifndef DEBUG_RANGES_SECTION_LABEL
3465 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3467 #ifndef DEBUG_MACINFO_SECTION_LABEL
3468 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3470 #ifndef DEBUG_MACRO_SECTION_LABEL
3471 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3473 #define SKELETON_COMP_DIE_ABBREV 1
3474 #define SKELETON_TYPE_DIE_ABBREV 2
3476 /* Definitions of defaults for formats and names of various special
3477 (artificial) labels which may be generated within this file (when the -g
3478 options is used and DWARF2_DEBUGGING_INFO is in effect.
3479 If necessary, these may be overridden from within the tm.h file, but
3480 typically, overriding these defaults is unnecessary. */
3482 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3483 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3484 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3485 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3486 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3487 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3488 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3489 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3490 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3491 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3492 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3493 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3494 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3495 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3497 #ifndef TEXT_END_LABEL
3498 #define TEXT_END_LABEL "Letext"
3500 #ifndef COLD_END_LABEL
3501 #define COLD_END_LABEL "Letext_cold"
3503 #ifndef BLOCK_BEGIN_LABEL
3504 #define BLOCK_BEGIN_LABEL "LBB"
3506 #ifndef BLOCK_END_LABEL
3507 #define BLOCK_END_LABEL "LBE"
3509 #ifndef LINE_CODE_LABEL
3510 #define LINE_CODE_LABEL "LM"
3514 /* Return the root of the DIE's built for the current compilation unit. */
3516 comp_unit_die (void)
3518 if (!single_comp_unit_die
)
3519 single_comp_unit_die
= gen_compile_unit_die (NULL
);
3520 return single_comp_unit_die
;
3523 /* We allow a language front-end to designate a function that is to be
3524 called to "demangle" any name before it is put into a DIE. */
3526 static const char *(*demangle_name_func
) (const char *);
3529 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3531 demangle_name_func
= func
;
3534 /* Test if rtl node points to a pseudo register. */
3537 is_pseudo_reg (const_rtx rtl
)
3539 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3540 || (GET_CODE (rtl
) == SUBREG
3541 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3544 /* Return a reference to a type, with its const and volatile qualifiers
3548 type_main_variant (tree type
)
3550 type
= TYPE_MAIN_VARIANT (type
);
3552 /* ??? There really should be only one main variant among any group of
3553 variants of a given type (and all of the MAIN_VARIANT values for all
3554 members of the group should point to that one type) but sometimes the C
3555 front-end messes this up for array types, so we work around that bug
3557 if (TREE_CODE (type
) == ARRAY_TYPE
)
3558 while (type
!= TYPE_MAIN_VARIANT (type
))
3559 type
= TYPE_MAIN_VARIANT (type
);
3564 /* Return nonzero if the given type node represents a tagged type. */
3567 is_tagged_type (const_tree type
)
3569 enum tree_code code
= TREE_CODE (type
);
3571 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
3572 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
3575 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3578 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
3580 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
3583 /* Return die_offset of a DIE reference to a base type. */
3585 static unsigned long int
3586 get_base_type_offset (dw_die_ref ref
)
3588 if (ref
->die_offset
)
3589 return ref
->die_offset
;
3590 if (comp_unit_die ()->die_abbrev
)
3592 calc_base_type_die_sizes ();
3593 gcc_assert (ref
->die_offset
);
3595 return ref
->die_offset
;
3598 /* Return die_offset of a DIE reference other than base type. */
3600 static unsigned long int
3601 get_ref_die_offset (dw_die_ref ref
)
3603 gcc_assert (ref
->die_offset
);
3604 return ref
->die_offset
;
3607 /* Convert a DIE tag into its string name. */
3610 dwarf_tag_name (unsigned int tag
)
3612 const char *name
= get_DW_TAG_name (tag
);
3617 return "DW_TAG_<unknown>";
3620 /* Convert a DWARF attribute code into its string name. */
3623 dwarf_attr_name (unsigned int attr
)
3629 #if VMS_DEBUGGING_INFO
3630 case DW_AT_HP_prologue
:
3631 return "DW_AT_HP_prologue";
3633 case DW_AT_MIPS_loop_unroll_factor
:
3634 return "DW_AT_MIPS_loop_unroll_factor";
3637 #if VMS_DEBUGGING_INFO
3638 case DW_AT_HP_epilogue
:
3639 return "DW_AT_HP_epilogue";
3641 case DW_AT_MIPS_stride
:
3642 return "DW_AT_MIPS_stride";
3646 name
= get_DW_AT_name (attr
);
3651 return "DW_AT_<unknown>";
3654 /* Convert a DWARF value form code into its string name. */
3657 dwarf_form_name (unsigned int form
)
3659 const char *name
= get_DW_FORM_name (form
);
3664 return "DW_FORM_<unknown>";
3667 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3668 instance of an inlined instance of a decl which is local to an inline
3669 function, so we have to trace all of the way back through the origin chain
3670 to find out what sort of node actually served as the original seed for the
3674 decl_ultimate_origin (const_tree decl
)
3676 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
3679 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
3680 we're trying to output the abstract instance of this function. */
3681 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
3684 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3685 most distant ancestor, this should never happen. */
3686 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
3688 return DECL_ABSTRACT_ORIGIN (decl
);
3691 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3692 of a virtual function may refer to a base class, so we check the 'this'
3696 decl_class_context (tree decl
)
3698 tree context
= NULL_TREE
;
3700 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
3701 context
= DECL_CONTEXT (decl
);
3703 context
= TYPE_MAIN_VARIANT
3704 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
3706 if (context
&& !TYPE_P (context
))
3707 context
= NULL_TREE
;
3712 /* Add an attribute/value pair to a DIE. */
3715 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
3717 /* Maybe this should be an assert? */
3721 vec_safe_reserve (die
->die_attr
, 1);
3722 vec_safe_push (die
->die_attr
, *attr
);
3725 static inline enum dw_val_class
3726 AT_class (dw_attr_ref a
)
3728 return a
->dw_attr_val
.val_class
;
3731 /* Return the index for any attribute that will be referenced with a
3732 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
3733 are stored in dw_attr_val.v.val_str for reference counting
3736 static inline unsigned int
3737 AT_index (dw_attr_ref a
)
3739 if (AT_class (a
) == dw_val_class_str
)
3740 return a
->dw_attr_val
.v
.val_str
->index
;
3741 else if (a
->dw_attr_val
.val_entry
!= NULL
)
3742 return a
->dw_attr_val
.val_entry
->index
;
3746 /* Add a flag value attribute to a DIE. */
3749 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
3753 attr
.dw_attr
= attr_kind
;
3754 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
3755 attr
.dw_attr_val
.val_entry
= NULL
;
3756 attr
.dw_attr_val
.v
.val_flag
= flag
;
3757 add_dwarf_attr (die
, &attr
);
3760 static inline unsigned
3761 AT_flag (dw_attr_ref a
)
3763 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
3764 return a
->dw_attr_val
.v
.val_flag
;
3767 /* Add a signed integer attribute value to a DIE. */
3770 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
3774 attr
.dw_attr
= attr_kind
;
3775 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
3776 attr
.dw_attr_val
.val_entry
= NULL
;
3777 attr
.dw_attr_val
.v
.val_int
= int_val
;
3778 add_dwarf_attr (die
, &attr
);
3781 static inline HOST_WIDE_INT
3782 AT_int (dw_attr_ref a
)
3784 gcc_assert (a
&& AT_class (a
) == dw_val_class_const
);
3785 return a
->dw_attr_val
.v
.val_int
;
3788 /* Add an unsigned integer attribute value to a DIE. */
3791 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3792 unsigned HOST_WIDE_INT unsigned_val
)
3796 attr
.dw_attr
= attr_kind
;
3797 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
3798 attr
.dw_attr_val
.val_entry
= NULL
;
3799 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
3800 add_dwarf_attr (die
, &attr
);
3803 static inline unsigned HOST_WIDE_INT
3804 AT_unsigned (dw_attr_ref a
)
3806 gcc_assert (a
&& AT_class (a
) == dw_val_class_unsigned_const
);
3807 return a
->dw_attr_val
.v
.val_unsigned
;
3810 /* Add an unsigned wide integer attribute value to a DIE. */
3813 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3818 attr
.dw_attr
= attr_kind
;
3819 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
3820 attr
.dw_attr_val
.v
.val_wide
= ggc_cleared_alloc
<wide_int
> ();
3821 *attr
.dw_attr_val
.v
.val_wide
= w
;
3822 add_dwarf_attr (die
, &attr
);
3825 /* Add an unsigned double integer attribute value to a DIE. */
3828 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3829 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
3833 attr
.dw_attr
= attr_kind
;
3834 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
3835 attr
.dw_attr_val
.val_entry
= NULL
;
3836 attr
.dw_attr_val
.v
.val_double
.high
= high
;
3837 attr
.dw_attr_val
.v
.val_double
.low
= low
;
3838 add_dwarf_attr (die
, &attr
);
3841 /* Add a floating point attribute value to a DIE and return it. */
3844 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3845 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
3849 attr
.dw_attr
= attr_kind
;
3850 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
3851 attr
.dw_attr_val
.val_entry
= NULL
;
3852 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
3853 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
3854 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
3855 add_dwarf_attr (die
, &attr
);
3858 /* Add an 8-byte data attribute value to a DIE. */
3861 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3862 unsigned char data8
[8])
3866 attr
.dw_attr
= attr_kind
;
3867 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
3868 attr
.dw_attr_val
.val_entry
= NULL
;
3869 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
3870 add_dwarf_attr (die
, &attr
);
3873 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
3874 dwarf_split_debug_info, address attributes in dies destined for the
3875 final executable have force_direct set to avoid using indexed
3879 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
3885 lbl_id
= xstrdup (lbl_low
);
3886 attr
.dw_attr
= DW_AT_low_pc
;
3887 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
3888 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
3889 if (dwarf_split_debug_info
&& !force_direct
)
3890 attr
.dw_attr_val
.val_entry
3891 = add_addr_table_entry (lbl_id
, ate_kind_label
);
3893 attr
.dw_attr_val
.val_entry
= NULL
;
3894 add_dwarf_attr (die
, &attr
);
3896 attr
.dw_attr
= DW_AT_high_pc
;
3897 if (dwarf_version
< 4)
3898 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
3900 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
3901 lbl_id
= xstrdup (lbl_high
);
3902 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
3903 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
3904 && dwarf_split_debug_info
&& !force_direct
)
3905 attr
.dw_attr_val
.val_entry
3906 = add_addr_table_entry (lbl_id
, ate_kind_label
);
3908 attr
.dw_attr_val
.val_entry
= NULL
;
3909 add_dwarf_attr (die
, &attr
);
3912 /* Hash and equality functions for debug_str_hash. */
3915 debug_str_do_hash (const void *x
)
3917 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
3921 debug_str_eq (const void *x1
, const void *x2
)
3923 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
3924 (const char *)x2
) == 0;
3927 /* Add STR to the given string hash table. */
3929 static struct indirect_string_node
*
3930 find_AT_string_in_table (const char *str
, htab_t table
)
3932 struct indirect_string_node
*node
;
3935 slot
= htab_find_slot_with_hash (table
, str
,
3936 htab_hash_string (str
), INSERT
);
3939 node
= ggc_cleared_alloc
<indirect_string_node
> ();
3940 node
->str
= ggc_strdup (str
);
3944 node
= (struct indirect_string_node
*) *slot
;
3950 /* Add STR to the indirect string hash table. */
3952 static struct indirect_string_node
*
3953 find_AT_string (const char *str
)
3955 if (! debug_str_hash
)
3956 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
3957 debug_str_eq
, NULL
);
3959 return find_AT_string_in_table (str
, debug_str_hash
);
3962 /* Add a string attribute value to a DIE. */
3965 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
3968 struct indirect_string_node
*node
;
3970 node
= find_AT_string (str
);
3972 attr
.dw_attr
= attr_kind
;
3973 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
3974 attr
.dw_attr_val
.val_entry
= NULL
;
3975 attr
.dw_attr_val
.v
.val_str
= node
;
3976 add_dwarf_attr (die
, &attr
);
3979 static inline const char *
3980 AT_string (dw_attr_ref a
)
3982 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
3983 return a
->dw_attr_val
.v
.val_str
->str
;
3986 /* Call this function directly to bypass AT_string_form's logic to put
3987 the string inline in the die. */
3990 set_indirect_string (struct indirect_string_node
*node
)
3993 /* Already indirect is a no op. */
3994 if (node
->form
== DW_FORM_strp
|| node
->form
== DW_FORM_GNU_str_index
)
3996 gcc_assert (node
->label
);
3999 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4000 ++dw2_string_counter
;
4001 node
->label
= xstrdup (label
);
4003 if (!dwarf_split_debug_info
)
4005 node
->form
= DW_FORM_strp
;
4006 node
->index
= NOT_INDEXED
;
4010 node
->form
= DW_FORM_GNU_str_index
;
4011 node
->index
= NO_INDEX_ASSIGNED
;
4015 /* Find out whether a string should be output inline in DIE
4016 or out-of-line in .debug_str section. */
4018 static enum dwarf_form
4019 find_string_form (struct indirect_string_node
*node
)
4026 len
= strlen (node
->str
) + 1;
4028 /* If the string is shorter or equal to the size of the reference, it is
4029 always better to put it inline. */
4030 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4031 return node
->form
= DW_FORM_string
;
4033 /* If we cannot expect the linker to merge strings in .debug_str
4034 section, only put it into .debug_str if it is worth even in this
4036 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4037 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4038 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4039 return node
->form
= DW_FORM_string
;
4041 set_indirect_string (node
);
4046 /* Find out whether the string referenced from the attribute should be
4047 output inline in DIE or out-of-line in .debug_str section. */
4049 static enum dwarf_form
4050 AT_string_form (dw_attr_ref a
)
4052 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4053 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4056 /* Add a DIE reference attribute value to a DIE. */
4059 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4063 #ifdef ENABLE_CHECKING
4064 gcc_assert (targ_die
!= NULL
);
4066 /* With LTO we can end up trying to reference something we didn't create
4067 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4068 if (targ_die
== NULL
)
4072 attr
.dw_attr
= attr_kind
;
4073 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4074 attr
.dw_attr_val
.val_entry
= NULL
;
4075 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4076 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4077 add_dwarf_attr (die
, &attr
);
4080 /* Change DIE reference REF to point to NEW_DIE instead. */
4083 change_AT_die_ref (dw_attr_ref ref
, dw_die_ref new_die
)
4085 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4086 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4087 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4090 /* Add an AT_specification attribute to a DIE, and also make the back
4091 pointer from the specification to the definition. */
4094 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4096 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4097 gcc_assert (!targ_die
->die_definition
);
4098 targ_die
->die_definition
= die
;
4101 static inline dw_die_ref
4102 AT_ref (dw_attr_ref a
)
4104 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4105 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4109 AT_ref_external (dw_attr_ref a
)
4111 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4112 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4118 set_AT_ref_external (dw_attr_ref a
, int i
)
4120 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4121 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4124 /* Add an FDE reference attribute value to a DIE. */
4127 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4131 attr
.dw_attr
= attr_kind
;
4132 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4133 attr
.dw_attr_val
.val_entry
= NULL
;
4134 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4135 add_dwarf_attr (die
, &attr
);
4138 /* Add a location description attribute value to a DIE. */
4141 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4145 attr
.dw_attr
= attr_kind
;
4146 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4147 attr
.dw_attr_val
.val_entry
= NULL
;
4148 attr
.dw_attr_val
.v
.val_loc
= loc
;
4149 add_dwarf_attr (die
, &attr
);
4152 static inline dw_loc_descr_ref
4153 AT_loc (dw_attr_ref a
)
4155 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4156 return a
->dw_attr_val
.v
.val_loc
;
4160 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4164 attr
.dw_attr
= attr_kind
;
4165 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4166 attr
.dw_attr_val
.val_entry
= NULL
;
4167 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4168 add_dwarf_attr (die
, &attr
);
4169 have_location_lists
= true;
4172 static inline dw_loc_list_ref
4173 AT_loc_list (dw_attr_ref a
)
4175 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4176 return a
->dw_attr_val
.v
.val_loc_list
;
4179 static inline dw_loc_list_ref
*
4180 AT_loc_list_ptr (dw_attr_ref a
)
4182 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4183 return &a
->dw_attr_val
.v
.val_loc_list
;
4186 /* Table of entries into the .debug_addr section. */
4188 static GTY ((param_is (addr_table_entry
))) htab_t addr_index_table
;
4190 /* Hash an address_table_entry. */
4193 addr_table_entry_do_hash (const void *x
)
4195 const addr_table_entry
*a
= (const addr_table_entry
*) x
;
4196 inchash::hash hstate
;
4202 case ate_kind_rtx_dtprel
:
4205 case ate_kind_label
:
4206 return htab_hash_string (a
->addr
.label
);
4210 inchash::add_rtx (a
->addr
.rtl
, hstate
);
4211 return hstate
.end ();
4214 /* Determine equality for two address_table_entries. */
4217 addr_table_entry_eq (const void *x1
, const void *x2
)
4219 const addr_table_entry
*a1
= (const addr_table_entry
*) x1
;
4220 const addr_table_entry
*a2
= (const addr_table_entry
*) x2
;
4222 if (a1
->kind
!= a2
->kind
)
4227 case ate_kind_rtx_dtprel
:
4228 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4229 case ate_kind_label
:
4230 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
4236 /* Initialize an addr_table_entry. */
4239 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
4245 case ate_kind_rtx_dtprel
:
4246 e
->addr
.rtl
= (rtx
) addr
;
4248 case ate_kind_label
:
4249 e
->addr
.label
= (char *) addr
;
4253 e
->index
= NO_INDEX_ASSIGNED
;
4256 /* Add attr to the address table entry to the table. Defer setting an
4257 index until output time. */
4259 static addr_table_entry
*
4260 add_addr_table_entry (void *addr
, enum ate_kind kind
)
4262 addr_table_entry
*node
;
4263 addr_table_entry finder
;
4266 gcc_assert (dwarf_split_debug_info
);
4267 if (! addr_index_table
)
4268 addr_index_table
= htab_create_ggc (10, addr_table_entry_do_hash
,
4269 addr_table_entry_eq
, NULL
);
4270 init_addr_table_entry (&finder
, kind
, addr
);
4271 slot
= htab_find_slot (addr_index_table
, &finder
, INSERT
);
4273 if (*slot
== HTAB_EMPTY_ENTRY
)
4275 node
= ggc_cleared_alloc
<addr_table_entry
> ();
4276 init_addr_table_entry (node
, kind
, addr
);
4280 node
= (addr_table_entry
*) *slot
;
4286 /* Remove an entry from the addr table by decrementing its refcount.
4287 Strictly, decrementing the refcount would be enough, but the
4288 assertion that the entry is actually in the table has found
4292 remove_addr_table_entry (addr_table_entry
*entry
)
4294 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
4295 /* After an index is assigned, the table is frozen. */
4296 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
4300 /* Given a location list, remove all addresses it refers to from the
4304 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
4306 for (; descr
; descr
= descr
->dw_loc_next
)
4307 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
4309 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
4310 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
4314 /* A helper function for dwarf2out_finish called through
4315 htab_traverse. Assign an addr_table_entry its index. All entries
4316 must be collected into the table when this function is called,
4317 because the indexing code relies on htab_traverse to traverse nodes
4318 in the same order for each run. */
4321 index_addr_table_entry (void **h
, void *v
)
4323 addr_table_entry
*node
= (addr_table_entry
*) *h
;
4324 unsigned int *index
= (unsigned int *) v
;
4326 /* Don't index unreferenced nodes. */
4327 if (node
->refcount
== 0)
4330 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
4331 node
->index
= *index
;
4337 /* Add an address constant attribute value to a DIE. When using
4338 dwarf_split_debug_info, address attributes in dies destined for the
4339 final executable should be direct references--setting the parameter
4340 force_direct ensures this behavior. */
4343 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
4348 attr
.dw_attr
= attr_kind
;
4349 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
4350 attr
.dw_attr_val
.v
.val_addr
= addr
;
4351 if (dwarf_split_debug_info
&& !force_direct
)
4352 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
4354 attr
.dw_attr_val
.val_entry
= NULL
;
4355 add_dwarf_attr (die
, &attr
);
4358 /* Get the RTX from to an address DIE attribute. */
4361 AT_addr (dw_attr_ref a
)
4363 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
4364 return a
->dw_attr_val
.v
.val_addr
;
4367 /* Add a file attribute value to a DIE. */
4370 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4371 struct dwarf_file_data
*fd
)
4375 attr
.dw_attr
= attr_kind
;
4376 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
4377 attr
.dw_attr_val
.val_entry
= NULL
;
4378 attr
.dw_attr_val
.v
.val_file
= fd
;
4379 add_dwarf_attr (die
, &attr
);
4382 /* Get the dwarf_file_data from a file DIE attribute. */
4384 static inline struct dwarf_file_data
*
4385 AT_file (dw_attr_ref a
)
4387 gcc_assert (a
&& AT_class (a
) == dw_val_class_file
);
4388 return a
->dw_attr_val
.v
.val_file
;
4391 /* Add a vms delta attribute value to a DIE. */
4394 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4395 const char *lbl1
, const char *lbl2
)
4399 attr
.dw_attr
= attr_kind
;
4400 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
4401 attr
.dw_attr_val
.val_entry
= NULL
;
4402 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
4403 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
4404 add_dwarf_attr (die
, &attr
);
4407 /* Add a label identifier attribute value to a DIE. */
4410 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4415 attr
.dw_attr
= attr_kind
;
4416 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4417 attr
.dw_attr_val
.val_entry
= NULL
;
4418 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4419 if (dwarf_split_debug_info
)
4420 attr
.dw_attr_val
.val_entry
4421 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
4423 add_dwarf_attr (die
, &attr
);
4426 /* Add a section offset attribute value to a DIE, an offset into the
4427 debug_line section. */
4430 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4435 attr
.dw_attr
= attr_kind
;
4436 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
4437 attr
.dw_attr_val
.val_entry
= NULL
;
4438 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4439 add_dwarf_attr (die
, &attr
);
4442 /* Add a section offset attribute value to a DIE, an offset into the
4443 debug_macinfo section. */
4446 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4451 attr
.dw_attr
= attr_kind
;
4452 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
4453 attr
.dw_attr_val
.val_entry
= NULL
;
4454 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4455 add_dwarf_attr (die
, &attr
);
4458 /* Add an offset attribute value to a DIE. */
4461 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4462 unsigned HOST_WIDE_INT offset
)
4466 attr
.dw_attr
= attr_kind
;
4467 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
4468 attr
.dw_attr_val
.val_entry
= NULL
;
4469 attr
.dw_attr_val
.v
.val_offset
= offset
;
4470 add_dwarf_attr (die
, &attr
);
4473 /* Add a range_list attribute value to a DIE. When using
4474 dwarf_split_debug_info, address attributes in dies destined for the
4475 final executable should be direct references--setting the parameter
4476 force_direct ensures this behavior. */
4478 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4479 #define RELOCATED_OFFSET (NULL)
4482 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4483 long unsigned int offset
, bool force_direct
)
4487 attr
.dw_attr
= attr_kind
;
4488 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
4489 /* For the range_list attribute, use val_entry to store whether the
4490 offset should follow split-debug-info or normal semantics. This
4491 value is read in output_range_list_offset. */
4492 if (dwarf_split_debug_info
&& !force_direct
)
4493 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
4495 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
4496 attr
.dw_attr_val
.v
.val_offset
= offset
;
4497 add_dwarf_attr (die
, &attr
);
4500 /* Return the start label of a delta attribute. */
4502 static inline const char *
4503 AT_vms_delta1 (dw_attr_ref a
)
4505 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4506 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
4509 /* Return the end label of a delta attribute. */
4511 static inline const char *
4512 AT_vms_delta2 (dw_attr_ref a
)
4514 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4515 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
4518 static inline const char *
4519 AT_lbl (dw_attr_ref a
)
4521 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
4522 || AT_class (a
) == dw_val_class_lineptr
4523 || AT_class (a
) == dw_val_class_macptr
4524 || AT_class (a
) == dw_val_class_high_pc
));
4525 return a
->dw_attr_val
.v
.val_lbl_id
;
4528 /* Get the attribute of type attr_kind. */
4531 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4535 dw_die_ref spec
= NULL
;
4540 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4541 if (a
->dw_attr
== attr_kind
)
4543 else if (a
->dw_attr
== DW_AT_specification
4544 || a
->dw_attr
== DW_AT_abstract_origin
)
4548 return get_AT (spec
, attr_kind
);
4553 /* Returns the parent of the declaration of DIE. */
4556 get_die_parent (dw_die_ref die
)
4563 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
4564 || (t
= get_AT_ref (die
, DW_AT_specification
)))
4567 return die
->die_parent
;
4570 /* Return the "low pc" attribute value, typically associated with a subprogram
4571 DIE. Return null if the "low pc" attribute is either not present, or if it
4572 cannot be represented as an assembler label identifier. */
4574 static inline const char *
4575 get_AT_low_pc (dw_die_ref die
)
4577 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
4579 return a
? AT_lbl (a
) : NULL
;
4582 /* Return the "high pc" attribute value, typically associated with a subprogram
4583 DIE. Return null if the "high pc" attribute is either not present, or if it
4584 cannot be represented as an assembler label identifier. */
4586 static inline const char *
4587 get_AT_hi_pc (dw_die_ref die
)
4589 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
4591 return a
? AT_lbl (a
) : NULL
;
4594 /* Return the value of the string attribute designated by ATTR_KIND, or
4595 NULL if it is not present. */
4597 static inline const char *
4598 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4600 dw_attr_ref a
= get_AT (die
, attr_kind
);
4602 return a
? AT_string (a
) : NULL
;
4605 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4606 if it is not present. */
4609 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4611 dw_attr_ref a
= get_AT (die
, attr_kind
);
4613 return a
? AT_flag (a
) : 0;
4616 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4617 if it is not present. */
4619 static inline unsigned
4620 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4622 dw_attr_ref a
= get_AT (die
, attr_kind
);
4624 return a
? AT_unsigned (a
) : 0;
4627 static inline dw_die_ref
4628 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4630 dw_attr_ref a
= get_AT (die
, attr_kind
);
4632 return a
? AT_ref (a
) : NULL
;
4635 static inline struct dwarf_file_data
*
4636 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4638 dw_attr_ref a
= get_AT (die
, attr_kind
);
4640 return a
? AT_file (a
) : NULL
;
4643 /* Return TRUE if the language is C++. */
4648 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4650 return lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
;
4653 /* Return TRUE if the language is Java. */
4658 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4660 return lang
== DW_LANG_Java
;
4663 /* Return TRUE if the language is Fortran. */
4668 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4670 return (lang
== DW_LANG_Fortran77
4671 || lang
== DW_LANG_Fortran90
4672 || lang
== DW_LANG_Fortran95
);
4675 /* Return TRUE if the language is Ada. */
4680 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4682 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
4685 /* Remove the specified attribute if present. */
4688 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4696 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4697 if (a
->dw_attr
== attr_kind
)
4699 if (AT_class (a
) == dw_val_class_str
)
4700 if (a
->dw_attr_val
.v
.val_str
->refcount
)
4701 a
->dw_attr_val
.v
.val_str
->refcount
--;
4703 /* vec::ordered_remove should help reduce the number of abbrevs
4705 die
->die_attr
->ordered_remove (ix
);
4710 /* Remove CHILD from its parent. PREV must have the property that
4711 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4714 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
4716 gcc_assert (child
->die_parent
== prev
->die_parent
);
4717 gcc_assert (prev
->die_sib
== child
);
4720 gcc_assert (child
->die_parent
->die_child
== child
);
4724 prev
->die_sib
= child
->die_sib
;
4725 if (child
->die_parent
->die_child
== child
)
4726 child
->die_parent
->die_child
= prev
;
4729 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4730 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4733 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
4735 dw_die_ref parent
= old_child
->die_parent
;
4737 gcc_assert (parent
== prev
->die_parent
);
4738 gcc_assert (prev
->die_sib
== old_child
);
4740 new_child
->die_parent
= parent
;
4741 if (prev
== old_child
)
4743 gcc_assert (parent
->die_child
== old_child
);
4744 new_child
->die_sib
= new_child
;
4748 prev
->die_sib
= new_child
;
4749 new_child
->die_sib
= old_child
->die_sib
;
4751 if (old_child
->die_parent
->die_child
== old_child
)
4752 old_child
->die_parent
->die_child
= new_child
;
4755 /* Move all children from OLD_PARENT to NEW_PARENT. */
4758 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
4761 new_parent
->die_child
= old_parent
->die_child
;
4762 old_parent
->die_child
= NULL
;
4763 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
4766 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4770 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
4776 dw_die_ref prev
= c
;
4778 while (c
->die_tag
== tag
)
4780 remove_child_with_prev (c
, prev
);
4781 /* Might have removed every child. */
4782 if (c
== c
->die_sib
)
4786 } while (c
!= die
->die_child
);
4789 /* Add a CHILD_DIE as the last child of DIE. */
4792 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
4794 /* FIXME this should probably be an assert. */
4795 if (! die
|| ! child_die
)
4797 gcc_assert (die
!= child_die
);
4799 child_die
->die_parent
= die
;
4802 child_die
->die_sib
= die
->die_child
->die_sib
;
4803 die
->die_child
->die_sib
= child_die
;
4806 child_die
->die_sib
= child_die
;
4807 die
->die_child
= child_die
;
4810 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4811 is the specification, to the end of PARENT's list of children.
4812 This is done by removing and re-adding it. */
4815 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
4819 /* We want the declaration DIE from inside the class, not the
4820 specification DIE at toplevel. */
4821 if (child
->die_parent
!= parent
)
4823 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
4829 gcc_assert (child
->die_parent
== parent
4830 || (child
->die_parent
4831 == get_AT_ref (parent
, DW_AT_specification
)));
4833 for (p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
4834 if (p
->die_sib
== child
)
4836 remove_child_with_prev (child
, p
);
4840 add_child_die (parent
, child
);
4843 /* Return a pointer to a newly created DIE node. */
4845 static inline dw_die_ref
4846 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
4848 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
4850 die
->die_tag
= tag_value
;
4852 if (parent_die
!= NULL
)
4853 add_child_die (parent_die
, die
);
4856 limbo_die_node
*limbo_node
;
4858 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
4859 limbo_node
->die
= die
;
4860 limbo_node
->created_for
= t
;
4861 limbo_node
->next
= limbo_die_list
;
4862 limbo_die_list
= limbo_node
;
4868 /* Return the DIE associated with the given type specifier. */
4870 static inline dw_die_ref
4871 lookup_type_die (tree type
)
4873 return TYPE_SYMTAB_DIE (type
);
4876 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
4877 anonymous type named by the typedef TYPE_DIE, return the DIE of the
4878 anonymous type instead the one of the naming typedef. */
4880 static inline dw_die_ref
4881 strip_naming_typedef (tree type
, dw_die_ref type_die
)
4884 && TREE_CODE (type
) == RECORD_TYPE
4886 && type_die
->die_tag
== DW_TAG_typedef
4887 && is_naming_typedef_decl (TYPE_NAME (type
)))
4888 type_die
= get_AT_ref (type_die
, DW_AT_type
);
4892 /* Like lookup_type_die, but if type is an anonymous type named by a
4893 typedef[1], return the DIE of the anonymous type instead the one of
4894 the naming typedef. This is because in gen_typedef_die, we did
4895 equate the anonymous struct named by the typedef with the DIE of
4896 the naming typedef. So by default, lookup_type_die on an anonymous
4897 struct yields the DIE of the naming typedef.
4899 [1]: Read the comment of is_naming_typedef_decl to learn about what
4900 a naming typedef is. */
4902 static inline dw_die_ref
4903 lookup_type_die_strip_naming_typedef (tree type
)
4905 dw_die_ref die
= lookup_type_die (type
);
4906 return strip_naming_typedef (type
, die
);
4909 /* Equate a DIE to a given type specifier. */
4912 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
4914 TYPE_SYMTAB_DIE (type
) = type_die
;
4917 /* Returns a hash value for X (which really is a die_struct). */
4920 decl_die_table_hash (const void *x
)
4922 return (hashval_t
) ((const_dw_die_ref
) x
)->decl_id
;
4925 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
4928 decl_die_table_eq (const void *x
, const void *y
)
4930 return (((const_dw_die_ref
) x
)->decl_id
== DECL_UID ((const_tree
) y
));
4933 /* Return the DIE associated with a given declaration. */
4935 static inline dw_die_ref
4936 lookup_decl_die (tree decl
)
4938 return (dw_die_ref
) htab_find_with_hash (decl_die_table
, decl
, DECL_UID (decl
));
4941 /* Returns a hash value for X (which really is a var_loc_list). */
4944 decl_loc_table_hash (const void *x
)
4946 return (hashval_t
) ((const var_loc_list
*) x
)->decl_id
;
4949 /* Return nonzero if decl_id of var_loc_list X is the same as
4953 decl_loc_table_eq (const void *x
, const void *y
)
4955 return (((const var_loc_list
*) x
)->decl_id
== DECL_UID ((const_tree
) y
));
4958 /* Return the var_loc list associated with a given declaration. */
4960 static inline var_loc_list
*
4961 lookup_decl_loc (const_tree decl
)
4963 if (!decl_loc_table
)
4965 return (var_loc_list
*)
4966 htab_find_with_hash (decl_loc_table
, decl
, DECL_UID (decl
));
4969 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
4972 cached_dw_loc_list_table_hash (const void *x
)
4974 return (hashval_t
) ((const cached_dw_loc_list
*) x
)->decl_id
;
4977 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
4981 cached_dw_loc_list_table_eq (const void *x
, const void *y
)
4983 return (((const cached_dw_loc_list
*) x
)->decl_id
4984 == DECL_UID ((const_tree
) y
));
4987 /* Equate a DIE to a particular declaration. */
4990 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
4992 unsigned int decl_id
= DECL_UID (decl
);
4995 slot
= htab_find_slot_with_hash (decl_die_table
, decl
, decl_id
, INSERT
);
4997 decl_die
->decl_id
= decl_id
;
5000 /* Return how many bits covers PIECE EXPR_LIST. */
5003 decl_piece_bitsize (rtx piece
)
5005 int ret
= (int) GET_MODE (piece
);
5008 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
5009 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
5010 return INTVAL (XEXP (XEXP (piece
, 0), 0));
5013 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5016 decl_piece_varloc_ptr (rtx piece
)
5018 if ((int) GET_MODE (piece
))
5019 return &XEXP (piece
, 0);
5021 return &XEXP (XEXP (piece
, 0), 1);
5024 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5025 Next is the chain of following piece nodes. */
5027 static rtx_expr_list
*
5028 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
5030 if (bitsize
<= (int) MAX_MACHINE_MODE
)
5031 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
5033 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
5038 /* Return rtx that should be stored into loc field for
5039 LOC_NOTE and BITPOS/BITSIZE. */
5042 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
5043 HOST_WIDE_INT bitsize
)
5047 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
5049 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
5054 /* This function either modifies location piece list *DEST in
5055 place (if SRC and INNER is NULL), or copies location piece list
5056 *SRC to *DEST while modifying it. Location BITPOS is modified
5057 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5058 not copied and if needed some padding around it is added.
5059 When modifying in place, DEST should point to EXPR_LIST where
5060 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5061 to the start of the whole list and INNER points to the EXPR_LIST
5062 where earlier pieces cover PIECE_BITPOS bits. */
5065 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
5066 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
5067 HOST_WIDE_INT bitsize
, rtx loc_note
)
5070 bool copy
= inner
!= NULL
;
5074 /* First copy all nodes preceding the current bitpos. */
5075 while (src
!= inner
)
5077 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5078 decl_piece_bitsize (*src
), NULL_RTX
);
5079 dest
= &XEXP (*dest
, 1);
5080 src
= &XEXP (*src
, 1);
5083 /* Add padding if needed. */
5084 if (bitpos
!= piece_bitpos
)
5086 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
5087 copy
? NULL_RTX
: *dest
);
5088 dest
= &XEXP (*dest
, 1);
5090 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
5093 /* A piece with correct bitpos and bitsize already exist,
5094 just update the location for it and return. */
5095 *decl_piece_varloc_ptr (*dest
) = loc_note
;
5098 /* Add the piece that changed. */
5099 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
5100 dest
= &XEXP (*dest
, 1);
5101 /* Skip over pieces that overlap it. */
5102 diff
= bitpos
- piece_bitpos
+ bitsize
;
5105 while (diff
> 0 && *src
)
5108 diff
-= decl_piece_bitsize (piece
);
5110 src
= &XEXP (piece
, 1);
5113 *src
= XEXP (piece
, 1);
5114 free_EXPR_LIST_node (piece
);
5117 /* Add padding if needed. */
5118 if (diff
< 0 && *src
)
5122 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
5123 dest
= &XEXP (*dest
, 1);
5127 /* Finally copy all nodes following it. */
5130 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5131 decl_piece_bitsize (*src
), NULL_RTX
);
5132 dest
= &XEXP (*dest
, 1);
5133 src
= &XEXP (*src
, 1);
5137 /* Add a variable location node to the linked list for DECL. */
5139 static struct var_loc_node
*
5140 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
)
5142 unsigned int decl_id
;
5145 struct var_loc_node
*loc
= NULL
;
5146 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
5148 if (TREE_CODE (decl
) == VAR_DECL
5149 && DECL_HAS_DEBUG_EXPR_P (decl
))
5151 tree realdecl
= DECL_DEBUG_EXPR (decl
);
5152 if (handled_component_p (realdecl
)
5153 || (TREE_CODE (realdecl
) == MEM_REF
5154 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5156 HOST_WIDE_INT maxsize
;
5159 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
, &maxsize
);
5160 if (!DECL_P (innerdecl
)
5161 || DECL_IGNORED_P (innerdecl
)
5162 || TREE_STATIC (innerdecl
)
5164 || bitpos
+ bitsize
> 256
5165 || bitsize
!= maxsize
)
5171 decl_id
= DECL_UID (decl
);
5172 slot
= htab_find_slot_with_hash (decl_loc_table
, decl
, decl_id
, INSERT
);
5175 temp
= ggc_cleared_alloc
<var_loc_list
> ();
5176 temp
->decl_id
= decl_id
;
5180 temp
= (var_loc_list
*) *slot
;
5182 /* For PARM_DECLs try to keep around the original incoming value,
5183 even if that means we'll emit a zero-range .debug_loc entry. */
5185 && temp
->first
== temp
->last
5186 && TREE_CODE (decl
) == PARM_DECL
5187 && NOTE_P (temp
->first
->loc
)
5188 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
5189 && DECL_INCOMING_RTL (decl
)
5190 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
5191 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
5192 == GET_CODE (DECL_INCOMING_RTL (decl
))
5193 && prev_real_insn (temp
->first
->loc
) == NULL_RTX
5195 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
5196 NOTE_VAR_LOCATION_LOC (loc_note
))
5197 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
5198 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
5200 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5201 temp
->first
->next
= loc
;
5203 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5205 else if (temp
->last
)
5207 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
5208 rtx
*piece_loc
= NULL
, last_loc_note
;
5209 int piece_bitpos
= 0;
5213 gcc_assert (last
->next
== NULL
);
5215 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
5217 piece_loc
= &last
->loc
;
5220 int cur_bitsize
= decl_piece_bitsize (*piece_loc
);
5221 if (piece_bitpos
+ cur_bitsize
> bitpos
)
5223 piece_bitpos
+= cur_bitsize
;
5224 piece_loc
= &XEXP (*piece_loc
, 1);
5228 /* TEMP->LAST here is either pointer to the last but one or
5229 last element in the chained list, LAST is pointer to the
5231 if (label
&& strcmp (last
->label
, label
) == 0)
5233 /* For SRA optimized variables if there weren't any real
5234 insns since last note, just modify the last node. */
5235 if (piece_loc
!= NULL
)
5237 adjust_piece_list (piece_loc
, NULL
, NULL
,
5238 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5241 /* If the last note doesn't cover any instructions, remove it. */
5242 if (temp
->last
!= last
)
5244 temp
->last
->next
= NULL
;
5247 gcc_assert (strcmp (last
->label
, label
) != 0);
5251 gcc_assert (temp
->first
== temp
->last
5252 || (temp
->first
->next
== temp
->last
5253 && TREE_CODE (decl
) == PARM_DECL
));
5254 memset (temp
->last
, '\0', sizeof (*temp
->last
));
5255 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5259 if (bitsize
== -1 && NOTE_P (last
->loc
))
5260 last_loc_note
= last
->loc
;
5261 else if (piece_loc
!= NULL
5262 && *piece_loc
!= NULL_RTX
5263 && piece_bitpos
== bitpos
5264 && decl_piece_bitsize (*piece_loc
) == bitsize
)
5265 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
5267 last_loc_note
= NULL_RTX
;
5268 /* If the current location is the same as the end of the list,
5269 and either both or neither of the locations is uninitialized,
5270 we have nothing to do. */
5271 if (last_loc_note
== NULL_RTX
5272 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
5273 NOTE_VAR_LOCATION_LOC (loc_note
)))
5274 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5275 != NOTE_VAR_LOCATION_STATUS (loc_note
))
5276 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5277 == VAR_INIT_STATUS_UNINITIALIZED
)
5278 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
5279 == VAR_INIT_STATUS_UNINITIALIZED
))))
5281 /* Add LOC to the end of list and update LAST. If the last
5282 element of the list has been removed above, reuse its
5283 memory for the new node, otherwise allocate a new one. */
5287 memset (loc
, '\0', sizeof (*loc
));
5290 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5291 if (bitsize
== -1 || piece_loc
== NULL
)
5292 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5294 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
5295 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5297 /* Ensure TEMP->LAST will point either to the new last but one
5298 element of the chain, or to the last element in it. */
5299 if (last
!= temp
->last
)
5307 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5310 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5315 /* Keep track of the number of spaces used to indent the
5316 output of the debugging routines that print the structure of
5317 the DIE internal representation. */
5318 static int print_indent
;
5320 /* Indent the line the number of spaces given by print_indent. */
5323 print_spaces (FILE *outfile
)
5325 fprintf (outfile
, "%*s", print_indent
, "");
5328 /* Print a type signature in hex. */
5331 print_signature (FILE *outfile
, char *sig
)
5335 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
5336 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
5339 /* Print the information associated with a given DIE, and its children.
5340 This routine is a debugging aid only. */
5343 print_die (dw_die_ref die
, FILE *outfile
)
5349 print_spaces (outfile
);
5350 fprintf (outfile
, "DIE %4ld: %s (%p)\n",
5351 die
->die_offset
, dwarf_tag_name (die
->die_tag
),
5353 print_spaces (outfile
);
5354 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
5355 fprintf (outfile
, " offset: %ld", die
->die_offset
);
5356 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
5358 if (die
->comdat_type_p
)
5360 print_spaces (outfile
);
5361 fprintf (outfile
, " signature: ");
5362 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
5363 fprintf (outfile
, "\n");
5366 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5368 print_spaces (outfile
);
5369 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
5371 switch (AT_class (a
))
5373 case dw_val_class_addr
:
5374 fprintf (outfile
, "address");
5376 case dw_val_class_offset
:
5377 fprintf (outfile
, "offset");
5379 case dw_val_class_loc
:
5380 fprintf (outfile
, "location descriptor");
5382 case dw_val_class_loc_list
:
5383 fprintf (outfile
, "location list -> label:%s",
5384 AT_loc_list (a
)->ll_symbol
);
5386 case dw_val_class_range_list
:
5387 fprintf (outfile
, "range list");
5389 case dw_val_class_const
:
5390 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
5392 case dw_val_class_unsigned_const
:
5393 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
5395 case dw_val_class_const_double
:
5396 fprintf (outfile
, "constant ("HOST_WIDE_INT_PRINT_DEC
","\
5397 HOST_WIDE_INT_PRINT_UNSIGNED
")",
5398 a
->dw_attr_val
.v
.val_double
.high
,
5399 a
->dw_attr_val
.v
.val_double
.low
);
5401 case dw_val_class_wide_int
:
5403 int i
= a
->dw_attr_val
.v
.val_wide
->get_len ();
5404 fprintf (outfile
, "constant (");
5406 if (a
->dw_attr_val
.v
.val_wide
->elt (i
- 1) == 0)
5407 fprintf (outfile
, "0x");
5408 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
5409 a
->dw_attr_val
.v
.val_wide
->elt (--i
));
5411 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
5412 a
->dw_attr_val
.v
.val_wide
->elt (i
));
5413 fprintf (outfile
, ")");
5416 case dw_val_class_vec
:
5417 fprintf (outfile
, "floating-point or vector constant");
5419 case dw_val_class_flag
:
5420 fprintf (outfile
, "%u", AT_flag (a
));
5422 case dw_val_class_die_ref
:
5423 if (AT_ref (a
) != NULL
)
5425 if (AT_ref (a
)->comdat_type_p
)
5427 fprintf (outfile
, "die -> signature: ");
5428 print_signature (outfile
,
5429 AT_ref (a
)->die_id
.die_type_node
->signature
);
5431 else if (AT_ref (a
)->die_id
.die_symbol
)
5432 fprintf (outfile
, "die -> label: %s",
5433 AT_ref (a
)->die_id
.die_symbol
);
5435 fprintf (outfile
, "die -> %ld", AT_ref (a
)->die_offset
);
5436 fprintf (outfile
, " (%p)", (void *) AT_ref (a
));
5439 fprintf (outfile
, "die -> <null>");
5441 case dw_val_class_vms_delta
:
5442 fprintf (outfile
, "delta: @slotcount(%s-%s)",
5443 AT_vms_delta2 (a
), AT_vms_delta1 (a
));
5445 case dw_val_class_lbl_id
:
5446 case dw_val_class_lineptr
:
5447 case dw_val_class_macptr
:
5448 case dw_val_class_high_pc
:
5449 fprintf (outfile
, "label: %s", AT_lbl (a
));
5451 case dw_val_class_str
:
5452 if (AT_string (a
) != NULL
)
5453 fprintf (outfile
, "\"%s\"", AT_string (a
));
5455 fprintf (outfile
, "<null>");
5457 case dw_val_class_file
:
5458 fprintf (outfile
, "\"%s\" (%d)", AT_file (a
)->filename
,
5459 AT_file (a
)->emitted_number
);
5461 case dw_val_class_data8
:
5465 for (i
= 0; i
< 8; i
++)
5466 fprintf (outfile
, "%02x", a
->dw_attr_val
.v
.val_data8
[i
]);
5473 fprintf (outfile
, "\n");
5476 if (die
->die_child
!= NULL
)
5479 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
5482 if (print_indent
== 0)
5483 fprintf (outfile
, "\n");
5486 /* Print the information collected for a given DIE. */
5489 debug_dwarf_die (dw_die_ref die
)
5491 print_die (die
, stderr
);
5495 debug (die_struct
&ref
)
5497 print_die (&ref
, stderr
);
5501 debug (die_struct
*ptr
)
5506 fprintf (stderr
, "<nil>\n");
5510 /* Print all DWARF information collected for the compilation unit.
5511 This routine is a debugging aid only. */
5517 print_die (comp_unit_die (), stderr
);
5520 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5521 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5522 DIE that marks the start of the DIEs for this include file. */
5525 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
5527 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
5528 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
5530 new_unit
->die_sib
= old_unit
;
5534 /* Close an include-file CU and reopen the enclosing one. */
5537 pop_compile_unit (dw_die_ref old_unit
)
5539 dw_die_ref new_unit
= old_unit
->die_sib
;
5541 old_unit
->die_sib
= NULL
;
5545 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5546 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5547 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5549 /* Calculate the checksum of a location expression. */
5552 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5555 inchash::hash hstate
;
5558 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
5560 hash_loc_operands (loc
, hstate
);
5561 hash
= hstate
.end();
5565 /* Calculate the checksum of an attribute. */
5568 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
5570 dw_loc_descr_ref loc
;
5573 CHECKSUM (at
->dw_attr
);
5575 /* We don't care that this was compiled with a different compiler
5576 snapshot; if the output is the same, that's what matters. */
5577 if (at
->dw_attr
== DW_AT_producer
)
5580 switch (AT_class (at
))
5582 case dw_val_class_const
:
5583 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
5585 case dw_val_class_unsigned_const
:
5586 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
5588 case dw_val_class_const_double
:
5589 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
5591 case dw_val_class_wide_int
:
5592 CHECKSUM (*at
->dw_attr_val
.v
.val_wide
);
5594 case dw_val_class_vec
:
5595 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
5596 (at
->dw_attr_val
.v
.val_vec
.length
5597 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
5599 case dw_val_class_flag
:
5600 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
5602 case dw_val_class_str
:
5603 CHECKSUM_STRING (AT_string (at
));
5606 case dw_val_class_addr
:
5608 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5609 CHECKSUM_STRING (XSTR (r
, 0));
5612 case dw_val_class_offset
:
5613 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
5616 case dw_val_class_loc
:
5617 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5618 loc_checksum (loc
, ctx
);
5621 case dw_val_class_die_ref
:
5622 die_checksum (AT_ref (at
), ctx
, mark
);
5625 case dw_val_class_fde_ref
:
5626 case dw_val_class_vms_delta
:
5627 case dw_val_class_lbl_id
:
5628 case dw_val_class_lineptr
:
5629 case dw_val_class_macptr
:
5630 case dw_val_class_high_pc
:
5633 case dw_val_class_file
:
5634 CHECKSUM_STRING (AT_file (at
)->filename
);
5637 case dw_val_class_data8
:
5638 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
5646 /* Calculate the checksum of a DIE. */
5649 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
5655 /* To avoid infinite recursion. */
5658 CHECKSUM (die
->die_mark
);
5661 die
->die_mark
= ++(*mark
);
5663 CHECKSUM (die
->die_tag
);
5665 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5666 attr_checksum (a
, ctx
, mark
);
5668 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
5672 #undef CHECKSUM_BLOCK
5673 #undef CHECKSUM_STRING
5675 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
5676 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5677 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5678 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
5679 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
5680 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
5681 #define CHECKSUM_ATTR(FOO) \
5682 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
5684 /* Calculate the checksum of a number in signed LEB128 format. */
5687 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
5694 byte
= (value
& 0x7f);
5696 more
= !((value
== 0 && (byte
& 0x40) == 0)
5697 || (value
== -1 && (byte
& 0x40) != 0));
5706 /* Calculate the checksum of a number in unsigned LEB128 format. */
5709 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
5713 unsigned char byte
= (value
& 0x7f);
5716 /* More bytes to follow. */
5724 /* Checksum the context of the DIE. This adds the names of any
5725 surrounding namespaces or structures to the checksum. */
5728 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
5732 int tag
= die
->die_tag
;
5734 if (tag
!= DW_TAG_namespace
5735 && tag
!= DW_TAG_structure_type
5736 && tag
!= DW_TAG_class_type
)
5739 name
= get_AT_string (die
, DW_AT_name
);
5741 spec
= get_AT_ref (die
, DW_AT_specification
);
5745 if (die
->die_parent
!= NULL
)
5746 checksum_die_context (die
->die_parent
, ctx
);
5748 CHECKSUM_ULEB128 ('C');
5749 CHECKSUM_ULEB128 (tag
);
5751 CHECKSUM_STRING (name
);
5754 /* Calculate the checksum of a location expression. */
5757 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5759 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
5760 were emitted as a DW_FORM_sdata instead of a location expression. */
5761 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
5763 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5764 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
5768 /* Otherwise, just checksum the raw location expression. */
5771 inchash::hash hstate
;
5774 CHECKSUM_ULEB128 (loc
->dtprel
);
5775 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
5776 hash_loc_operands (loc
, hstate
);
5777 hash
= hstate
.end ();
5779 loc
= loc
->dw_loc_next
;
5783 /* Calculate the checksum of an attribute. */
5786 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_ref at
,
5787 struct md5_ctx
*ctx
, int *mark
)
5789 dw_loc_descr_ref loc
;
5792 if (AT_class (at
) == dw_val_class_die_ref
)
5794 dw_die_ref target_die
= AT_ref (at
);
5796 /* For pointer and reference types, we checksum only the (qualified)
5797 name of the target type (if there is a name). For friend entries,
5798 we checksum only the (qualified) name of the target type or function.
5799 This allows the checksum to remain the same whether the target type
5800 is complete or not. */
5801 if ((at
->dw_attr
== DW_AT_type
5802 && (tag
== DW_TAG_pointer_type
5803 || tag
== DW_TAG_reference_type
5804 || tag
== DW_TAG_rvalue_reference_type
5805 || tag
== DW_TAG_ptr_to_member_type
))
5806 || (at
->dw_attr
== DW_AT_friend
5807 && tag
== DW_TAG_friend
))
5809 dw_attr_ref name_attr
= get_AT (target_die
, DW_AT_name
);
5811 if (name_attr
!= NULL
)
5813 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
5817 CHECKSUM_ULEB128 ('N');
5818 CHECKSUM_ULEB128 (at
->dw_attr
);
5819 if (decl
->die_parent
!= NULL
)
5820 checksum_die_context (decl
->die_parent
, ctx
);
5821 CHECKSUM_ULEB128 ('E');
5822 CHECKSUM_STRING (AT_string (name_attr
));
5827 /* For all other references to another DIE, we check to see if the
5828 target DIE has already been visited. If it has, we emit a
5829 backward reference; if not, we descend recursively. */
5830 if (target_die
->die_mark
> 0)
5832 CHECKSUM_ULEB128 ('R');
5833 CHECKSUM_ULEB128 (at
->dw_attr
);
5834 CHECKSUM_ULEB128 (target_die
->die_mark
);
5838 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
5842 target_die
->die_mark
= ++(*mark
);
5843 CHECKSUM_ULEB128 ('T');
5844 CHECKSUM_ULEB128 (at
->dw_attr
);
5845 if (decl
->die_parent
!= NULL
)
5846 checksum_die_context (decl
->die_parent
, ctx
);
5847 die_checksum_ordered (target_die
, ctx
, mark
);
5852 CHECKSUM_ULEB128 ('A');
5853 CHECKSUM_ULEB128 (at
->dw_attr
);
5855 switch (AT_class (at
))
5857 case dw_val_class_const
:
5858 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5859 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
5862 case dw_val_class_unsigned_const
:
5863 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5864 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
5867 case dw_val_class_const_double
:
5868 CHECKSUM_ULEB128 (DW_FORM_block
);
5869 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
5870 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
5873 case dw_val_class_wide_int
:
5874 CHECKSUM_ULEB128 (DW_FORM_block
);
5875 CHECKSUM_ULEB128 (sizeof (*at
->dw_attr_val
.v
.val_wide
));
5876 CHECKSUM (*at
->dw_attr_val
.v
.val_wide
);
5879 case dw_val_class_vec
:
5880 CHECKSUM_ULEB128 (DW_FORM_block
);
5881 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
5882 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
5883 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
5884 (at
->dw_attr_val
.v
.val_vec
.length
5885 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
5888 case dw_val_class_flag
:
5889 CHECKSUM_ULEB128 (DW_FORM_flag
);
5890 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
5893 case dw_val_class_str
:
5894 CHECKSUM_ULEB128 (DW_FORM_string
);
5895 CHECKSUM_STRING (AT_string (at
));
5898 case dw_val_class_addr
:
5900 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5901 CHECKSUM_ULEB128 (DW_FORM_string
);
5902 CHECKSUM_STRING (XSTR (r
, 0));
5905 case dw_val_class_offset
:
5906 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5907 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
5910 case dw_val_class_loc
:
5911 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5912 loc_checksum_ordered (loc
, ctx
);
5915 case dw_val_class_fde_ref
:
5916 case dw_val_class_lbl_id
:
5917 case dw_val_class_lineptr
:
5918 case dw_val_class_macptr
:
5919 case dw_val_class_high_pc
:
5922 case dw_val_class_file
:
5923 CHECKSUM_ULEB128 (DW_FORM_string
);
5924 CHECKSUM_STRING (AT_file (at
)->filename
);
5927 case dw_val_class_data8
:
5928 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
5936 struct checksum_attributes
5938 dw_attr_ref at_name
;
5939 dw_attr_ref at_type
;
5940 dw_attr_ref at_friend
;
5941 dw_attr_ref at_accessibility
;
5942 dw_attr_ref at_address_class
;
5943 dw_attr_ref at_allocated
;
5944 dw_attr_ref at_artificial
;
5945 dw_attr_ref at_associated
;
5946 dw_attr_ref at_binary_scale
;
5947 dw_attr_ref at_bit_offset
;
5948 dw_attr_ref at_bit_size
;
5949 dw_attr_ref at_bit_stride
;
5950 dw_attr_ref at_byte_size
;
5951 dw_attr_ref at_byte_stride
;
5952 dw_attr_ref at_const_value
;
5953 dw_attr_ref at_containing_type
;
5954 dw_attr_ref at_count
;
5955 dw_attr_ref at_data_location
;
5956 dw_attr_ref at_data_member_location
;
5957 dw_attr_ref at_decimal_scale
;
5958 dw_attr_ref at_decimal_sign
;
5959 dw_attr_ref at_default_value
;
5960 dw_attr_ref at_digit_count
;
5961 dw_attr_ref at_discr
;
5962 dw_attr_ref at_discr_list
;
5963 dw_attr_ref at_discr_value
;
5964 dw_attr_ref at_encoding
;
5965 dw_attr_ref at_endianity
;
5966 dw_attr_ref at_explicit
;
5967 dw_attr_ref at_is_optional
;
5968 dw_attr_ref at_location
;
5969 dw_attr_ref at_lower_bound
;
5970 dw_attr_ref at_mutable
;
5971 dw_attr_ref at_ordering
;
5972 dw_attr_ref at_picture_string
;
5973 dw_attr_ref at_prototyped
;
5974 dw_attr_ref at_small
;
5975 dw_attr_ref at_segment
;
5976 dw_attr_ref at_string_length
;
5977 dw_attr_ref at_threads_scaled
;
5978 dw_attr_ref at_upper_bound
;
5979 dw_attr_ref at_use_location
;
5980 dw_attr_ref at_use_UTF8
;
5981 dw_attr_ref at_variable_parameter
;
5982 dw_attr_ref at_virtuality
;
5983 dw_attr_ref at_visibility
;
5984 dw_attr_ref at_vtable_elem_location
;
5987 /* Collect the attributes that we will want to use for the checksum. */
5990 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
5995 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6006 attrs
->at_friend
= a
;
6008 case DW_AT_accessibility
:
6009 attrs
->at_accessibility
= a
;
6011 case DW_AT_address_class
:
6012 attrs
->at_address_class
= a
;
6014 case DW_AT_allocated
:
6015 attrs
->at_allocated
= a
;
6017 case DW_AT_artificial
:
6018 attrs
->at_artificial
= a
;
6020 case DW_AT_associated
:
6021 attrs
->at_associated
= a
;
6023 case DW_AT_binary_scale
:
6024 attrs
->at_binary_scale
= a
;
6026 case DW_AT_bit_offset
:
6027 attrs
->at_bit_offset
= a
;
6029 case DW_AT_bit_size
:
6030 attrs
->at_bit_size
= a
;
6032 case DW_AT_bit_stride
:
6033 attrs
->at_bit_stride
= a
;
6035 case DW_AT_byte_size
:
6036 attrs
->at_byte_size
= a
;
6038 case DW_AT_byte_stride
:
6039 attrs
->at_byte_stride
= a
;
6041 case DW_AT_const_value
:
6042 attrs
->at_const_value
= a
;
6044 case DW_AT_containing_type
:
6045 attrs
->at_containing_type
= a
;
6048 attrs
->at_count
= a
;
6050 case DW_AT_data_location
:
6051 attrs
->at_data_location
= a
;
6053 case DW_AT_data_member_location
:
6054 attrs
->at_data_member_location
= a
;
6056 case DW_AT_decimal_scale
:
6057 attrs
->at_decimal_scale
= a
;
6059 case DW_AT_decimal_sign
:
6060 attrs
->at_decimal_sign
= a
;
6062 case DW_AT_default_value
:
6063 attrs
->at_default_value
= a
;
6065 case DW_AT_digit_count
:
6066 attrs
->at_digit_count
= a
;
6069 attrs
->at_discr
= a
;
6071 case DW_AT_discr_list
:
6072 attrs
->at_discr_list
= a
;
6074 case DW_AT_discr_value
:
6075 attrs
->at_discr_value
= a
;
6077 case DW_AT_encoding
:
6078 attrs
->at_encoding
= a
;
6080 case DW_AT_endianity
:
6081 attrs
->at_endianity
= a
;
6083 case DW_AT_explicit
:
6084 attrs
->at_explicit
= a
;
6086 case DW_AT_is_optional
:
6087 attrs
->at_is_optional
= a
;
6089 case DW_AT_location
:
6090 attrs
->at_location
= a
;
6092 case DW_AT_lower_bound
:
6093 attrs
->at_lower_bound
= a
;
6096 attrs
->at_mutable
= a
;
6098 case DW_AT_ordering
:
6099 attrs
->at_ordering
= a
;
6101 case DW_AT_picture_string
:
6102 attrs
->at_picture_string
= a
;
6104 case DW_AT_prototyped
:
6105 attrs
->at_prototyped
= a
;
6108 attrs
->at_small
= a
;
6111 attrs
->at_segment
= a
;
6113 case DW_AT_string_length
:
6114 attrs
->at_string_length
= a
;
6116 case DW_AT_threads_scaled
:
6117 attrs
->at_threads_scaled
= a
;
6119 case DW_AT_upper_bound
:
6120 attrs
->at_upper_bound
= a
;
6122 case DW_AT_use_location
:
6123 attrs
->at_use_location
= a
;
6125 case DW_AT_use_UTF8
:
6126 attrs
->at_use_UTF8
= a
;
6128 case DW_AT_variable_parameter
:
6129 attrs
->at_variable_parameter
= a
;
6131 case DW_AT_virtuality
:
6132 attrs
->at_virtuality
= a
;
6134 case DW_AT_visibility
:
6135 attrs
->at_visibility
= a
;
6137 case DW_AT_vtable_elem_location
:
6138 attrs
->at_vtable_elem_location
= a
;
6146 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6149 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6153 struct checksum_attributes attrs
;
6155 CHECKSUM_ULEB128 ('D');
6156 CHECKSUM_ULEB128 (die
->die_tag
);
6158 memset (&attrs
, 0, sizeof (attrs
));
6160 decl
= get_AT_ref (die
, DW_AT_specification
);
6162 collect_checksum_attributes (&attrs
, decl
);
6163 collect_checksum_attributes (&attrs
, die
);
6165 CHECKSUM_ATTR (attrs
.at_name
);
6166 CHECKSUM_ATTR (attrs
.at_accessibility
);
6167 CHECKSUM_ATTR (attrs
.at_address_class
);
6168 CHECKSUM_ATTR (attrs
.at_allocated
);
6169 CHECKSUM_ATTR (attrs
.at_artificial
);
6170 CHECKSUM_ATTR (attrs
.at_associated
);
6171 CHECKSUM_ATTR (attrs
.at_binary_scale
);
6172 CHECKSUM_ATTR (attrs
.at_bit_offset
);
6173 CHECKSUM_ATTR (attrs
.at_bit_size
);
6174 CHECKSUM_ATTR (attrs
.at_bit_stride
);
6175 CHECKSUM_ATTR (attrs
.at_byte_size
);
6176 CHECKSUM_ATTR (attrs
.at_byte_stride
);
6177 CHECKSUM_ATTR (attrs
.at_const_value
);
6178 CHECKSUM_ATTR (attrs
.at_containing_type
);
6179 CHECKSUM_ATTR (attrs
.at_count
);
6180 CHECKSUM_ATTR (attrs
.at_data_location
);
6181 CHECKSUM_ATTR (attrs
.at_data_member_location
);
6182 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
6183 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
6184 CHECKSUM_ATTR (attrs
.at_default_value
);
6185 CHECKSUM_ATTR (attrs
.at_digit_count
);
6186 CHECKSUM_ATTR (attrs
.at_discr
);
6187 CHECKSUM_ATTR (attrs
.at_discr_list
);
6188 CHECKSUM_ATTR (attrs
.at_discr_value
);
6189 CHECKSUM_ATTR (attrs
.at_encoding
);
6190 CHECKSUM_ATTR (attrs
.at_endianity
);
6191 CHECKSUM_ATTR (attrs
.at_explicit
);
6192 CHECKSUM_ATTR (attrs
.at_is_optional
);
6193 CHECKSUM_ATTR (attrs
.at_location
);
6194 CHECKSUM_ATTR (attrs
.at_lower_bound
);
6195 CHECKSUM_ATTR (attrs
.at_mutable
);
6196 CHECKSUM_ATTR (attrs
.at_ordering
);
6197 CHECKSUM_ATTR (attrs
.at_picture_string
);
6198 CHECKSUM_ATTR (attrs
.at_prototyped
);
6199 CHECKSUM_ATTR (attrs
.at_small
);
6200 CHECKSUM_ATTR (attrs
.at_segment
);
6201 CHECKSUM_ATTR (attrs
.at_string_length
);
6202 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
6203 CHECKSUM_ATTR (attrs
.at_upper_bound
);
6204 CHECKSUM_ATTR (attrs
.at_use_location
);
6205 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
6206 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
6207 CHECKSUM_ATTR (attrs
.at_virtuality
);
6208 CHECKSUM_ATTR (attrs
.at_visibility
);
6209 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
6210 CHECKSUM_ATTR (attrs
.at_type
);
6211 CHECKSUM_ATTR (attrs
.at_friend
);
6213 /* Checksum the child DIEs. */
6216 dw_attr_ref name_attr
;
6219 name_attr
= get_AT (c
, DW_AT_name
);
6220 if (is_template_instantiation (c
))
6222 /* Ignore instantiations of member type and function templates. */
6224 else if (name_attr
!= NULL
6225 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
6227 /* Use a shallow checksum for named nested types and member
6229 CHECKSUM_ULEB128 ('S');
6230 CHECKSUM_ULEB128 (c
->die_tag
);
6231 CHECKSUM_STRING (AT_string (name_attr
));
6235 /* Use a deep checksum for other children. */
6236 /* Mark this DIE so it gets processed when unmarking. */
6237 if (c
->die_mark
== 0)
6239 die_checksum_ordered (c
, ctx
, mark
);
6241 } while (c
!= die
->die_child
);
6243 CHECKSUM_ULEB128 (0);
6246 /* Add a type name and tag to a hash. */
6248 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
6250 CHECKSUM_ULEB128 (tag
);
6251 CHECKSUM_STRING (name
);
6255 #undef CHECKSUM_STRING
6256 #undef CHECKSUM_ATTR
6257 #undef CHECKSUM_LEB128
6258 #undef CHECKSUM_ULEB128
6260 /* Generate the type signature for DIE. This is computed by generating an
6261 MD5 checksum over the DIE's tag, its relevant attributes, and its
6262 children. Attributes that are references to other DIEs are processed
6263 by recursion, using the MARK field to prevent infinite recursion.
6264 If the DIE is nested inside a namespace or another type, we also
6265 need to include that context in the signature. The lower 64 bits
6266 of the resulting MD5 checksum comprise the signature. */
6269 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
6273 unsigned char checksum
[16];
6278 name
= get_AT_string (die
, DW_AT_name
);
6279 decl
= get_AT_ref (die
, DW_AT_specification
);
6280 parent
= get_die_parent (die
);
6282 /* First, compute a signature for just the type name (and its surrounding
6283 context, if any. This is stored in the type unit DIE for link-time
6284 ODR (one-definition rule) checking. */
6286 if (is_cxx () && name
!= NULL
)
6288 md5_init_ctx (&ctx
);
6290 /* Checksum the names of surrounding namespaces and structures. */
6292 checksum_die_context (parent
, &ctx
);
6294 /* Checksum the current DIE. */
6295 die_odr_checksum (die
->die_tag
, name
, &ctx
);
6296 md5_finish_ctx (&ctx
, checksum
);
6298 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
6301 /* Next, compute the complete type signature. */
6303 md5_init_ctx (&ctx
);
6305 die
->die_mark
= mark
;
6307 /* Checksum the names of surrounding namespaces and structures. */
6309 checksum_die_context (parent
, &ctx
);
6311 /* Checksum the DIE and its children. */
6312 die_checksum_ordered (die
, &ctx
, &mark
);
6313 unmark_all_dies (die
);
6314 md5_finish_ctx (&ctx
, checksum
);
6316 /* Store the signature in the type node and link the type DIE and the
6317 type node together. */
6318 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
6319 DWARF_TYPE_SIGNATURE_SIZE
);
6320 die
->comdat_type_p
= true;
6321 die
->die_id
.die_type_node
= type_node
;
6322 type_node
->type_die
= die
;
6324 /* If the DIE is a specification, link its declaration to the type node
6328 decl
->comdat_type_p
= true;
6329 decl
->die_id
.die_type_node
= type_node
;
6333 /* Do the location expressions look same? */
6335 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
6337 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
6338 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
6339 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
6342 /* Do the values look the same? */
6344 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
6346 dw_loc_descr_ref loc1
, loc2
;
6349 if (v1
->val_class
!= v2
->val_class
)
6352 switch (v1
->val_class
)
6354 case dw_val_class_const
:
6355 return v1
->v
.val_int
== v2
->v
.val_int
;
6356 case dw_val_class_unsigned_const
:
6357 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
6358 case dw_val_class_const_double
:
6359 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
6360 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
6361 case dw_val_class_wide_int
:
6362 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
6363 case dw_val_class_vec
:
6364 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
6365 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
6367 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
6368 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
6371 case dw_val_class_flag
:
6372 return v1
->v
.val_flag
== v2
->v
.val_flag
;
6373 case dw_val_class_str
:
6374 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
6376 case dw_val_class_addr
:
6377 r1
= v1
->v
.val_addr
;
6378 r2
= v2
->v
.val_addr
;
6379 if (GET_CODE (r1
) != GET_CODE (r2
))
6381 return !rtx_equal_p (r1
, r2
);
6383 case dw_val_class_offset
:
6384 return v1
->v
.val_offset
== v2
->v
.val_offset
;
6386 case dw_val_class_loc
:
6387 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
6389 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
6390 if (!same_loc_p (loc1
, loc2
, mark
))
6392 return !loc1
&& !loc2
;
6394 case dw_val_class_die_ref
:
6395 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
6397 case dw_val_class_fde_ref
:
6398 case dw_val_class_vms_delta
:
6399 case dw_val_class_lbl_id
:
6400 case dw_val_class_lineptr
:
6401 case dw_val_class_macptr
:
6402 case dw_val_class_high_pc
:
6405 case dw_val_class_file
:
6406 return v1
->v
.val_file
== v2
->v
.val_file
;
6408 case dw_val_class_data8
:
6409 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
6416 /* Do the attributes look the same? */
6419 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
6421 if (at1
->dw_attr
!= at2
->dw_attr
)
6424 /* We don't care that this was compiled with a different compiler
6425 snapshot; if the output is the same, that's what matters. */
6426 if (at1
->dw_attr
== DW_AT_producer
)
6429 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
6432 /* Do the dies look the same? */
6435 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
6441 /* To avoid infinite recursion. */
6443 return die1
->die_mark
== die2
->die_mark
;
6444 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
6446 if (die1
->die_tag
!= die2
->die_tag
)
6449 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
6452 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
6453 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
6456 c1
= die1
->die_child
;
6457 c2
= die2
->die_child
;
6466 if (!same_die_p (c1
, c2
, mark
))
6470 if (c1
== die1
->die_child
)
6472 if (c2
== die2
->die_child
)
6482 /* Do the dies look the same? Wrapper around same_die_p. */
6485 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
6488 int ret
= same_die_p (die1
, die2
, &mark
);
6490 unmark_all_dies (die1
);
6491 unmark_all_dies (die2
);
6496 /* The prefix to attach to symbols on DIEs in the current comdat debug
6498 static const char *comdat_symbol_id
;
6500 /* The index of the current symbol within the current comdat CU. */
6501 static unsigned int comdat_symbol_number
;
6503 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6504 children, and set comdat_symbol_id accordingly. */
6507 compute_section_prefix (dw_die_ref unit_die
)
6509 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
6510 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
6511 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
6514 unsigned char checksum
[16];
6517 /* Compute the checksum of the DIE, then append part of it as hex digits to
6518 the name filename of the unit. */
6520 md5_init_ctx (&ctx
);
6522 die_checksum (unit_die
, &ctx
, &mark
);
6523 unmark_all_dies (unit_die
);
6524 md5_finish_ctx (&ctx
, checksum
);
6526 sprintf (name
, "%s.", base
);
6527 clean_symbol_name (name
);
6529 p
= name
+ strlen (name
);
6530 for (i
= 0; i
< 4; i
++)
6532 sprintf (p
, "%.2x", checksum
[i
]);
6536 comdat_symbol_id
= unit_die
->die_id
.die_symbol
= xstrdup (name
);
6537 comdat_symbol_number
= 0;
6540 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6543 is_type_die (dw_die_ref die
)
6545 switch (die
->die_tag
)
6547 case DW_TAG_array_type
:
6548 case DW_TAG_class_type
:
6549 case DW_TAG_interface_type
:
6550 case DW_TAG_enumeration_type
:
6551 case DW_TAG_pointer_type
:
6552 case DW_TAG_reference_type
:
6553 case DW_TAG_rvalue_reference_type
:
6554 case DW_TAG_string_type
:
6555 case DW_TAG_structure_type
:
6556 case DW_TAG_subroutine_type
:
6557 case DW_TAG_union_type
:
6558 case DW_TAG_ptr_to_member_type
:
6559 case DW_TAG_set_type
:
6560 case DW_TAG_subrange_type
:
6561 case DW_TAG_base_type
:
6562 case DW_TAG_const_type
:
6563 case DW_TAG_file_type
:
6564 case DW_TAG_packed_type
:
6565 case DW_TAG_volatile_type
:
6566 case DW_TAG_typedef
:
6573 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6574 Basically, we want to choose the bits that are likely to be shared between
6575 compilations (types) and leave out the bits that are specific to individual
6576 compilations (functions). */
6579 is_comdat_die (dw_die_ref c
)
6581 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6582 we do for stabs. The advantage is a greater likelihood of sharing between
6583 objects that don't include headers in the same order (and therefore would
6584 put the base types in a different comdat). jason 8/28/00 */
6586 if (c
->die_tag
== DW_TAG_base_type
)
6589 if (c
->die_tag
== DW_TAG_pointer_type
6590 || c
->die_tag
== DW_TAG_reference_type
6591 || c
->die_tag
== DW_TAG_rvalue_reference_type
6592 || c
->die_tag
== DW_TAG_const_type
6593 || c
->die_tag
== DW_TAG_volatile_type
)
6595 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
6597 return t
? is_comdat_die (t
) : 0;
6600 return is_type_die (c
);
6603 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6604 compilation unit. */
6607 is_symbol_die (dw_die_ref c
)
6609 return (is_type_die (c
)
6610 || is_declaration_die (c
)
6611 || c
->die_tag
== DW_TAG_namespace
6612 || c
->die_tag
== DW_TAG_module
);
6615 /* Returns true iff C is a compile-unit DIE. */
6618 is_cu_die (dw_die_ref c
)
6620 return c
&& c
->die_tag
== DW_TAG_compile_unit
;
6623 /* Returns true iff C is a unit DIE of some sort. */
6626 is_unit_die (dw_die_ref c
)
6628 return c
&& (c
->die_tag
== DW_TAG_compile_unit
6629 || c
->die_tag
== DW_TAG_partial_unit
6630 || c
->die_tag
== DW_TAG_type_unit
);
6633 /* Returns true iff C is a namespace DIE. */
6636 is_namespace_die (dw_die_ref c
)
6638 return c
&& c
->die_tag
== DW_TAG_namespace
;
6641 /* Returns true iff C is a class or structure DIE. */
6644 is_class_die (dw_die_ref c
)
6646 return c
&& (c
->die_tag
== DW_TAG_class_type
6647 || c
->die_tag
== DW_TAG_structure_type
);
6650 /* Return non-zero if this DIE is a template parameter. */
6653 is_template_parameter (dw_die_ref die
)
6655 switch (die
->die_tag
)
6657 case DW_TAG_template_type_param
:
6658 case DW_TAG_template_value_param
:
6659 case DW_TAG_GNU_template_template_param
:
6660 case DW_TAG_GNU_template_parameter_pack
:
6667 /* Return non-zero if this DIE represents a template instantiation. */
6670 is_template_instantiation (dw_die_ref die
)
6674 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
6676 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
6681 gen_internal_sym (const char *prefix
)
6685 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
6686 return xstrdup (buf
);
6689 /* Assign symbols to all worthy DIEs under DIE. */
6692 assign_symbol_names (dw_die_ref die
)
6696 if (is_symbol_die (die
) && !die
->comdat_type_p
)
6698 if (comdat_symbol_id
)
6700 char *p
= XALLOCAVEC (char, strlen (comdat_symbol_id
) + 64);
6702 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
6703 comdat_symbol_id
, comdat_symbol_number
++);
6704 die
->die_id
.die_symbol
= xstrdup (p
);
6707 die
->die_id
.die_symbol
= gen_internal_sym ("LDIE");
6710 FOR_EACH_CHILD (die
, c
, assign_symbol_names (c
));
6713 struct cu_hash_table_entry
6716 unsigned min_comdat_num
, max_comdat_num
;
6717 struct cu_hash_table_entry
*next
;
6720 /* Helpers to manipulate hash table of CUs. */
6722 struct cu_hash_table_entry_hasher
6724 typedef cu_hash_table_entry value_type
;
6725 typedef die_struct compare_type
;
6726 static inline hashval_t
hash (const value_type
*);
6727 static inline bool equal (const value_type
*, const compare_type
*);
6728 static inline void remove (value_type
*);
6732 cu_hash_table_entry_hasher::hash (const value_type
*entry
)
6734 return htab_hash_string (entry
->cu
->die_id
.die_symbol
);
6738 cu_hash_table_entry_hasher::equal (const value_type
*entry1
,
6739 const compare_type
*entry2
)
6741 return !strcmp (entry1
->cu
->die_id
.die_symbol
, entry2
->die_id
.die_symbol
);
6745 cu_hash_table_entry_hasher::remove (value_type
*entry
)
6747 struct cu_hash_table_entry
*next
;
6757 typedef hash_table
<cu_hash_table_entry_hasher
> cu_hash_type
;
6759 /* Check whether we have already seen this CU and set up SYM_NUM
6762 check_duplicate_cu (dw_die_ref cu
, cu_hash_type
*htable
, unsigned int *sym_num
)
6764 struct cu_hash_table_entry dummy
;
6765 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
6767 dummy
.max_comdat_num
= 0;
6769 slot
= htable
->find_slot_with_hash (cu
,
6770 htab_hash_string (cu
->die_id
.die_symbol
),
6774 for (; entry
; last
= entry
, entry
= entry
->next
)
6776 if (same_die_p_wrap (cu
, entry
->cu
))
6782 *sym_num
= entry
->min_comdat_num
;
6786 entry
= XCNEW (struct cu_hash_table_entry
);
6788 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
6789 entry
->next
= *slot
;
6795 /* Record SYM_NUM to record of CU in HTABLE. */
6797 record_comdat_symbol_number (dw_die_ref cu
, cu_hash_type
*htable
,
6798 unsigned int sym_num
)
6800 struct cu_hash_table_entry
**slot
, *entry
;
6802 slot
= htable
->find_slot_with_hash (cu
,
6803 htab_hash_string (cu
->die_id
.die_symbol
),
6807 entry
->max_comdat_num
= sym_num
;
6810 /* Traverse the DIE (which is always comp_unit_die), and set up
6811 additional compilation units for each of the include files we see
6812 bracketed by BINCL/EINCL. */
6815 break_out_includes (dw_die_ref die
)
6818 dw_die_ref unit
= NULL
;
6819 limbo_die_node
*node
, **pnode
;
6823 dw_die_ref prev
= c
;
6825 while (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
6826 || (unit
&& is_comdat_die (c
)))
6828 dw_die_ref next
= c
->die_sib
;
6830 /* This DIE is for a secondary CU; remove it from the main one. */
6831 remove_child_with_prev (c
, prev
);
6833 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
6834 unit
= push_new_compile_unit (unit
, c
);
6835 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
6836 unit
= pop_compile_unit (unit
);
6838 add_child_die (unit
, c
);
6840 if (c
== die
->die_child
)
6843 } while (c
!= die
->die_child
);
6846 /* We can only use this in debugging, since the frontend doesn't check
6847 to make sure that we leave every include file we enter. */
6851 assign_symbol_names (die
);
6852 cu_hash_type
cu_hash_table (10);
6853 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
6859 compute_section_prefix (node
->die
);
6860 is_dupl
= check_duplicate_cu (node
->die
, &cu_hash_table
,
6861 &comdat_symbol_number
);
6862 assign_symbol_names (node
->die
);
6864 *pnode
= node
->next
;
6867 pnode
= &node
->next
;
6868 record_comdat_symbol_number (node
->die
, &cu_hash_table
,
6869 comdat_symbol_number
);
6874 /* Return non-zero if this DIE is a declaration. */
6877 is_declaration_die (dw_die_ref die
)
6882 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6883 if (a
->dw_attr
== DW_AT_declaration
)
6889 /* Return non-zero if this DIE is nested inside a subprogram. */
6892 is_nested_in_subprogram (dw_die_ref die
)
6894 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
6898 return local_scope_p (decl
);
6901 /* Return non-zero if this DIE contains a defining declaration of a
6905 contains_subprogram_definition (dw_die_ref die
)
6909 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
6911 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
6915 /* Return non-zero if this is a type DIE that should be moved to a
6916 COMDAT .debug_types section. */
6919 should_move_die_to_comdat (dw_die_ref die
)
6921 switch (die
->die_tag
)
6923 case DW_TAG_class_type
:
6924 case DW_TAG_structure_type
:
6925 case DW_TAG_enumeration_type
:
6926 case DW_TAG_union_type
:
6927 /* Don't move declarations, inlined instances, types nested in a
6928 subprogram, or types that contain subprogram definitions. */
6929 if (is_declaration_die (die
)
6930 || get_AT (die
, DW_AT_abstract_origin
)
6931 || is_nested_in_subprogram (die
)
6932 || contains_subprogram_definition (die
))
6935 case DW_TAG_array_type
:
6936 case DW_TAG_interface_type
:
6937 case DW_TAG_pointer_type
:
6938 case DW_TAG_reference_type
:
6939 case DW_TAG_rvalue_reference_type
:
6940 case DW_TAG_string_type
:
6941 case DW_TAG_subroutine_type
:
6942 case DW_TAG_ptr_to_member_type
:
6943 case DW_TAG_set_type
:
6944 case DW_TAG_subrange_type
:
6945 case DW_TAG_base_type
:
6946 case DW_TAG_const_type
:
6947 case DW_TAG_file_type
:
6948 case DW_TAG_packed_type
:
6949 case DW_TAG_volatile_type
:
6950 case DW_TAG_typedef
:
6956 /* Make a clone of DIE. */
6959 clone_die (dw_die_ref die
)
6965 clone
= ggc_cleared_alloc
<die_node
> ();
6966 clone
->die_tag
= die
->die_tag
;
6968 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6969 add_dwarf_attr (clone
, a
);
6974 /* Make a clone of the tree rooted at DIE. */
6977 clone_tree (dw_die_ref die
)
6980 dw_die_ref clone
= clone_die (die
);
6982 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
6987 /* Make a clone of DIE as a declaration. */
6990 clone_as_declaration (dw_die_ref die
)
6997 /* If the DIE is already a declaration, just clone it. */
6998 if (is_declaration_die (die
))
6999 return clone_die (die
);
7001 /* If the DIE is a specification, just clone its declaration DIE. */
7002 decl
= get_AT_ref (die
, DW_AT_specification
);
7005 clone
= clone_die (decl
);
7006 if (die
->comdat_type_p
)
7007 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7011 clone
= ggc_cleared_alloc
<die_node
> ();
7012 clone
->die_tag
= die
->die_tag
;
7014 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7016 /* We don't want to copy over all attributes.
7017 For example we don't want DW_AT_byte_size because otherwise we will no
7018 longer have a declaration and GDB will treat it as a definition. */
7022 case DW_AT_abstract_origin
:
7023 case DW_AT_artificial
:
7024 case DW_AT_containing_type
:
7025 case DW_AT_external
:
7028 case DW_AT_virtuality
:
7029 case DW_AT_linkage_name
:
7030 case DW_AT_MIPS_linkage_name
:
7031 add_dwarf_attr (clone
, a
);
7033 case DW_AT_byte_size
:
7039 if (die
->comdat_type_p
)
7040 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7042 add_AT_flag (clone
, DW_AT_declaration
, 1);
7047 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7049 struct decl_table_entry
7055 /* Helpers to manipulate hash table of copied declarations. */
7057 /* Hashtable helpers. */
7059 struct decl_table_entry_hasher
: typed_free_remove
<decl_table_entry
>
7061 typedef decl_table_entry value_type
;
7062 typedef die_struct compare_type
;
7063 static inline hashval_t
hash (const value_type
*);
7064 static inline bool equal (const value_type
*, const compare_type
*);
7068 decl_table_entry_hasher::hash (const value_type
*entry
)
7070 return htab_hash_pointer (entry
->orig
);
7074 decl_table_entry_hasher::equal (const value_type
*entry1
,
7075 const compare_type
*entry2
)
7077 return entry1
->orig
== entry2
;
7080 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
7082 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7083 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7084 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7085 to check if the ancestor has already been copied into UNIT. */
7088 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
7089 decl_hash_type
*decl_table
)
7091 dw_die_ref parent
= die
->die_parent
;
7092 dw_die_ref new_parent
= unit
;
7094 decl_table_entry
**slot
= NULL
;
7095 struct decl_table_entry
*entry
= NULL
;
7099 /* Check if the entry has already been copied to UNIT. */
7100 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
7102 if (*slot
!= HTAB_EMPTY_ENTRY
)
7108 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7109 entry
= XCNEW (struct decl_table_entry
);
7117 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
7120 if (!is_unit_die (parent
))
7121 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
7124 copy
= clone_as_declaration (die
);
7125 add_child_die (new_parent
, copy
);
7129 /* Record the pointer to the copy. */
7135 /* Copy the declaration context to the new type unit DIE. This includes
7136 any surrounding namespace or type declarations. If the DIE has an
7137 AT_specification attribute, it also includes attributes and children
7138 attached to the specification, and returns a pointer to the original
7139 parent of the declaration DIE. Returns NULL otherwise. */
7142 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
7145 dw_die_ref new_decl
;
7146 dw_die_ref orig_parent
= NULL
;
7148 decl
= get_AT_ref (die
, DW_AT_specification
);
7157 /* The original DIE will be changed to a declaration, and must
7158 be moved to be a child of the original declaration DIE. */
7159 orig_parent
= decl
->die_parent
;
7161 /* Copy the type node pointer from the new DIE to the original
7162 declaration DIE so we can forward references later. */
7163 decl
->comdat_type_p
= true;
7164 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
7166 remove_AT (die
, DW_AT_specification
);
7168 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
7170 if (a
->dw_attr
!= DW_AT_name
7171 && a
->dw_attr
!= DW_AT_declaration
7172 && a
->dw_attr
!= DW_AT_external
)
7173 add_dwarf_attr (die
, a
);
7176 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
7179 if (decl
->die_parent
!= NULL
7180 && !is_unit_die (decl
->die_parent
))
7182 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
7183 if (new_decl
!= NULL
)
7185 remove_AT (new_decl
, DW_AT_signature
);
7186 add_AT_specification (die
, new_decl
);
7193 /* Generate the skeleton ancestor tree for the given NODE, then clone
7194 the DIE and add the clone into the tree. */
7197 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
7199 if (node
->new_die
!= NULL
)
7202 node
->new_die
= clone_as_declaration (node
->old_die
);
7204 if (node
->parent
!= NULL
)
7206 generate_skeleton_ancestor_tree (node
->parent
);
7207 add_child_die (node
->parent
->new_die
, node
->new_die
);
7211 /* Generate a skeleton tree of DIEs containing any declarations that are
7212 found in the original tree. We traverse the tree looking for declaration
7213 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7216 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
7218 skeleton_chain_node node
;
7221 dw_die_ref prev
= NULL
;
7222 dw_die_ref next
= NULL
;
7224 node
.parent
= parent
;
7226 first
= c
= parent
->old_die
->die_child
;
7230 if (prev
== NULL
|| prev
->die_sib
== c
)
7233 next
= (c
== first
? NULL
: c
->die_sib
);
7235 node
.new_die
= NULL
;
7236 if (is_declaration_die (c
))
7238 if (is_template_instantiation (c
))
7240 /* Instantiated templates do not need to be cloned into the
7241 type unit. Just move the DIE and its children back to
7242 the skeleton tree (in the main CU). */
7243 remove_child_with_prev (c
, prev
);
7244 add_child_die (parent
->new_die
, c
);
7249 /* Clone the existing DIE, move the original to the skeleton
7250 tree (which is in the main CU), and put the clone, with
7251 all the original's children, where the original came from
7252 (which is about to be moved to the type unit). */
7253 dw_die_ref clone
= clone_die (c
);
7254 move_all_children (c
, clone
);
7256 /* If the original has a DW_AT_object_pointer attribute,
7257 it would now point to a child DIE just moved to the
7258 cloned tree, so we need to remove that attribute from
7260 remove_AT (c
, DW_AT_object_pointer
);
7262 replace_child (c
, clone
, prev
);
7263 generate_skeleton_ancestor_tree (parent
);
7264 add_child_die (parent
->new_die
, c
);
7269 generate_skeleton_bottom_up (&node
);
7270 } while (next
!= NULL
);
7273 /* Wrapper function for generate_skeleton_bottom_up. */
7276 generate_skeleton (dw_die_ref die
)
7278 skeleton_chain_node node
;
7281 node
.new_die
= NULL
;
7284 /* If this type definition is nested inside another type,
7285 and is not an instantiation of a template, always leave
7286 at least a declaration in its place. */
7287 if (die
->die_parent
!= NULL
7288 && is_type_die (die
->die_parent
)
7289 && !is_template_instantiation (die
))
7290 node
.new_die
= clone_as_declaration (die
);
7292 generate_skeleton_bottom_up (&node
);
7293 return node
.new_die
;
7296 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7297 declaration. The original DIE is moved to a new compile unit so that
7298 existing references to it follow it to the new location. If any of the
7299 original DIE's descendants is a declaration, we need to replace the
7300 original DIE with a skeleton tree and move the declarations back into the
7304 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
7307 dw_die_ref skeleton
, orig_parent
;
7309 /* Copy the declaration context to the type unit DIE. If the returned
7310 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7312 orig_parent
= copy_declaration_context (unit
, child
);
7314 skeleton
= generate_skeleton (child
);
7315 if (skeleton
== NULL
)
7316 remove_child_with_prev (child
, prev
);
7319 skeleton
->comdat_type_p
= true;
7320 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
7322 /* If the original DIE was a specification, we need to put
7323 the skeleton under the parent DIE of the declaration.
7324 This leaves the original declaration in the tree, but
7325 it will be pruned later since there are no longer any
7326 references to it. */
7327 if (orig_parent
!= NULL
)
7329 remove_child_with_prev (child
, prev
);
7330 add_child_die (orig_parent
, skeleton
);
7333 replace_child (child
, skeleton
, prev
);
7339 /* Traverse the DIE and set up additional .debug_types sections for each
7340 type worthy of being placed in a COMDAT section. */
7343 break_out_comdat_types (dw_die_ref die
)
7347 dw_die_ref prev
= NULL
;
7348 dw_die_ref next
= NULL
;
7349 dw_die_ref unit
= NULL
;
7351 first
= c
= die
->die_child
;
7355 if (prev
== NULL
|| prev
->die_sib
== c
)
7358 next
= (c
== first
? NULL
: c
->die_sib
);
7359 if (should_move_die_to_comdat (c
))
7361 dw_die_ref replacement
;
7362 comdat_type_node_ref type_node
;
7364 /* Break out nested types into their own type units. */
7365 break_out_comdat_types (c
);
7367 /* Create a new type unit DIE as the root for the new tree, and
7368 add it to the list of comdat types. */
7369 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
7370 add_AT_unsigned (unit
, DW_AT_language
,
7371 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
7372 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
7373 type_node
->root_die
= unit
;
7374 type_node
->next
= comdat_type_list
;
7375 comdat_type_list
= type_node
;
7377 /* Generate the type signature. */
7378 generate_type_signature (c
, type_node
);
7380 /* Copy the declaration context, attributes, and children of the
7381 declaration into the new type unit DIE, then remove this DIE
7382 from the main CU (or replace it with a skeleton if necessary). */
7383 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
7384 type_node
->skeleton_die
= replacement
;
7386 /* Add the DIE to the new compunit. */
7387 add_child_die (unit
, c
);
7389 if (replacement
!= NULL
)
7392 else if (c
->die_tag
== DW_TAG_namespace
7393 || c
->die_tag
== DW_TAG_class_type
7394 || c
->die_tag
== DW_TAG_structure_type
7395 || c
->die_tag
== DW_TAG_union_type
)
7397 /* Look for nested types that can be broken out. */
7398 break_out_comdat_types (c
);
7400 } while (next
!= NULL
);
7403 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
7404 Enter all the cloned children into the hash table decl_table. */
7407 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
7411 struct decl_table_entry
*entry
;
7412 decl_table_entry
**slot
;
7414 if (die
->die_tag
== DW_TAG_subprogram
)
7415 clone
= clone_as_declaration (die
);
7417 clone
= clone_die (die
);
7419 slot
= decl_table
->find_slot_with_hash (die
,
7420 htab_hash_pointer (die
), INSERT
);
7422 /* Assert that DIE isn't in the hash table yet. If it would be there
7423 before, the ancestors would be necessarily there as well, therefore
7424 clone_tree_partial wouldn't be called. */
7425 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
7427 entry
= XCNEW (struct decl_table_entry
);
7429 entry
->copy
= clone
;
7432 if (die
->die_tag
!= DW_TAG_subprogram
)
7433 FOR_EACH_CHILD (die
, c
,
7434 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
7439 /* Walk the DIE and its children, looking for references to incomplete
7440 or trivial types that are unmarked (i.e., that are not in the current
7444 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
7450 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7452 if (AT_class (a
) == dw_val_class_die_ref
)
7454 dw_die_ref targ
= AT_ref (a
);
7455 decl_table_entry
**slot
;
7456 struct decl_table_entry
*entry
;
7458 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
7461 slot
= decl_table
->find_slot_with_hash (targ
,
7462 htab_hash_pointer (targ
),
7465 if (*slot
!= HTAB_EMPTY_ENTRY
)
7467 /* TARG has already been copied, so we just need to
7468 modify the reference to point to the copy. */
7470 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
7474 dw_die_ref parent
= unit
;
7475 dw_die_ref copy
= clone_die (targ
);
7477 /* Record in DECL_TABLE that TARG has been copied.
7478 Need to do this now, before the recursive call,
7479 because DECL_TABLE may be expanded and SLOT
7480 would no longer be a valid pointer. */
7481 entry
= XCNEW (struct decl_table_entry
);
7486 /* If TARG is not a declaration DIE, we need to copy its
7488 if (!is_declaration_die (targ
))
7492 add_child_die (copy
,
7493 clone_tree_partial (c
, decl_table
)));
7496 /* Make sure the cloned tree is marked as part of the
7500 /* If TARG has surrounding context, copy its ancestor tree
7501 into the new type unit. */
7502 if (targ
->die_parent
!= NULL
7503 && !is_unit_die (targ
->die_parent
))
7504 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
7507 add_child_die (parent
, copy
);
7508 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
7510 /* Make sure the newly-copied DIE is walked. If it was
7511 installed in a previously-added context, it won't
7512 get visited otherwise. */
7515 /* Find the highest point of the newly-added tree,
7516 mark each node along the way, and walk from there. */
7517 parent
->die_mark
= 1;
7518 while (parent
->die_parent
7519 && parent
->die_parent
->die_mark
== 0)
7521 parent
= parent
->die_parent
;
7522 parent
->die_mark
= 1;
7524 copy_decls_walk (unit
, parent
, decl_table
);
7530 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
7533 /* Copy declarations for "unworthy" types into the new comdat section.
7534 Incomplete types, modified types, and certain other types aren't broken
7535 out into comdat sections of their own, so they don't have a signature,
7536 and we need to copy the declaration into the same section so that we
7537 don't have an external reference. */
7540 copy_decls_for_unworthy_types (dw_die_ref unit
)
7543 decl_hash_type
decl_table (10);
7544 copy_decls_walk (unit
, unit
, &decl_table
);
7548 /* Traverse the DIE and add a sibling attribute if it may have the
7549 effect of speeding up access to siblings. To save some space,
7550 avoid generating sibling attributes for DIE's without children. */
7553 add_sibling_attributes (dw_die_ref die
)
7557 if (! die
->die_child
)
7560 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
7561 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
7563 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
7566 /* Output all location lists for the DIE and its children. */
7569 output_location_lists (dw_die_ref die
)
7575 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7576 if (AT_class (a
) == dw_val_class_loc_list
)
7577 output_loc_list (AT_loc_list (a
));
7579 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
7582 /* We want to limit the number of external references, because they are
7583 larger than local references: a relocation takes multiple words, and
7584 even a sig8 reference is always eight bytes, whereas a local reference
7585 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
7586 So if we encounter multiple external references to the same type DIE, we
7587 make a local typedef stub for it and redirect all references there.
7589 This is the element of the hash table for keeping track of these
7599 /* Hashtable helpers. */
7601 struct external_ref_hasher
: typed_free_remove
<external_ref
>
7603 typedef external_ref value_type
;
7604 typedef external_ref compare_type
;
7605 static inline hashval_t
hash (const value_type
*);
7606 static inline bool equal (const value_type
*, const compare_type
*);
7610 external_ref_hasher::hash (const value_type
*r
)
7612 dw_die_ref die
= r
->type
;
7615 /* We can't use the address of the DIE for hashing, because
7616 that will make the order of the stub DIEs non-deterministic. */
7617 if (! die
->comdat_type_p
)
7618 /* We have a symbol; use it to compute a hash. */
7619 h
= htab_hash_string (die
->die_id
.die_symbol
);
7622 /* We have a type signature; use a subset of the bits as the hash.
7623 The 8-byte signature is at least as large as hashval_t. */
7624 comdat_type_node_ref type_node
= die
->die_id
.die_type_node
;
7625 memcpy (&h
, type_node
->signature
, sizeof (h
));
7631 external_ref_hasher::equal (const value_type
*r1
, const compare_type
*r2
)
7633 return r1
->type
== r2
->type
;
7636 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
7638 /* Return a pointer to the external_ref for references to DIE. */
7640 static struct external_ref
*
7641 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
7643 struct external_ref ref
, *ref_p
;
7644 external_ref
**slot
;
7647 slot
= map
->find_slot (&ref
, INSERT
);
7648 if (*slot
!= HTAB_EMPTY_ENTRY
)
7651 ref_p
= XCNEW (struct external_ref
);
7657 /* Subroutine of optimize_external_refs, below.
7659 If we see a type skeleton, record it as our stub. If we see external
7660 references, remember how many we've seen. */
7663 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
7668 struct external_ref
*ref_p
;
7670 if (is_type_die (die
)
7671 && (c
= get_AT_ref (die
, DW_AT_signature
)))
7673 /* This is a local skeleton; use it for local references. */
7674 ref_p
= lookup_external_ref (map
, c
);
7678 /* Scan the DIE references, and remember any that refer to DIEs from
7679 other CUs (i.e. those which are not marked). */
7680 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7681 if (AT_class (a
) == dw_val_class_die_ref
7682 && (c
= AT_ref (a
))->die_mark
== 0
7685 ref_p
= lookup_external_ref (map
, c
);
7689 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
7692 /* htab_traverse callback function for optimize_external_refs, below. SLOT
7693 points to an external_ref, DATA is the CU we're processing. If we don't
7694 already have a local stub, and we have multiple refs, build a stub. */
7697 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
7699 struct external_ref
*ref_p
= *slot
;
7701 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
7703 /* We have multiple references to this type, so build a small stub.
7704 Both of these forms are a bit dodgy from the perspective of the
7705 DWARF standard, since technically they should have names. */
7706 dw_die_ref cu
= data
;
7707 dw_die_ref type
= ref_p
->type
;
7708 dw_die_ref stub
= NULL
;
7710 if (type
->comdat_type_p
)
7712 /* If we refer to this type via sig8, use AT_signature. */
7713 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
7714 add_AT_die_ref (stub
, DW_AT_signature
, type
);
7718 /* Otherwise, use a typedef with no name. */
7719 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
7720 add_AT_die_ref (stub
, DW_AT_type
, type
);
7729 /* DIE is a unit; look through all the DIE references to see if there are
7730 any external references to types, and if so, create local stubs for
7731 them which will be applied in build_abbrev_table. This is useful because
7732 references to local DIEs are smaller. */
7734 static external_ref_hash_type
*
7735 optimize_external_refs (dw_die_ref die
)
7737 external_ref_hash_type
*map
= new external_ref_hash_type (10);
7738 optimize_external_refs_1 (die
, map
);
7739 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
7743 /* The format of each DIE (and its attribute value pairs) is encoded in an
7744 abbreviation table. This routine builds the abbreviation table and assigns
7745 a unique abbreviation id for each abbreviation entry. The children of each
7746 die are visited recursively. */
7749 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
7751 unsigned long abbrev_id
;
7752 unsigned int n_alloc
;
7757 /* Scan the DIE references, and replace any that refer to
7758 DIEs from other CUs (i.e. those which are not marked) with
7759 the local stubs we built in optimize_external_refs. */
7760 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7761 if (AT_class (a
) == dw_val_class_die_ref
7762 && (c
= AT_ref (a
))->die_mark
== 0)
7764 struct external_ref
*ref_p
;
7765 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
7767 ref_p
= lookup_external_ref (extern_map
, c
);
7768 if (ref_p
->stub
&& ref_p
->stub
!= die
)
7769 change_AT_die_ref (a
, ref_p
->stub
);
7771 /* We aren't changing this reference, so mark it external. */
7772 set_AT_ref_external (a
, 1);
7775 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
7777 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
7778 dw_attr_ref die_a
, abbrev_a
;
7782 if (abbrev
->die_tag
!= die
->die_tag
)
7784 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
7787 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
7790 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
7792 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
7793 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
7794 || (value_format (abbrev_a
) != value_format (die_a
)))
7804 if (abbrev_id
>= abbrev_die_table_in_use
)
7806 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
7808 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
7809 abbrev_die_table
= GGC_RESIZEVEC (dw_die_ref
, abbrev_die_table
,
7812 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
7813 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
7814 abbrev_die_table_allocated
= n_alloc
;
7817 ++abbrev_die_table_in_use
;
7818 abbrev_die_table
[abbrev_id
] = die
;
7821 die
->die_abbrev
= abbrev_id
;
7822 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
7825 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7828 constant_size (unsigned HOST_WIDE_INT value
)
7835 log
= floor_log2 (value
);
7838 log
= 1 << (floor_log2 (log
) + 1);
7843 /* Return the size of a DIE as it is represented in the
7844 .debug_info section. */
7846 static unsigned long
7847 size_of_die (dw_die_ref die
)
7849 unsigned long size
= 0;
7852 enum dwarf_form form
;
7854 size
+= size_of_uleb128 (die
->die_abbrev
);
7855 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7857 switch (AT_class (a
))
7859 case dw_val_class_addr
:
7860 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7862 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7863 size
+= size_of_uleb128 (AT_index (a
));
7866 size
+= DWARF2_ADDR_SIZE
;
7868 case dw_val_class_offset
:
7869 size
+= DWARF_OFFSET_SIZE
;
7871 case dw_val_class_loc
:
7873 unsigned long lsize
= size_of_locs (AT_loc (a
));
7876 if (dwarf_version
>= 4)
7877 size
+= size_of_uleb128 (lsize
);
7879 size
+= constant_size (lsize
);
7883 case dw_val_class_loc_list
:
7884 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7886 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7887 size
+= size_of_uleb128 (AT_index (a
));
7890 size
+= DWARF_OFFSET_SIZE
;
7892 case dw_val_class_range_list
:
7893 size
+= DWARF_OFFSET_SIZE
;
7895 case dw_val_class_const
:
7896 size
+= size_of_sleb128 (AT_int (a
));
7898 case dw_val_class_unsigned_const
:
7900 int csize
= constant_size (AT_unsigned (a
));
7901 if (dwarf_version
== 3
7902 && a
->dw_attr
== DW_AT_data_member_location
7904 size
+= size_of_uleb128 (AT_unsigned (a
));
7909 case dw_val_class_const_double
:
7910 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
7911 if (HOST_BITS_PER_WIDE_INT
>= 64)
7914 case dw_val_class_wide_int
:
7915 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
7916 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7917 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
7921 case dw_val_class_vec
:
7922 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
7923 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
7924 + a
->dw_attr_val
.v
.val_vec
.length
7925 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
7927 case dw_val_class_flag
:
7928 if (dwarf_version
>= 4)
7929 /* Currently all add_AT_flag calls pass in 1 as last argument,
7930 so DW_FORM_flag_present can be used. If that ever changes,
7931 we'll need to use DW_FORM_flag and have some optimization
7932 in build_abbrev_table that will change those to
7933 DW_FORM_flag_present if it is set to 1 in all DIEs using
7934 the same abbrev entry. */
7935 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
7939 case dw_val_class_die_ref
:
7940 if (AT_ref_external (a
))
7942 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
7943 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
7944 is sized by target address length, whereas in DWARF3
7945 it's always sized as an offset. */
7946 if (use_debug_types
)
7947 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
7948 else if (dwarf_version
== 2)
7949 size
+= DWARF2_ADDR_SIZE
;
7951 size
+= DWARF_OFFSET_SIZE
;
7954 size
+= DWARF_OFFSET_SIZE
;
7956 case dw_val_class_fde_ref
:
7957 size
+= DWARF_OFFSET_SIZE
;
7959 case dw_val_class_lbl_id
:
7960 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7962 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7963 size
+= size_of_uleb128 (AT_index (a
));
7966 size
+= DWARF2_ADDR_SIZE
;
7968 case dw_val_class_lineptr
:
7969 case dw_val_class_macptr
:
7970 size
+= DWARF_OFFSET_SIZE
;
7972 case dw_val_class_str
:
7973 form
= AT_string_form (a
);
7974 if (form
== DW_FORM_strp
)
7975 size
+= DWARF_OFFSET_SIZE
;
7976 else if (form
== DW_FORM_GNU_str_index
)
7977 size
+= size_of_uleb128 (AT_index (a
));
7979 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
7981 case dw_val_class_file
:
7982 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
7984 case dw_val_class_data8
:
7987 case dw_val_class_vms_delta
:
7988 size
+= DWARF_OFFSET_SIZE
;
7990 case dw_val_class_high_pc
:
7991 size
+= DWARF2_ADDR_SIZE
;
8001 /* Size the debugging information associated with a given DIE. Visits the
8002 DIE's children recursively. Updates the global variable next_die_offset, on
8003 each time through. Uses the current value of next_die_offset to update the
8004 die_offset field in each DIE. */
8007 calc_die_sizes (dw_die_ref die
)
8011 gcc_assert (die
->die_offset
== 0
8012 || (unsigned long int) die
->die_offset
== next_die_offset
);
8013 die
->die_offset
= next_die_offset
;
8014 next_die_offset
+= size_of_die (die
);
8016 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
8018 if (die
->die_child
!= NULL
)
8019 /* Count the null byte used to terminate sibling lists. */
8020 next_die_offset
+= 1;
8023 /* Size just the base type children at the start of the CU.
8024 This is needed because build_abbrev needs to size locs
8025 and sizing of type based stack ops needs to know die_offset
8026 values for the base types. */
8029 calc_base_type_die_sizes (void)
8031 unsigned long die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8033 dw_die_ref base_type
;
8034 #if ENABLE_ASSERT_CHECKING
8035 dw_die_ref prev
= comp_unit_die ()->die_child
;
8038 die_offset
+= size_of_die (comp_unit_die ());
8039 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
8041 #if ENABLE_ASSERT_CHECKING
8042 gcc_assert (base_type
->die_offset
== 0
8043 && prev
->die_sib
== base_type
8044 && base_type
->die_child
== NULL
8045 && base_type
->die_abbrev
);
8048 base_type
->die_offset
= die_offset
;
8049 die_offset
+= size_of_die (base_type
);
8053 /* Set the marks for a die and its children. We do this so
8054 that we know whether or not a reference needs to use FORM_ref_addr; only
8055 DIEs in the same CU will be marked. We used to clear out the offset
8056 and use that as the flag, but ran into ordering problems. */
8059 mark_dies (dw_die_ref die
)
8063 gcc_assert (!die
->die_mark
);
8066 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
8069 /* Clear the marks for a die and its children. */
8072 unmark_dies (dw_die_ref die
)
8076 if (! use_debug_types
)
8077 gcc_assert (die
->die_mark
);
8080 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
8083 /* Clear the marks for a die, its children and referred dies. */
8086 unmark_all_dies (dw_die_ref die
)
8096 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
8098 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8099 if (AT_class (a
) == dw_val_class_die_ref
)
8100 unmark_all_dies (AT_ref (a
));
8103 /* Calculate if the entry should appear in the final output file. It may be
8104 from a pruned a type. */
8107 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
8109 /* By limiting gnu pubnames to definitions only, gold can generate a
8110 gdb index without entries for declarations, which don't include
8111 enough information to be useful. */
8112 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
8115 if (table
== pubname_table
)
8117 /* Enumerator names are part of the pubname table, but the
8118 parent DW_TAG_enumeration_type die may have been pruned.
8119 Don't output them if that is the case. */
8120 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
8121 (p
->die
->die_parent
== NULL
8122 || !p
->die
->die_parent
->die_perennial_p
))
8125 /* Everything else in the pubname table is included. */
8129 /* The pubtypes table shouldn't include types that have been
8131 return (p
->die
->die_offset
!= 0
8132 || !flag_eliminate_unused_debug_types
);
8135 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8136 generated for the compilation unit. */
8138 static unsigned long
8139 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
8144 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
8146 size
= DWARF_PUBNAMES_HEADER_SIZE
;
8147 FOR_EACH_VEC_ELT (*names
, i
, p
)
8148 if (include_pubname_in_output (names
, p
))
8149 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
8151 size
+= DWARF_OFFSET_SIZE
;
8155 /* Return the size of the information in the .debug_aranges section. */
8157 static unsigned long
8158 size_of_aranges (void)
8162 size
= DWARF_ARANGES_HEADER_SIZE
;
8164 /* Count the address/length pair for this compilation unit. */
8165 if (text_section_used
)
8166 size
+= 2 * DWARF2_ADDR_SIZE
;
8167 if (cold_text_section_used
)
8168 size
+= 2 * DWARF2_ADDR_SIZE
;
8169 if (have_multiple_function_sections
)
8174 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
8176 if (DECL_IGNORED_P (fde
->decl
))
8178 if (!fde
->in_std_section
)
8179 size
+= 2 * DWARF2_ADDR_SIZE
;
8180 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
8181 size
+= 2 * DWARF2_ADDR_SIZE
;
8185 /* Count the two zero words used to terminated the address range table. */
8186 size
+= 2 * DWARF2_ADDR_SIZE
;
8190 /* Select the encoding of an attribute value. */
8192 static enum dwarf_form
8193 value_format (dw_attr_ref a
)
8195 switch (AT_class (a
))
8197 case dw_val_class_addr
:
8198 /* Only very few attributes allow DW_FORM_addr. */
8203 case DW_AT_entry_pc
:
8204 case DW_AT_trampoline
:
8205 return (AT_index (a
) == NOT_INDEXED
8206 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8210 switch (DWARF2_ADDR_SIZE
)
8213 return DW_FORM_data1
;
8215 return DW_FORM_data2
;
8217 return DW_FORM_data4
;
8219 return DW_FORM_data8
;
8223 case dw_val_class_range_list
:
8224 case dw_val_class_loc_list
:
8225 if (dwarf_version
>= 4)
8226 return DW_FORM_sec_offset
;
8228 case dw_val_class_vms_delta
:
8229 case dw_val_class_offset
:
8230 switch (DWARF_OFFSET_SIZE
)
8233 return DW_FORM_data4
;
8235 return DW_FORM_data8
;
8239 case dw_val_class_loc
:
8240 if (dwarf_version
>= 4)
8241 return DW_FORM_exprloc
;
8242 switch (constant_size (size_of_locs (AT_loc (a
))))
8245 return DW_FORM_block1
;
8247 return DW_FORM_block2
;
8249 return DW_FORM_block4
;
8253 case dw_val_class_const
:
8254 return DW_FORM_sdata
;
8255 case dw_val_class_unsigned_const
:
8256 switch (constant_size (AT_unsigned (a
)))
8259 return DW_FORM_data1
;
8261 return DW_FORM_data2
;
8263 /* In DWARF3 DW_AT_data_member_location with
8264 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8265 constant, so we need to use DW_FORM_udata if we need
8266 a large constant. */
8267 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8268 return DW_FORM_udata
;
8269 return DW_FORM_data4
;
8271 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8272 return DW_FORM_udata
;
8273 return DW_FORM_data8
;
8277 case dw_val_class_const_double
:
8278 switch (HOST_BITS_PER_WIDE_INT
)
8281 return DW_FORM_data2
;
8283 return DW_FORM_data4
;
8285 return DW_FORM_data8
;
8288 return DW_FORM_block1
;
8290 case dw_val_class_wide_int
:
8291 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
8294 return DW_FORM_data1
;
8296 return DW_FORM_data2
;
8298 return DW_FORM_data4
;
8300 return DW_FORM_data8
;
8302 return DW_FORM_block1
;
8304 case dw_val_class_vec
:
8305 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
8306 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
8309 return DW_FORM_block1
;
8311 return DW_FORM_block2
;
8313 return DW_FORM_block4
;
8317 case dw_val_class_flag
:
8318 if (dwarf_version
>= 4)
8320 /* Currently all add_AT_flag calls pass in 1 as last argument,
8321 so DW_FORM_flag_present can be used. If that ever changes,
8322 we'll need to use DW_FORM_flag and have some optimization
8323 in build_abbrev_table that will change those to
8324 DW_FORM_flag_present if it is set to 1 in all DIEs using
8325 the same abbrev entry. */
8326 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
8327 return DW_FORM_flag_present
;
8329 return DW_FORM_flag
;
8330 case dw_val_class_die_ref
:
8331 if (AT_ref_external (a
))
8332 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
8335 case dw_val_class_fde_ref
:
8336 return DW_FORM_data
;
8337 case dw_val_class_lbl_id
:
8338 return (AT_index (a
) == NOT_INDEXED
8339 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8340 case dw_val_class_lineptr
:
8341 case dw_val_class_macptr
:
8342 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
8343 case dw_val_class_str
:
8344 return AT_string_form (a
);
8345 case dw_val_class_file
:
8346 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
8349 return DW_FORM_data1
;
8351 return DW_FORM_data2
;
8353 return DW_FORM_data4
;
8358 case dw_val_class_data8
:
8359 return DW_FORM_data8
;
8361 case dw_val_class_high_pc
:
8362 switch (DWARF2_ADDR_SIZE
)
8365 return DW_FORM_data1
;
8367 return DW_FORM_data2
;
8369 return DW_FORM_data4
;
8371 return DW_FORM_data8
;
8381 /* Output the encoding of an attribute value. */
8384 output_value_format (dw_attr_ref a
)
8386 enum dwarf_form form
= value_format (a
);
8388 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
8391 /* Given a die and id, produce the appropriate abbreviations. */
8394 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
8399 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
8400 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
8401 dwarf_tag_name (abbrev
->die_tag
));
8403 if (abbrev
->die_child
!= NULL
)
8404 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
8406 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
8408 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
8410 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
8411 dwarf_attr_name (a_attr
->dw_attr
));
8412 output_value_format (a_attr
);
8415 dw2_asm_output_data (1, 0, NULL
);
8416 dw2_asm_output_data (1, 0, NULL
);
8420 /* Output the .debug_abbrev section which defines the DIE abbreviation
8424 output_abbrev_section (void)
8426 unsigned long abbrev_id
;
8428 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
8429 output_die_abbrevs (abbrev_id
, abbrev_die_table
[abbrev_id
]);
8431 /* Terminate the table. */
8432 dw2_asm_output_data (1, 0, NULL
);
8435 /* Output a symbol we can use to refer to this DIE from another CU. */
8438 output_die_symbol (dw_die_ref die
)
8440 const char *sym
= die
->die_id
.die_symbol
;
8442 gcc_assert (!die
->comdat_type_p
);
8447 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
8448 /* We make these global, not weak; if the target doesn't support
8449 .linkonce, it doesn't support combining the sections, so debugging
8451 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
8453 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
8456 /* Return a new location list, given the begin and end range, and the
8459 static inline dw_loc_list_ref
8460 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
8461 const char *section
)
8463 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
8465 retlist
->begin
= begin
;
8466 retlist
->begin_entry
= NULL
;
8468 retlist
->expr
= expr
;
8469 retlist
->section
= section
;
8474 /* Generate a new internal symbol for this location list node, if it
8475 hasn't got one yet. */
8478 gen_llsym (dw_loc_list_ref list
)
8480 gcc_assert (!list
->ll_symbol
);
8481 list
->ll_symbol
= gen_internal_sym ("LLST");
8484 /* Output the location list given to us. */
8487 output_loc_list (dw_loc_list_ref list_head
)
8489 dw_loc_list_ref curr
= list_head
;
8491 if (list_head
->emitted
)
8493 list_head
->emitted
= true;
8495 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
8497 /* Walk the location list, and output each range + expression. */
8498 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
8501 /* Don't output an entry that starts and ends at the same address. */
8502 if (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
)
8504 size
= size_of_locs (curr
->expr
);
8505 /* If the expression is too large, drop it on the floor. We could
8506 perhaps put it into DW_TAG_dwarf_procedure and refer to that
8507 in the expression, but >= 64KB expressions for a single value
8508 in a single range are unlikely very useful. */
8511 if (dwarf_split_debug_info
)
8513 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
8514 "Location list start/length entry (%s)",
8515 list_head
->ll_symbol
);
8516 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
8517 "Location list range start index (%s)",
8519 /* The length field is 4 bytes. If we ever need to support
8520 an 8-byte length, we can add a new DW_LLE code or fall back
8521 to DW_LLE_GNU_start_end_entry. */
8522 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
8523 "Location list range length (%s)",
8524 list_head
->ll_symbol
);
8526 else if (!have_multiple_function_sections
)
8528 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
8529 "Location list begin address (%s)",
8530 list_head
->ll_symbol
);
8531 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
8532 "Location list end address (%s)",
8533 list_head
->ll_symbol
);
8537 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
8538 "Location list begin address (%s)",
8539 list_head
->ll_symbol
);
8540 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
8541 "Location list end address (%s)",
8542 list_head
->ll_symbol
);
8545 /* Output the block length for this list of location operations. */
8546 gcc_assert (size
<= 0xffff);
8547 dw2_asm_output_data (2, size
, "%s", "Location expression size");
8549 output_loc_sequence (curr
->expr
, -1);
8552 if (dwarf_split_debug_info
)
8553 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
8554 "Location list terminator (%s)",
8555 list_head
->ll_symbol
);
8558 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8559 "Location list terminator begin (%s)",
8560 list_head
->ll_symbol
);
8561 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8562 "Location list terminator end (%s)",
8563 list_head
->ll_symbol
);
8567 /* Output a range_list offset into the debug_range section. Emit a
8568 relocated reference if val_entry is NULL, otherwise, emit an
8569 indirect reference. */
8572 output_range_list_offset (dw_attr_ref a
)
8574 const char *name
= dwarf_attr_name (a
->dw_attr
);
8576 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
8578 char *p
= strchr (ranges_section_label
, '\0');
8579 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
, a
->dw_attr_val
.v
.val_offset
);
8580 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
8581 debug_ranges_section
, "%s", name
);
8585 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8586 "%s (offset from %s)", name
, ranges_section_label
);
8589 /* Output the offset into the debug_loc section. */
8592 output_loc_list_offset (dw_attr_ref a
)
8594 char *sym
= AT_loc_list (a
)->ll_symbol
;
8597 if (dwarf_split_debug_info
)
8598 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
8599 "%s", dwarf_attr_name (a
->dw_attr
));
8601 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
8602 "%s", dwarf_attr_name (a
->dw_attr
));
8605 /* Output an attribute's index or value appropriately. */
8608 output_attr_index_or_value (dw_attr_ref a
)
8610 const char *name
= dwarf_attr_name (a
->dw_attr
);
8612 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8614 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
8617 switch (AT_class (a
))
8619 case dw_val_class_addr
:
8620 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
8622 case dw_val_class_high_pc
:
8623 case dw_val_class_lbl_id
:
8624 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
8626 case dw_val_class_loc_list
:
8627 output_loc_list_offset (a
);
8634 /* Output a type signature. */
8637 output_signature (const char *sig
, const char *name
)
8641 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
8642 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
8645 /* Output the DIE and its attributes. Called recursively to generate
8646 the definitions of each child DIE. */
8649 output_die (dw_die_ref die
)
8656 /* If someone in another CU might refer to us, set up a symbol for
8657 them to point to. */
8658 if (! die
->comdat_type_p
&& die
->die_id
.die_symbol
)
8659 output_die_symbol (die
);
8661 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
8662 (unsigned long)die
->die_offset
,
8663 dwarf_tag_name (die
->die_tag
));
8665 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8667 const char *name
= dwarf_attr_name (a
->dw_attr
);
8669 switch (AT_class (a
))
8671 case dw_val_class_addr
:
8672 output_attr_index_or_value (a
);
8675 case dw_val_class_offset
:
8676 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8680 case dw_val_class_range_list
:
8681 output_range_list_offset (a
);
8684 case dw_val_class_loc
:
8685 size
= size_of_locs (AT_loc (a
));
8687 /* Output the block length for this list of location operations. */
8688 if (dwarf_version
>= 4)
8689 dw2_asm_output_data_uleb128 (size
, "%s", name
);
8691 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
8693 output_loc_sequence (AT_loc (a
), -1);
8696 case dw_val_class_const
:
8697 /* ??? It would be slightly more efficient to use a scheme like is
8698 used for unsigned constants below, but gdb 4.x does not sign
8699 extend. Gdb 5.x does sign extend. */
8700 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
8703 case dw_val_class_unsigned_const
:
8705 int csize
= constant_size (AT_unsigned (a
));
8706 if (dwarf_version
== 3
8707 && a
->dw_attr
== DW_AT_data_member_location
8709 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
8711 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
8715 case dw_val_class_const_double
:
8717 unsigned HOST_WIDE_INT first
, second
;
8719 if (HOST_BITS_PER_WIDE_INT
>= 64)
8720 dw2_asm_output_data (1,
8721 HOST_BITS_PER_DOUBLE_INT
8722 / HOST_BITS_PER_CHAR
,
8725 if (WORDS_BIG_ENDIAN
)
8727 first
= a
->dw_attr_val
.v
.val_double
.high
;
8728 second
= a
->dw_attr_val
.v
.val_double
.low
;
8732 first
= a
->dw_attr_val
.v
.val_double
.low
;
8733 second
= a
->dw_attr_val
.v
.val_double
.high
;
8736 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8738 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8743 case dw_val_class_wide_int
:
8746 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
8747 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
8748 if (len
* HOST_BITS_PER_WIDE_INT
> 64)
8749 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
) * l
,
8752 if (WORDS_BIG_ENDIAN
)
8753 for (i
= len
- 1; i
>= 0; --i
)
8755 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
8760 for (i
= 0; i
< len
; ++i
)
8762 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
8769 case dw_val_class_vec
:
8771 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
8772 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
8776 dw2_asm_output_data (constant_size (len
* elt_size
),
8777 len
* elt_size
, "%s", name
);
8778 if (elt_size
> sizeof (HOST_WIDE_INT
))
8783 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
8786 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
8787 "fp or vector constant word %u", i
);
8791 case dw_val_class_flag
:
8792 if (dwarf_version
>= 4)
8794 /* Currently all add_AT_flag calls pass in 1 as last argument,
8795 so DW_FORM_flag_present can be used. If that ever changes,
8796 we'll need to use DW_FORM_flag and have some optimization
8797 in build_abbrev_table that will change those to
8798 DW_FORM_flag_present if it is set to 1 in all DIEs using
8799 the same abbrev entry. */
8800 gcc_assert (AT_flag (a
) == 1);
8802 fprintf (asm_out_file
, "\t\t\t%s %s\n",
8803 ASM_COMMENT_START
, name
);
8806 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
8809 case dw_val_class_loc_list
:
8810 output_attr_index_or_value (a
);
8813 case dw_val_class_die_ref
:
8814 if (AT_ref_external (a
))
8816 if (AT_ref (a
)->comdat_type_p
)
8818 comdat_type_node_ref type_node
=
8819 AT_ref (a
)->die_id
.die_type_node
;
8821 gcc_assert (type_node
);
8822 output_signature (type_node
->signature
, name
);
8826 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
8830 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8831 length, whereas in DWARF3 it's always sized as an
8833 if (dwarf_version
== 2)
8834 size
= DWARF2_ADDR_SIZE
;
8836 size
= DWARF_OFFSET_SIZE
;
8837 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
8843 gcc_assert (AT_ref (a
)->die_offset
);
8844 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
8849 case dw_val_class_fde_ref
:
8853 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
8854 a
->dw_attr_val
.v
.val_fde_index
* 2);
8855 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
8860 case dw_val_class_vms_delta
:
8861 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
8862 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
8866 case dw_val_class_lbl_id
:
8867 output_attr_index_or_value (a
);
8870 case dw_val_class_lineptr
:
8871 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8872 debug_line_section
, "%s", name
);
8875 case dw_val_class_macptr
:
8876 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8877 debug_macinfo_section
, "%s", name
);
8880 case dw_val_class_str
:
8881 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
8882 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
8883 a
->dw_attr_val
.v
.val_str
->label
,
8885 "%s: \"%s\"", name
, AT_string (a
));
8886 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_GNU_str_index
)
8887 dw2_asm_output_data_uleb128 (AT_index (a
),
8888 "%s: \"%s\"", name
, AT_string (a
));
8890 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
8893 case dw_val_class_file
:
8895 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
8897 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
8898 a
->dw_attr_val
.v
.val_file
->filename
);
8902 case dw_val_class_data8
:
8906 for (i
= 0; i
< 8; i
++)
8907 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
8908 i
== 0 ? "%s" : NULL
, name
);
8912 case dw_val_class_high_pc
:
8913 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
8914 get_AT_low_pc (die
), "DW_AT_high_pc");
8922 FOR_EACH_CHILD (die
, c
, output_die (c
));
8924 /* Add null byte to terminate sibling list. */
8925 if (die
->die_child
!= NULL
)
8926 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
8927 (unsigned long) die
->die_offset
);
8930 /* Output the compilation unit that appears at the beginning of the
8931 .debug_info section, and precedes the DIE descriptions. */
8934 output_compilation_unit_header (void)
8936 int ver
= dwarf_version
;
8938 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8939 dw2_asm_output_data (4, 0xffffffff,
8940 "Initial length escape value indicating 64-bit DWARF extension");
8941 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
8942 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
8943 "Length of Compilation Unit Info");
8944 dw2_asm_output_data (2, ver
, "DWARF version number");
8945 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
8946 debug_abbrev_section
,
8947 "Offset Into Abbrev. Section");
8948 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
8951 /* Output the compilation unit DIE and its children. */
8954 output_comp_unit (dw_die_ref die
, int output_if_empty
)
8956 const char *secname
, *oldsym
;
8959 /* Unless we are outputting main CU, we may throw away empty ones. */
8960 if (!output_if_empty
&& die
->die_child
== NULL
)
8963 /* Even if there are no children of this DIE, we must output the information
8964 about the compilation unit. Otherwise, on an empty translation unit, we
8965 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8966 will then complain when examining the file. First mark all the DIEs in
8967 this CU so we know which get local refs. */
8970 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
8972 build_abbrev_table (die
, extern_map
);
8976 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8977 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8978 calc_die_sizes (die
);
8980 oldsym
= die
->die_id
.die_symbol
;
8983 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
8985 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
8987 die
->die_id
.die_symbol
= NULL
;
8988 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
8992 switch_to_section (debug_info_section
);
8993 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
8994 info_section_emitted
= true;
8997 /* Output debugging information. */
8998 output_compilation_unit_header ();
9001 /* Leave the marks on the main CU, so we can check them in
9006 die
->die_id
.die_symbol
= oldsym
;
9010 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
9011 and .debug_pubtypes. This is configured per-target, but can be
9012 overridden by the -gpubnames or -gno-pubnames options. */
9015 want_pubnames (void)
9017 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9019 if (debug_generate_pub_sections
!= -1)
9020 return debug_generate_pub_sections
;
9021 return targetm
.want_debug_pub_sections
;
9024 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
9027 add_AT_pubnames (dw_die_ref die
)
9029 if (want_pubnames ())
9030 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
9033 /* Add a string attribute value to a skeleton DIE. */
9036 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
9040 struct indirect_string_node
*node
;
9042 if (! skeleton_debug_str_hash
)
9043 skeleton_debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
9044 debug_str_eq
, NULL
);
9046 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
9047 find_string_form (node
);
9048 if (node
->form
== DW_FORM_GNU_str_index
)
9049 node
->form
= DW_FORM_strp
;
9051 attr
.dw_attr
= attr_kind
;
9052 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
9053 attr
.dw_attr_val
.val_entry
= NULL
;
9054 attr
.dw_attr_val
.v
.val_str
= node
;
9055 add_dwarf_attr (die
, &attr
);
9058 /* Helper function to generate top-level dies for skeleton debug_info and
9062 add_top_level_skeleton_die_attrs (dw_die_ref die
)
9064 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
9065 const char *comp_dir
= comp_dir_string ();
9067 add_skeleton_AT_string (die
, DW_AT_GNU_dwo_name
, dwo_file_name
);
9068 if (comp_dir
!= NULL
)
9069 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
9070 add_AT_pubnames (die
);
9071 add_AT_lineptr (die
, DW_AT_GNU_addr_base
, debug_addr_section_label
);
9074 /* Output skeleton debug sections that point to the dwo file. */
9077 output_skeleton_debug_sections (dw_die_ref comp_unit
)
9079 /* These attributes will be found in the full debug_info section. */
9080 remove_AT (comp_unit
, DW_AT_producer
);
9081 remove_AT (comp_unit
, DW_AT_language
);
9083 switch_to_section (debug_skeleton_info_section
);
9084 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
9086 /* Produce the skeleton compilation-unit header. This one differs enough from
9087 a normal CU header that it's better not to call output_compilation_unit
9089 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9090 dw2_asm_output_data (4, 0xffffffff,
9091 "Initial length escape value indicating 64-bit DWARF extension");
9093 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9094 DWARF_COMPILE_UNIT_HEADER_SIZE
9095 - DWARF_INITIAL_LENGTH_SIZE
9096 + size_of_die (comp_unit
),
9097 "Length of Compilation Unit Info");
9098 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
9099 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
9100 debug_abbrev_section
,
9101 "Offset Into Abbrev. Section");
9102 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
9104 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
9105 output_die (comp_unit
);
9107 /* Build the skeleton debug_abbrev section. */
9108 switch_to_section (debug_skeleton_abbrev_section
);
9109 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
9111 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
9113 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
9116 /* Output a comdat type unit DIE and its children. */
9119 output_comdat_type_unit (comdat_type_node
*node
)
9121 const char *secname
;
9124 #if defined (OBJECT_FORMAT_ELF)
9128 /* First mark all the DIEs in this CU so we know which get local refs. */
9129 mark_dies (node
->root_die
);
9131 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
9133 build_abbrev_table (node
->root_die
, extern_map
);
9138 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9139 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
9140 calc_die_sizes (node
->root_die
);
9142 #if defined (OBJECT_FORMAT_ELF)
9143 if (!dwarf_split_debug_info
)
9144 secname
= ".debug_types";
9146 secname
= ".debug_types.dwo";
9148 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9149 sprintf (tmp
, "wt.");
9150 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9151 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9152 comdat_key
= get_identifier (tmp
);
9153 targetm
.asm_out
.named_section (secname
,
9154 SECTION_DEBUG
| SECTION_LINKONCE
,
9157 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9158 sprintf (tmp
, ".gnu.linkonce.wt.");
9159 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9160 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9162 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
9165 /* Output debugging information. */
9166 output_compilation_unit_header ();
9167 output_signature (node
->signature
, "Type Signature");
9168 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
9169 "Offset to Type DIE");
9170 output_die (node
->root_die
);
9172 unmark_dies (node
->root_die
);
9175 /* Return the DWARF2/3 pubname associated with a decl. */
9178 dwarf2_name (tree decl
, int scope
)
9180 if (DECL_NAMELESS (decl
))
9182 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
9185 /* Add a new entry to .debug_pubnames if appropriate. */
9188 add_pubname_string (const char *str
, dw_die_ref die
)
9193 e
.name
= xstrdup (str
);
9194 vec_safe_push (pubname_table
, e
);
9198 add_pubname (tree decl
, dw_die_ref die
)
9200 if (!want_pubnames ())
9203 /* Don't add items to the table when we expect that the consumer will have
9204 just read the enclosing die. For example, if the consumer is looking at a
9205 class_member, it will either be inside the class already, or will have just
9206 looked up the class to find the member. Either way, searching the class is
9207 faster than searching the index. */
9208 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
9209 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9211 const char *name
= dwarf2_name (decl
, 1);
9214 add_pubname_string (name
, die
);
9218 /* Add an enumerator to the pubnames section. */
9221 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
9225 gcc_assert (scope_name
);
9226 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
9228 vec_safe_push (pubname_table
, e
);
9231 /* Add a new entry to .debug_pubtypes if appropriate. */
9234 add_pubtype (tree decl
, dw_die_ref die
)
9238 if (!want_pubnames ())
9241 if ((TREE_PUBLIC (decl
)
9242 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9243 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
9246 const char *scope_name
= "";
9247 const char *sep
= is_cxx () ? "::" : ".";
9250 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
9251 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
9253 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
9254 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
9255 scope_name
= concat (scope_name
, sep
, NULL
);
9261 name
= type_tag (decl
);
9263 name
= lang_hooks
.dwarf_name (decl
, 1);
9265 /* If we don't have a name for the type, there's no point in adding
9267 if (name
!= NULL
&& name
[0] != '\0')
9270 e
.name
= concat (scope_name
, name
, NULL
);
9271 vec_safe_push (pubtype_table
, e
);
9274 /* Although it might be more consistent to add the pubinfo for the
9275 enumerators as their dies are created, they should only be added if the
9276 enum type meets the criteria above. So rather than re-check the parent
9277 enum type whenever an enumerator die is created, just output them all
9278 here. This isn't protected by the name conditional because anonymous
9279 enums don't have names. */
9280 if (die
->die_tag
== DW_TAG_enumeration_type
)
9284 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
9289 /* Output a single entry in the pubnames table. */
9292 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
9294 dw_die_ref die
= entry
->die
;
9295 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
9297 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
9299 if (debug_generate_pub_sections
== 2)
9301 /* This logic follows gdb's method for determining the value of the flag
9303 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
9304 switch (die
->die_tag
)
9306 case DW_TAG_typedef
:
9307 case DW_TAG_base_type
:
9308 case DW_TAG_subrange_type
:
9309 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9310 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9312 case DW_TAG_enumerator
:
9313 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9314 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9315 if (!is_cxx () && !is_java ())
9316 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9318 case DW_TAG_subprogram
:
9319 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9320 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
9322 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9324 case DW_TAG_constant
:
9325 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9326 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9327 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9329 case DW_TAG_variable
:
9330 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9331 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9332 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9334 case DW_TAG_namespace
:
9335 case DW_TAG_imported_declaration
:
9336 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9338 case DW_TAG_class_type
:
9339 case DW_TAG_interface_type
:
9340 case DW_TAG_structure_type
:
9341 case DW_TAG_union_type
:
9342 case DW_TAG_enumeration_type
:
9343 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9344 if (!is_cxx () && !is_java ())
9345 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9348 /* An unusual tag. Leave the flag-byte empty. */
9351 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
9355 dw2_asm_output_nstring (entry
->name
, -1, "external name");
9359 /* Output the public names table used to speed up access to externally
9360 visible names; or the public types table used to find type definitions. */
9363 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9366 unsigned long pubnames_length
= size_of_pubnames (names
);
9369 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9370 dw2_asm_output_data (4, 0xffffffff,
9371 "Initial length escape value indicating 64-bit DWARF extension");
9372 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
, "Pub Info Length");
9374 /* Version number for pubnames/pubtypes is independent of dwarf version. */
9375 dw2_asm_output_data (2, 2, "DWARF Version");
9377 if (dwarf_split_debug_info
)
9378 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9379 debug_skeleton_info_section
,
9380 "Offset of Compilation Unit Info");
9382 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9384 "Offset of Compilation Unit Info");
9385 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
9386 "Compilation Unit Length");
9388 FOR_EACH_VEC_ELT (*names
, i
, pub
)
9390 if (include_pubname_in_output (names
, pub
))
9392 dw_offset die_offset
= pub
->die
->die_offset
;
9394 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9395 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
9396 gcc_assert (pub
->die
->die_mark
);
9398 /* If we're putting types in their own .debug_types sections,
9399 the .debug_pubtypes table will still point to the compile
9400 unit (not the type unit), so we want to use the offset of
9401 the skeleton DIE (if there is one). */
9402 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
9404 comdat_type_node_ref type_node
= pub
->die
->die_id
.die_type_node
;
9406 if (type_node
!= NULL
)
9407 die_offset
= (type_node
->skeleton_die
!= NULL
9408 ? type_node
->skeleton_die
->die_offset
9409 : comp_unit_die ()->die_offset
);
9412 output_pubname (die_offset
, pub
);
9416 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
9419 /* Output public names and types tables if necessary. */
9422 output_pubtables (void)
9424 if (!want_pubnames () || !info_section_emitted
)
9427 switch_to_section (debug_pubnames_section
);
9428 output_pubnames (pubname_table
);
9429 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
9430 It shouldn't hurt to emit it always, since pure DWARF2 consumers
9431 simply won't look for the section. */
9432 switch_to_section (debug_pubtypes_section
);
9433 output_pubnames (pubtype_table
);
9437 /* Output the information that goes into the .debug_aranges table.
9438 Namely, define the beginning and ending address range of the
9439 text section generated for this compilation unit. */
9442 output_aranges (unsigned long aranges_length
)
9446 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9447 dw2_asm_output_data (4, 0xffffffff,
9448 "Initial length escape value indicating 64-bit DWARF extension");
9449 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
9450 "Length of Address Ranges Info");
9451 /* Version number for aranges is still 2, even in DWARF3. */
9452 dw2_asm_output_data (2, 2, "DWARF Version");
9453 if (dwarf_split_debug_info
)
9454 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9455 debug_skeleton_info_section
,
9456 "Offset of Compilation Unit Info");
9458 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9460 "Offset of Compilation Unit Info");
9461 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
9462 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9464 /* We need to align to twice the pointer size here. */
9465 if (DWARF_ARANGES_PAD_SIZE
)
9467 /* Pad using a 2 byte words so that padding is correct for any
9469 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9470 2 * DWARF2_ADDR_SIZE
);
9471 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
9472 dw2_asm_output_data (2, 0, NULL
);
9475 /* It is necessary not to output these entries if the sections were
9476 not used; if the sections were not used, the length will be 0 and
9477 the address may end up as 0 if the section is discarded by ld
9478 --gc-sections, leaving an invalid (0, 0) entry that can be
9479 confused with the terminator. */
9480 if (text_section_used
)
9482 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
9483 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
9484 text_section_label
, "Length");
9486 if (cold_text_section_used
)
9488 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
9490 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
9491 cold_text_section_label
, "Length");
9494 if (have_multiple_function_sections
)
9499 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9501 if (DECL_IGNORED_P (fde
->decl
))
9503 if (!fde
->in_std_section
)
9505 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
9507 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
9508 fde
->dw_fde_begin
, "Length");
9510 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9512 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
9514 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
9515 fde
->dw_fde_second_begin
, "Length");
9520 /* Output the terminator words. */
9521 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9522 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9525 /* Add a new entry to .debug_ranges. Return the offset at which it
9529 add_ranges_num (int num
)
9531 unsigned int in_use
= ranges_table_in_use
;
9533 if (in_use
== ranges_table_allocated
)
9535 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
9536 ranges_table
= GGC_RESIZEVEC (struct dw_ranges_struct
, ranges_table
,
9537 ranges_table_allocated
);
9538 memset (ranges_table
+ ranges_table_in_use
, 0,
9539 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
9542 ranges_table
[in_use
].num
= num
;
9543 ranges_table_in_use
= in_use
+ 1;
9545 return in_use
* 2 * DWARF2_ADDR_SIZE
;
9548 /* Add a new entry to .debug_ranges corresponding to a block, or a
9549 range terminator if BLOCK is NULL. */
9552 add_ranges (const_tree block
)
9554 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0);
9557 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
9558 When using dwarf_split_debug_info, address attributes in dies destined
9559 for the final executable should be direct references--setting the
9560 parameter force_direct ensures this behavior. */
9563 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
9564 bool *added
, bool force_direct
)
9566 unsigned int in_use
= ranges_by_label_in_use
;
9567 unsigned int offset
;
9569 if (in_use
== ranges_by_label_allocated
)
9571 ranges_by_label_allocated
+= RANGES_TABLE_INCREMENT
;
9572 ranges_by_label
= GGC_RESIZEVEC (struct dw_ranges_by_label_struct
,
9574 ranges_by_label_allocated
);
9575 memset (ranges_by_label
+ ranges_by_label_in_use
, 0,
9576 RANGES_TABLE_INCREMENT
9577 * sizeof (struct dw_ranges_by_label_struct
));
9580 ranges_by_label
[in_use
].begin
= begin
;
9581 ranges_by_label
[in_use
].end
= end
;
9582 ranges_by_label_in_use
= in_use
+ 1;
9584 offset
= add_ranges_num (-(int)in_use
- 1);
9587 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
9593 output_ranges (void)
9596 static const char *const start_fmt
= "Offset %#x";
9597 const char *fmt
= start_fmt
;
9599 for (i
= 0; i
< ranges_table_in_use
; i
++)
9601 int block_num
= ranges_table
[i
].num
;
9605 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
9606 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
9608 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
9609 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
9611 /* If all code is in the text section, then the compilation
9612 unit base address defaults to DW_AT_low_pc, which is the
9613 base of the text section. */
9614 if (!have_multiple_function_sections
)
9616 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
9618 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9619 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
9620 text_section_label
, NULL
);
9623 /* Otherwise, the compilation unit base address is zero,
9624 which allows us to use absolute addresses, and not worry
9625 about whether the target supports cross-section
9629 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
9630 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9631 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
9637 /* Negative block_num stands for an index into ranges_by_label. */
9638 else if (block_num
< 0)
9640 int lab_idx
= - block_num
- 1;
9642 if (!have_multiple_function_sections
)
9646 /* If we ever use add_ranges_by_labels () for a single
9647 function section, all we have to do is to take out
9649 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9650 ranges_by_label
[lab_idx
].begin
,
9652 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9653 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9654 ranges_by_label
[lab_idx
].end
,
9655 text_section_label
, NULL
);
9660 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9661 ranges_by_label
[lab_idx
].begin
,
9662 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9663 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9664 ranges_by_label
[lab_idx
].end
,
9670 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9671 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9677 /* Data structure containing information about input files. */
9680 const char *path
; /* Complete file name. */
9681 const char *fname
; /* File name part. */
9682 int length
; /* Length of entire string. */
9683 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
9684 int dir_idx
; /* Index in directory table. */
9687 /* Data structure containing information about directories with source
9691 const char *path
; /* Path including directory name. */
9692 int length
; /* Path length. */
9693 int prefix
; /* Index of directory entry which is a prefix. */
9694 int count
; /* Number of files in this directory. */
9695 int dir_idx
; /* Index of directory used as base. */
9698 /* Callback function for file_info comparison. We sort by looking at
9699 the directories in the path. */
9702 file_info_cmp (const void *p1
, const void *p2
)
9704 const struct file_info
*const s1
= (const struct file_info
*) p1
;
9705 const struct file_info
*const s2
= (const struct file_info
*) p2
;
9706 const unsigned char *cp1
;
9707 const unsigned char *cp2
;
9709 /* Take care of file names without directories. We need to make sure that
9710 we return consistent values to qsort since some will get confused if
9711 we return the same value when identical operands are passed in opposite
9712 orders. So if neither has a directory, return 0 and otherwise return
9713 1 or -1 depending on which one has the directory. */
9714 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
9715 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
9717 cp1
= (const unsigned char *) s1
->path
;
9718 cp2
= (const unsigned char *) s2
->path
;
9724 /* Reached the end of the first path? If so, handle like above. */
9725 if ((cp1
== (const unsigned char *) s1
->fname
)
9726 || (cp2
== (const unsigned char *) s2
->fname
))
9727 return ((cp2
== (const unsigned char *) s2
->fname
)
9728 - (cp1
== (const unsigned char *) s1
->fname
));
9730 /* Character of current path component the same? */
9731 else if (*cp1
!= *cp2
)
9736 struct file_name_acquire_data
9738 struct file_info
*files
;
9743 /* Traversal function for the hash table. */
9746 file_name_acquire (void ** slot
, void *data
)
9748 struct file_name_acquire_data
*fnad
= (struct file_name_acquire_data
*) data
;
9749 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
9750 struct file_info
*fi
;
9753 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
9755 if (! d
->emitted_number
)
9758 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
9760 fi
= fnad
->files
+ fnad
->used_files
++;
9762 /* Skip all leading "./". */
9764 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
9767 /* Create a new array entry. */
9769 fi
->length
= strlen (f
);
9772 /* Search for the file name part. */
9773 f
= strrchr (f
, DIR_SEPARATOR
);
9774 #if defined (DIR_SEPARATOR_2)
9776 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
9780 if (f
== NULL
|| f
< g
)
9786 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
9790 /* Output the directory table and the file name table. We try to minimize
9791 the total amount of memory needed. A heuristic is used to avoid large
9792 slowdowns with many input files. */
9795 output_file_names (void)
9797 struct file_name_acquire_data fnad
;
9799 struct file_info
*files
;
9800 struct dir_info
*dirs
;
9808 if (!last_emitted_file
)
9810 dw2_asm_output_data (1, 0, "End directory table");
9811 dw2_asm_output_data (1, 0, "End file name table");
9815 numfiles
= last_emitted_file
->emitted_number
;
9817 /* Allocate the various arrays we need. */
9818 files
= XALLOCAVEC (struct file_info
, numfiles
);
9819 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
9822 fnad
.used_files
= 0;
9823 fnad
.max_files
= numfiles
;
9824 htab_traverse (file_table
, file_name_acquire
, &fnad
);
9825 gcc_assert (fnad
.used_files
== fnad
.max_files
);
9827 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
9829 /* Find all the different directories used. */
9830 dirs
[0].path
= files
[0].path
;
9831 dirs
[0].length
= files
[0].fname
- files
[0].path
;
9832 dirs
[0].prefix
= -1;
9834 dirs
[0].dir_idx
= 0;
9835 files
[0].dir_idx
= 0;
9838 for (i
= 1; i
< numfiles
; i
++)
9839 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
9840 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
9841 dirs
[ndirs
- 1].length
) == 0)
9843 /* Same directory as last entry. */
9844 files
[i
].dir_idx
= ndirs
- 1;
9845 ++dirs
[ndirs
- 1].count
;
9851 /* This is a new directory. */
9852 dirs
[ndirs
].path
= files
[i
].path
;
9853 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
9854 dirs
[ndirs
].count
= 1;
9855 dirs
[ndirs
].dir_idx
= ndirs
;
9856 files
[i
].dir_idx
= ndirs
;
9858 /* Search for a prefix. */
9859 dirs
[ndirs
].prefix
= -1;
9860 for (j
= 0; j
< ndirs
; j
++)
9861 if (dirs
[j
].length
< dirs
[ndirs
].length
9862 && dirs
[j
].length
> 1
9863 && (dirs
[ndirs
].prefix
== -1
9864 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
9865 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
9866 dirs
[ndirs
].prefix
= j
;
9871 /* Now to the actual work. We have to find a subset of the directories which
9872 allow expressing the file name using references to the directory table
9873 with the least amount of characters. We do not do an exhaustive search
9874 where we would have to check out every combination of every single
9875 possible prefix. Instead we use a heuristic which provides nearly optimal
9876 results in most cases and never is much off. */
9877 saved
= XALLOCAVEC (int, ndirs
);
9878 savehere
= XALLOCAVEC (int, ndirs
);
9880 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
9881 for (i
= 0; i
< ndirs
; i
++)
9886 /* We can always save some space for the current directory. But this
9887 does not mean it will be enough to justify adding the directory. */
9888 savehere
[i
] = dirs
[i
].length
;
9889 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
9891 for (j
= i
+ 1; j
< ndirs
; j
++)
9894 if (saved
[j
] < dirs
[i
].length
)
9896 /* Determine whether the dirs[i] path is a prefix of the
9901 while (k
!= -1 && k
!= (int) i
)
9906 /* Yes it is. We can possibly save some memory by
9907 writing the filenames in dirs[j] relative to
9909 savehere
[j
] = dirs
[i
].length
;
9910 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
9915 /* Check whether we can save enough to justify adding the dirs[i]
9917 if (total
> dirs
[i
].length
+ 1)
9919 /* It's worthwhile adding. */
9920 for (j
= i
; j
< ndirs
; j
++)
9921 if (savehere
[j
] > 0)
9923 /* Remember how much we saved for this directory so far. */
9924 saved
[j
] = savehere
[j
];
9926 /* Remember the prefix directory. */
9927 dirs
[j
].dir_idx
= i
;
9932 /* Emit the directory name table. */
9933 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
9934 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
9935 dw2_asm_output_nstring (dirs
[i
].path
,
9937 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
9938 "Directory Entry: %#x", i
+ idx_offset
);
9940 dw2_asm_output_data (1, 0, "End directory table");
9942 /* We have to emit them in the order of emitted_number since that's
9943 used in the debug info generation. To do this efficiently we
9944 generate a back-mapping of the indices first. */
9945 backmap
= XALLOCAVEC (int, numfiles
);
9946 for (i
= 0; i
< numfiles
; i
++)
9947 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
9949 /* Now write all the file names. */
9950 for (i
= 0; i
< numfiles
; i
++)
9952 int file_idx
= backmap
[i
];
9953 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
9955 #ifdef VMS_DEBUGGING_INFO
9956 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
9958 /* Setting these fields can lead to debugger miscomparisons,
9959 but VMS Debug requires them to be set correctly. */
9964 int maxfilelen
= strlen (files
[file_idx
].path
)
9965 + dirs
[dir_idx
].length
9966 + MAX_VMS_VERSION_LEN
+ 1;
9967 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
9969 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
9970 snprintf (filebuf
, maxfilelen
, "%s;%d",
9971 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
9973 dw2_asm_output_nstring
9974 (filebuf
, -1, "File Entry: %#x", (unsigned) i
+ 1);
9976 /* Include directory index. */
9977 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
9979 /* Modification time. */
9980 dw2_asm_output_data_uleb128
9981 ((vms_file_stats_name (files
[file_idx
].path
, &cdt
, 0, 0, 0) == 0)
9985 /* File length in bytes. */
9986 dw2_asm_output_data_uleb128
9987 ((vms_file_stats_name (files
[file_idx
].path
, 0, &siz
, 0, 0) == 0)
9991 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
9992 "File Entry: %#x", (unsigned) i
+ 1);
9994 /* Include directory index. */
9995 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
9997 /* Modification time. */
9998 dw2_asm_output_data_uleb128 (0, NULL
);
10000 /* File length in bytes. */
10001 dw2_asm_output_data_uleb128 (0, NULL
);
10002 #endif /* VMS_DEBUGGING_INFO */
10005 dw2_asm_output_data (1, 0, "End file name table");
10009 /* Output one line number table into the .debug_line section. */
10012 output_one_line_info_table (dw_line_info_table
*table
)
10014 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10015 unsigned int current_line
= 1;
10016 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
10017 dw_line_info_entry
*ent
;
10020 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
10022 switch (ent
->opcode
)
10024 case LI_set_address
:
10025 /* ??? Unfortunately, we have little choice here currently, and
10026 must always use the most general form. GCC does not know the
10027 address delta itself, so we can't use DW_LNS_advance_pc. Many
10028 ports do have length attributes which will give an upper bound
10029 on the address range. We could perhaps use length attributes
10030 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
10031 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
10033 /* This can handle any delta. This takes
10034 4+DWARF2_ADDR_SIZE bytes. */
10035 dw2_asm_output_data (1, 0, "set address %s", line_label
);
10036 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10037 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10038 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
10042 if (ent
->val
== current_line
)
10044 /* We still need to start a new row, so output a copy insn. */
10045 dw2_asm_output_data (1, DW_LNS_copy
,
10046 "copy line %u", current_line
);
10050 int line_offset
= ent
->val
- current_line
;
10051 int line_delta
= line_offset
- DWARF_LINE_BASE
;
10053 current_line
= ent
->val
;
10054 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
10056 /* This can handle deltas from -10 to 234, using the current
10057 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
10058 This takes 1 byte. */
10059 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
10060 "line %u", current_line
);
10064 /* This can handle any delta. This takes at least 4 bytes,
10065 depending on the value being encoded. */
10066 dw2_asm_output_data (1, DW_LNS_advance_line
,
10067 "advance to line %u", current_line
);
10068 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
10069 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
10075 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
10076 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
10079 case LI_set_column
:
10080 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
10081 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
10084 case LI_negate_stmt
:
10085 current_is_stmt
= !current_is_stmt
;
10086 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
10087 "is_stmt %d", current_is_stmt
);
10090 case LI_set_prologue_end
:
10091 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
10092 "set prologue end");
10095 case LI_set_epilogue_begin
:
10096 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
10097 "set epilogue begin");
10100 case LI_set_discriminator
:
10101 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
10102 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
10103 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
10104 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
10109 /* Emit debug info for the address of the end of the table. */
10110 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
10111 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10112 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10113 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
10115 dw2_asm_output_data (1, 0, "end sequence");
10116 dw2_asm_output_data_uleb128 (1, NULL
);
10117 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
10120 /* Output the source line number correspondence information. This
10121 information goes into the .debug_line section. */
10124 output_line_info (bool prologue_only
)
10126 char l1
[20], l2
[20], p1
[20], p2
[20];
10127 int ver
= dwarf_version
;
10128 bool saw_one
= false;
10131 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
10132 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
10133 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
10134 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
10136 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10137 dw2_asm_output_data (4, 0xffffffff,
10138 "Initial length escape value indicating 64-bit DWARF extension");
10139 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
10140 "Length of Source Line Info");
10141 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
10143 dw2_asm_output_data (2, ver
, "DWARF Version");
10144 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
10145 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
10147 /* Define the architecture-dependent minimum instruction length (in bytes).
10148 In this implementation of DWARF, this field is used for information
10149 purposes only. Since GCC generates assembly language, we have no
10150 a priori knowledge of how many instruction bytes are generated for each
10151 source line, and therefore can use only the DW_LNE_set_address and
10152 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
10153 this as '1', which is "correct enough" for all architectures,
10154 and don't let the target override. */
10155 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
10158 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
10159 "Maximum Operations Per Instruction");
10160 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
10161 "Default is_stmt_start flag");
10162 dw2_asm_output_data (1, DWARF_LINE_BASE
,
10163 "Line Base Value (Special Opcodes)");
10164 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
10165 "Line Range Value (Special Opcodes)");
10166 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
10167 "Special Opcode Base");
10169 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
10174 case DW_LNS_advance_pc
:
10175 case DW_LNS_advance_line
:
10176 case DW_LNS_set_file
:
10177 case DW_LNS_set_column
:
10178 case DW_LNS_fixed_advance_pc
:
10179 case DW_LNS_set_isa
:
10187 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
10191 /* Write out the information about the files we use. */
10192 output_file_names ();
10193 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
10196 /* Output the marker for the end of the line number info. */
10197 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10201 if (separate_line_info
)
10203 dw_line_info_table
*table
;
10206 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
10209 output_one_line_info_table (table
);
10213 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
10215 output_one_line_info_table (cold_text_section_line_info
);
10219 /* ??? Some Darwin linkers crash on a .debug_line section with no
10220 sequences. Further, merely a DW_LNE_end_sequence entry is not
10221 sufficient -- the address column must also be initialized.
10222 Make sure to output at least one set_address/end_sequence pair,
10223 choosing .text since that section is always present. */
10224 if (text_section_line_info
->in_use
|| !saw_one
)
10225 output_one_line_info_table (text_section_line_info
);
10227 /* Output the marker for the end of the line number info. */
10228 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10231 /* Given a pointer to a tree node for some base type, return a pointer to
10232 a DIE that describes the given type.
10234 This routine must only be called for GCC type nodes that correspond to
10235 Dwarf base (fundamental) types. */
10238 base_type_die (tree type
)
10240 dw_die_ref base_type_result
;
10241 enum dwarf_type encoding
;
10243 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
10246 /* If this is a subtype that should not be emitted as a subrange type,
10247 use the base type. See subrange_type_for_debug_p. */
10248 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
10249 type
= TREE_TYPE (type
);
10251 switch (TREE_CODE (type
))
10254 if ((dwarf_version
>= 4 || !dwarf_strict
)
10255 && TYPE_NAME (type
)
10256 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10257 && DECL_IS_BUILTIN (TYPE_NAME (type
))
10258 && DECL_NAME (TYPE_NAME (type
)))
10260 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
10261 if (strcmp (name
, "char16_t") == 0
10262 || strcmp (name
, "char32_t") == 0)
10264 encoding
= DW_ATE_UTF
;
10268 if (TYPE_STRING_FLAG (type
))
10270 if (TYPE_UNSIGNED (type
))
10271 encoding
= DW_ATE_unsigned_char
;
10273 encoding
= DW_ATE_signed_char
;
10275 else if (TYPE_UNSIGNED (type
))
10276 encoding
= DW_ATE_unsigned
;
10278 encoding
= DW_ATE_signed
;
10282 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
10284 if (dwarf_version
>= 3 || !dwarf_strict
)
10285 encoding
= DW_ATE_decimal_float
;
10287 encoding
= DW_ATE_lo_user
;
10290 encoding
= DW_ATE_float
;
10293 case FIXED_POINT_TYPE
:
10294 if (!(dwarf_version
>= 3 || !dwarf_strict
))
10295 encoding
= DW_ATE_lo_user
;
10296 else if (TYPE_UNSIGNED (type
))
10297 encoding
= DW_ATE_unsigned_fixed
;
10299 encoding
= DW_ATE_signed_fixed
;
10302 /* Dwarf2 doesn't know anything about complex ints, so use
10303 a user defined type for it. */
10305 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
10306 encoding
= DW_ATE_complex_float
;
10308 encoding
= DW_ATE_lo_user
;
10312 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10313 encoding
= DW_ATE_boolean
;
10317 /* No other TREE_CODEs are Dwarf fundamental types. */
10318 gcc_unreachable ();
10321 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die (), type
);
10323 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
10324 int_size_in_bytes (type
));
10325 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
10326 add_pubtype (type
, base_type_result
);
10328 return base_type_result
;
10331 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
10332 named 'auto' in its type: return true for it, false otherwise. */
10335 is_cxx_auto (tree type
)
10339 tree name
= TYPE_IDENTIFIER (type
);
10340 if (name
== get_identifier ("auto")
10341 || name
== get_identifier ("decltype(auto)"))
10347 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10348 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10351 is_base_type (tree type
)
10353 switch (TREE_CODE (type
))
10359 case FIXED_POINT_TYPE
:
10367 case QUAL_UNION_TYPE
:
10368 case ENUMERAL_TYPE
:
10369 case FUNCTION_TYPE
:
10372 case REFERENCE_TYPE
:
10380 if (is_cxx_auto (type
))
10382 gcc_unreachable ();
10388 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10389 node, return the size in bits for the type if it is a constant, or else
10390 return the alignment for the type if the type's size is not constant, or
10391 else return BITS_PER_WORD if the type actually turns out to be an
10392 ERROR_MARK node. */
10394 static inline unsigned HOST_WIDE_INT
10395 simple_type_size_in_bits (const_tree type
)
10397 if (TREE_CODE (type
) == ERROR_MARK
)
10398 return BITS_PER_WORD
;
10399 else if (TYPE_SIZE (type
) == NULL_TREE
)
10401 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
10402 return tree_to_uhwi (TYPE_SIZE (type
));
10404 return TYPE_ALIGN (type
);
10407 /* Similarly, but return an offset_int instead of UHWI. */
10409 static inline offset_int
10410 offset_int_type_size_in_bits (const_tree type
)
10412 if (TREE_CODE (type
) == ERROR_MARK
)
10413 return BITS_PER_WORD
;
10414 else if (TYPE_SIZE (type
) == NULL_TREE
)
10416 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
10417 return wi::to_offset (TYPE_SIZE (type
));
10419 return TYPE_ALIGN (type
);
10422 /* Given a pointer to a tree node for a subrange type, return a pointer
10423 to a DIE that describes the given type. */
10426 subrange_type_die (tree type
, tree low
, tree high
, dw_die_ref context_die
)
10428 dw_die_ref subrange_die
;
10429 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
10431 if (context_die
== NULL
)
10432 context_die
= comp_unit_die ();
10434 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
10436 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
10438 /* The size of the subrange type and its base type do not match,
10439 so we need to generate a size attribute for the subrange type. */
10440 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
10444 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
);
10446 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
);
10448 return subrange_die
;
10451 /* Returns the (const and/or volatile) cv_qualifiers associated with
10452 the decl node. This will normally be augmented with the
10453 cv_qualifiers of the underlying type in add_type_attribute. */
10456 decl_quals (const_tree decl
)
10458 return ((TREE_READONLY (decl
)
10459 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
10460 | (TREE_THIS_VOLATILE (decl
)
10461 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
10464 /* Determine the TYPE whose qualifiers match the largest strict subset
10465 of the given TYPE_QUALS, and return its qualifiers. Ignore all
10466 qualifiers outside QUAL_MASK. */
10469 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
10472 int best_rank
= 0, best_qual
= 0, max_rank
;
10474 type_quals
&= qual_mask
;
10475 max_rank
= popcount_hwi (type_quals
) - 1;
10477 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
10478 t
= TYPE_NEXT_VARIANT (t
))
10480 int q
= TYPE_QUALS (t
) & qual_mask
;
10482 if ((q
& type_quals
) == q
&& q
!= type_quals
10483 && check_base_type (t
, type
))
10485 int rank
= popcount_hwi (q
);
10487 if (rank
> best_rank
)
10498 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10499 entry that chains various modifiers in front of the given type. */
10502 modified_type_die (tree type
, int cv_quals
, dw_die_ref context_die
)
10504 enum tree_code code
= TREE_CODE (type
);
10505 dw_die_ref mod_type_die
;
10506 dw_die_ref sub_die
= NULL
;
10507 tree item_type
= NULL
;
10508 tree qualified_type
;
10509 tree name
, low
, high
;
10510 dw_die_ref mod_scope
;
10511 /* Only these cv-qualifiers are currently handled. */
10512 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
10513 | TYPE_QUAL_RESTRICT
);
10515 if (code
== ERROR_MARK
)
10518 cv_quals
&= cv_qual_mask
;
10520 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
10521 tag modifier (and not an attribute) old consumers won't be able
10523 if (dwarf_version
< 3)
10524 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
10526 /* See if we already have the appropriately qualified variant of
10528 qualified_type
= get_qualified_type (type
, cv_quals
);
10530 if (qualified_type
== sizetype
10531 && TYPE_NAME (qualified_type
)
10532 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
10534 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
10536 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
10537 && TYPE_PRECISION (t
)
10538 == TYPE_PRECISION (qualified_type
)
10539 && TYPE_UNSIGNED (t
)
10540 == TYPE_UNSIGNED (qualified_type
));
10541 qualified_type
= t
;
10544 /* If we do, then we can just use its DIE, if it exists. */
10545 if (qualified_type
)
10547 mod_type_die
= lookup_type_die (qualified_type
);
10549 return mod_type_die
;
10552 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
10554 /* Handle C typedef types. */
10555 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
10556 && !DECL_ARTIFICIAL (name
))
10558 tree dtype
= TREE_TYPE (name
);
10560 if (qualified_type
== dtype
)
10562 /* For a named type, use the typedef. */
10563 gen_type_die (qualified_type
, context_die
);
10564 return lookup_type_die (qualified_type
);
10568 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
10569 dquals
&= cv_qual_mask
;
10570 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
10571 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
10572 /* cv-unqualified version of named type. Just use
10573 the unnamed type to which it refers. */
10574 return modified_type_die (DECL_ORIGINAL_TYPE (name
),
10575 cv_quals
, context_die
);
10576 /* Else cv-qualified version of named type; fall through. */
10580 mod_scope
= scope_die_for (type
, context_die
);
10584 struct qual_info
{ int q
; enum dwarf_tag t
; };
10585 static const struct qual_info qual_info
[] =
10587 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
10588 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
10589 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
10594 /* Determine a lesser qualified type that most closely matches
10595 this one. Then generate DW_TAG_* entries for the remaining
10597 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
10599 mod_type_die
= modified_type_die (type
, sub_quals
, context_die
);
10601 for (i
= 0; i
< sizeof (qual_info
) / sizeof (qual_info
[0]); i
++)
10602 if (qual_info
[i
].q
& cv_quals
& ~sub_quals
)
10604 dw_die_ref d
= new_die (qual_info
[i
].t
, mod_scope
, type
);
10606 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
10610 else if (code
== POINTER_TYPE
)
10612 mod_type_die
= new_die (DW_TAG_pointer_type
, mod_scope
, type
);
10613 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10614 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10615 item_type
= TREE_TYPE (type
);
10616 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10617 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10618 TYPE_ADDR_SPACE (item_type
));
10620 else if (code
== REFERENCE_TYPE
)
10622 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
10623 mod_type_die
= new_die (DW_TAG_rvalue_reference_type
, mod_scope
,
10626 mod_type_die
= new_die (DW_TAG_reference_type
, mod_scope
, type
);
10627 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10628 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10629 item_type
= TREE_TYPE (type
);
10630 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10631 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10632 TYPE_ADDR_SPACE (item_type
));
10634 else if (code
== INTEGER_TYPE
10635 && TREE_TYPE (type
) != NULL_TREE
10636 && subrange_type_for_debug_p (type
, &low
, &high
))
10638 mod_type_die
= subrange_type_die (type
, low
, high
, context_die
);
10639 item_type
= TREE_TYPE (type
);
10641 else if (is_base_type (type
))
10642 mod_type_die
= base_type_die (type
);
10645 gen_type_die (type
, context_die
);
10647 /* We have to get the type_main_variant here (and pass that to the
10648 `lookup_type_die' routine) because the ..._TYPE node we have
10649 might simply be a *copy* of some original type node (where the
10650 copy was created to help us keep track of typedef names) and
10651 that copy might have a different TYPE_UID from the original
10653 if (TREE_CODE (type
) != VECTOR_TYPE
)
10654 return lookup_type_die (type_main_variant (type
));
10656 /* Vectors have the debugging information in the type,
10657 not the main variant. */
10658 return lookup_type_die (type
);
10661 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10662 don't output a DW_TAG_typedef, since there isn't one in the
10663 user's program; just attach a DW_AT_name to the type.
10664 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
10665 if the base type already has the same name. */
10667 && ((TREE_CODE (name
) != TYPE_DECL
10668 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
10669 || (cv_quals
== TYPE_UNQUALIFIED
)))
10670 || (TREE_CODE (name
) == TYPE_DECL
10671 && TREE_TYPE (name
) == qualified_type
10672 && DECL_NAME (name
))))
10674 if (TREE_CODE (name
) == TYPE_DECL
)
10675 /* Could just call add_name_and_src_coords_attributes here,
10676 but since this is a builtin type it doesn't have any
10677 useful source coordinates anyway. */
10678 name
= DECL_NAME (name
);
10679 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
10681 /* This probably indicates a bug. */
10682 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
10684 name
= TYPE_IDENTIFIER (type
);
10685 add_name_attribute (mod_type_die
,
10686 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
10689 if (qualified_type
)
10690 equate_type_number_to_die (qualified_type
, mod_type_die
);
10693 /* We must do this after the equate_type_number_to_die call, in case
10694 this is a recursive type. This ensures that the modified_type_die
10695 recursion will terminate even if the type is recursive. Recursive
10696 types are possible in Ada. */
10697 sub_die
= modified_type_die (item_type
,
10698 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
10701 if (sub_die
!= NULL
)
10702 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
10704 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
10705 if (TYPE_ARTIFICIAL (type
))
10706 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
10708 return mod_type_die
;
10711 /* Generate DIEs for the generic parameters of T.
10712 T must be either a generic type or a generic function.
10713 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10716 gen_generic_params_dies (tree t
)
10720 dw_die_ref die
= NULL
;
10723 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
10727 die
= lookup_type_die (t
);
10728 else if (DECL_P (t
))
10729 die
= lookup_decl_die (t
);
10733 parms
= lang_hooks
.get_innermost_generic_parms (t
);
10735 /* T has no generic parameter. It means T is neither a generic type
10736 or function. End of story. */
10739 parms_num
= TREE_VEC_LENGTH (parms
);
10740 args
= lang_hooks
.get_innermost_generic_args (t
);
10741 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
10742 non_default
= int_cst_value (TREE_CHAIN (args
));
10744 non_default
= TREE_VEC_LENGTH (args
);
10745 for (i
= 0; i
< parms_num
; i
++)
10747 tree parm
, arg
, arg_pack_elems
;
10748 dw_die_ref parm_die
;
10750 parm
= TREE_VEC_ELT (parms
, i
);
10751 arg
= TREE_VEC_ELT (args
, i
);
10752 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
10753 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
10755 if (parm
&& TREE_VALUE (parm
) && arg
)
10757 /* If PARM represents a template parameter pack,
10758 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10759 by DW_TAG_template_*_parameter DIEs for the argument
10760 pack elements of ARG. Note that ARG would then be
10761 an argument pack. */
10762 if (arg_pack_elems
)
10763 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
10767 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
10768 true /* emit name */, die
);
10769 if (i
>= non_default
)
10770 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
10775 /* Create and return a DIE for PARM which should be
10776 the representation of a generic type parameter.
10777 For instance, in the C++ front end, PARM would be a template parameter.
10778 ARG is the argument to PARM.
10779 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10781 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10782 as a child node. */
10785 generic_parameter_die (tree parm
, tree arg
,
10787 dw_die_ref parent_die
)
10789 dw_die_ref tmpl_die
= NULL
;
10790 const char *name
= NULL
;
10792 if (!parm
|| !DECL_NAME (parm
) || !arg
)
10795 /* We support non-type generic parameters and arguments,
10796 type generic parameters and arguments, as well as
10797 generic generic parameters (a.k.a. template template parameters in C++)
10799 if (TREE_CODE (parm
) == PARM_DECL
)
10800 /* PARM is a nontype generic parameter */
10801 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
10802 else if (TREE_CODE (parm
) == TYPE_DECL
)
10803 /* PARM is a type generic parameter. */
10804 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
10805 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10806 /* PARM is a generic generic parameter.
10807 Its DIE is a GNU extension. It shall have a
10808 DW_AT_name attribute to represent the name of the template template
10809 parameter, and a DW_AT_GNU_template_name attribute to represent the
10810 name of the template template argument. */
10811 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
10814 gcc_unreachable ();
10820 /* If PARM is a generic parameter pack, it means we are
10821 emitting debug info for a template argument pack element.
10822 In other terms, ARG is a template argument pack element.
10823 In that case, we don't emit any DW_AT_name attribute for
10827 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
10829 add_AT_string (tmpl_die
, DW_AT_name
, name
);
10832 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10834 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10835 TMPL_DIE should have a child DW_AT_type attribute that is set
10836 to the type of the argument to PARM, which is ARG.
10837 If PARM is a type generic parameter, TMPL_DIE should have a
10838 child DW_AT_type that is set to ARG. */
10839 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
10840 add_type_attribute (tmpl_die
, tmpl_type
,
10841 (TREE_THIS_VOLATILE (tmpl_type
)
10842 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
10847 /* So TMPL_DIE is a DIE representing a
10848 a generic generic template parameter, a.k.a template template
10849 parameter in C++ and arg is a template. */
10851 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10852 to the name of the argument. */
10853 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
10855 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
10858 if (TREE_CODE (parm
) == PARM_DECL
)
10859 /* So PARM is a non-type generic parameter.
10860 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10861 attribute of TMPL_DIE which value represents the value
10863 We must be careful here:
10864 The value of ARG might reference some function decls.
10865 We might currently be emitting debug info for a generic
10866 type and types are emitted before function decls, we don't
10867 know if the function decls referenced by ARG will actually be
10868 emitted after cgraph computations.
10869 So must defer the generation of the DW_AT_const_value to
10870 after cgraph is ready. */
10871 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
10877 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
10878 PARM_PACK must be a template parameter pack. The returned DIE
10879 will be child DIE of PARENT_DIE. */
10882 template_parameter_pack_die (tree parm_pack
,
10883 tree parm_pack_args
,
10884 dw_die_ref parent_die
)
10889 gcc_assert (parent_die
&& parm_pack
);
10891 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
10892 add_name_and_src_coords_attributes (die
, parm_pack
);
10893 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
10894 generic_parameter_die (parm_pack
,
10895 TREE_VEC_ELT (parm_pack_args
, j
),
10896 false /* Don't emit DW_AT_name */,
10901 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10902 an enumerated type. */
10905 type_is_enum (const_tree type
)
10907 return TREE_CODE (type
) == ENUMERAL_TYPE
;
10910 /* Return the DBX register number described by a given RTL node. */
10912 static unsigned int
10913 dbx_reg_number (const_rtx rtl
)
10915 unsigned regno
= REGNO (rtl
);
10917 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
10919 #ifdef LEAF_REG_REMAP
10920 if (crtl
->uses_only_leaf_regs
)
10922 int leaf_reg
= LEAF_REG_REMAP (regno
);
10923 if (leaf_reg
!= -1)
10924 regno
= (unsigned) leaf_reg
;
10928 regno
= DBX_REGISTER_NUMBER (regno
);
10929 gcc_assert (regno
!= INVALID_REGNUM
);
10933 /* Optionally add a DW_OP_piece term to a location description expression.
10934 DW_OP_piece is only added if the location description expression already
10935 doesn't end with DW_OP_piece. */
10938 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
10940 dw_loc_descr_ref loc
;
10942 if (*list_head
!= NULL
)
10944 /* Find the end of the chain. */
10945 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
10948 if (loc
->dw_loc_opc
!= DW_OP_piece
)
10949 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
10953 /* Return a location descriptor that designates a machine register or
10954 zero if there is none. */
10956 static dw_loc_descr_ref
10957 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
10961 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
10964 /* We only use "frame base" when we're sure we're talking about the
10965 post-prologue local stack frame. We do this by *not* running
10966 register elimination until this point, and recognizing the special
10967 argument pointer and soft frame pointer rtx's.
10968 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
10969 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
10970 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
10972 dw_loc_descr_ref result
= NULL
;
10974 if (dwarf_version
>= 4 || !dwarf_strict
)
10976 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
10979 add_loc_descr (&result
,
10980 new_loc_descr (DW_OP_stack_value
, 0, 0));
10985 regs
= targetm
.dwarf_register_span (rtl
);
10987 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1 || regs
)
10988 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
10991 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
10992 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
10994 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
10998 /* Return a location descriptor that designates a machine register for
10999 a given hard register number. */
11001 static dw_loc_descr_ref
11002 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
11004 dw_loc_descr_ref reg_loc_descr
;
11008 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
11010 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
11012 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11013 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11015 return reg_loc_descr
;
11018 /* Given an RTL of a register, return a location descriptor that
11019 designates a value that spans more than one register. */
11021 static dw_loc_descr_ref
11022 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
11023 enum var_init_status initialized
)
11026 dw_loc_descr_ref loc_result
= NULL
;
11028 /* Simple, contiguous registers. */
11029 if (regs
== NULL_RTX
)
11031 unsigned reg
= REGNO (rtl
);
11034 #ifdef LEAF_REG_REMAP
11035 if (crtl
->uses_only_leaf_regs
)
11037 int leaf_reg
= LEAF_REG_REMAP (reg
);
11038 if (leaf_reg
!= -1)
11039 reg
= (unsigned) leaf_reg
;
11043 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
11044 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
11046 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
11051 dw_loc_descr_ref t
;
11053 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
11054 VAR_INIT_STATUS_INITIALIZED
);
11055 add_loc_descr (&loc_result
, t
);
11056 add_loc_descr_op_piece (&loc_result
, size
);
11062 /* Now onto stupid register sets in non contiguous locations. */
11064 gcc_assert (GET_CODE (regs
) == PARALLEL
);
11066 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
11069 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
11071 dw_loc_descr_ref t
;
11073 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
11074 VAR_INIT_STATUS_INITIALIZED
);
11075 add_loc_descr (&loc_result
, t
);
11076 add_loc_descr_op_piece (&loc_result
, size
);
11079 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11080 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11084 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
11086 /* Return a location descriptor that designates a constant i,
11087 as a compound operation from constant (i >> shift), constant shift
11090 static dw_loc_descr_ref
11091 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11093 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
11094 add_loc_descr (&ret
, int_loc_descriptor (shift
));
11095 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
11099 /* Return a location descriptor that designates a constant. */
11101 static dw_loc_descr_ref
11102 int_loc_descriptor (HOST_WIDE_INT i
)
11104 enum dwarf_location_atom op
;
11106 /* Pick the smallest representation of a constant, rather than just
11107 defaulting to the LEB encoding. */
11110 int clz
= clz_hwi (i
);
11111 int ctz
= ctz_hwi (i
);
11113 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
11114 else if (i
<= 0xff)
11115 op
= DW_OP_const1u
;
11116 else if (i
<= 0xffff)
11117 op
= DW_OP_const2u
;
11118 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11119 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11120 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
11121 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
11122 while DW_OP_const4u is 5 bytes. */
11123 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
11124 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11125 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11126 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
11127 while DW_OP_const4u is 5 bytes. */
11128 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11129 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11130 op
= DW_OP_const4u
;
11131 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11132 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11133 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
11134 while DW_OP_constu of constant >= 0x100000000 takes at least
11136 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11137 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11138 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
11139 >= HOST_BITS_PER_WIDE_INT
)
11140 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
11141 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
11142 while DW_OP_constu takes in this case at least 6 bytes. */
11143 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
11144 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11145 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11146 && size_of_uleb128 (i
) > 6)
11147 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
11148 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
11155 op
= DW_OP_const1s
;
11156 else if (i
>= -0x8000)
11157 op
= DW_OP_const2s
;
11158 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11160 if (size_of_int_loc_descriptor (i
) < 5)
11162 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11163 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11166 op
= DW_OP_const4s
;
11170 if (size_of_int_loc_descriptor (i
)
11171 < (unsigned long) 1 + size_of_sleb128 (i
))
11173 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11174 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11181 return new_loc_descr (op
, i
, 0);
11184 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
11185 without actually allocating it. */
11187 static unsigned long
11188 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11190 return size_of_int_loc_descriptor (i
>> shift
)
11191 + size_of_int_loc_descriptor (shift
)
11195 /* Return size_of_locs (int_loc_descriptor (i)) without
11196 actually allocating it. */
11198 static unsigned long
11199 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
11208 else if (i
<= 0xff)
11210 else if (i
<= 0xffff)
11214 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11215 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11216 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11218 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11219 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11220 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11222 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11224 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
11225 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11226 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11227 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11229 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11230 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
11231 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11233 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11234 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11236 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11245 else if (i
>= -0x8000)
11247 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11249 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11251 s
= size_of_int_loc_descriptor (-i
) + 1;
11259 unsigned long r
= 1 + size_of_sleb128 (i
);
11260 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11262 s
= size_of_int_loc_descriptor (-i
) + 1;
11271 /* Return loc description representing "address" of integer value.
11272 This can appear only as toplevel expression. */
11274 static dw_loc_descr_ref
11275 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
11278 dw_loc_descr_ref loc_result
= NULL
;
11280 if (!(dwarf_version
>= 4 || !dwarf_strict
))
11283 litsize
= size_of_int_loc_descriptor (i
);
11284 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11285 is more compact. For DW_OP_stack_value we need:
11286 litsize + 1 (DW_OP_stack_value)
11287 and for DW_OP_implicit_value:
11288 1 (DW_OP_implicit_value) + 1 (length) + size. */
11289 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
11291 loc_result
= int_loc_descriptor (i
);
11292 add_loc_descr (&loc_result
,
11293 new_loc_descr (DW_OP_stack_value
, 0, 0));
11297 loc_result
= new_loc_descr (DW_OP_implicit_value
,
11299 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
11300 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
11304 /* Return a location descriptor that designates a base+offset location. */
11306 static dw_loc_descr_ref
11307 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
11308 enum var_init_status initialized
)
11310 unsigned int regno
;
11311 dw_loc_descr_ref result
;
11312 dw_fde_ref fde
= cfun
->fde
;
11314 /* We only use "frame base" when we're sure we're talking about the
11315 post-prologue local stack frame. We do this by *not* running
11316 register elimination until this point, and recognizing the special
11317 argument pointer and soft frame pointer rtx's. */
11318 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
11320 rtx elim
= (ira_use_lra_p
11321 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
11322 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
11326 if (GET_CODE (elim
) == PLUS
)
11328 offset
+= INTVAL (XEXP (elim
, 1));
11329 elim
= XEXP (elim
, 0);
11331 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
11332 && (elim
== hard_frame_pointer_rtx
11333 || elim
== stack_pointer_rtx
))
11334 || elim
== (frame_pointer_needed
11335 ? hard_frame_pointer_rtx
11336 : stack_pointer_rtx
));
11338 /* If drap register is used to align stack, use frame
11339 pointer + offset to access stack variables. If stack
11340 is aligned without drap, use stack pointer + offset to
11341 access stack variables. */
11342 if (crtl
->stack_realign_tried
11343 && reg
== frame_pointer_rtx
)
11346 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
11347 ? HARD_FRAME_POINTER_REGNUM
11349 return new_reg_loc_descr (base_reg
, offset
);
11352 gcc_assert (frame_pointer_fb_offset_valid
);
11353 offset
+= frame_pointer_fb_offset
;
11354 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11358 regno
= REGNO (reg
);
11359 #ifdef LEAF_REG_REMAP
11360 if (crtl
->uses_only_leaf_regs
)
11362 int leaf_reg
= LEAF_REG_REMAP (regno
);
11363 if (leaf_reg
!= -1)
11364 regno
= (unsigned) leaf_reg
;
11367 regno
= DWARF_FRAME_REGNUM (regno
);
11369 if (!optimize
&& fde
11370 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
))
11372 /* Use cfa+offset to represent the location of arguments passed
11373 on the stack when drap is used to align stack.
11374 Only do this when not optimizing, for optimized code var-tracking
11375 is supposed to track where the arguments live and the register
11376 used as vdrap or drap in some spot might be used for something
11377 else in other part of the routine. */
11378 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11382 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
11385 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
11387 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11388 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11393 /* Return true if this RTL expression describes a base+offset calculation. */
11396 is_based_loc (const_rtx rtl
)
11398 return (GET_CODE (rtl
) == PLUS
11399 && ((REG_P (XEXP (rtl
, 0))
11400 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
11401 && CONST_INT_P (XEXP (rtl
, 1)))));
11404 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11407 static dw_loc_descr_ref
11408 tls_mem_loc_descriptor (rtx mem
)
11411 dw_loc_descr_ref loc_result
;
11413 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
11416 base
= get_base_address (MEM_EXPR (mem
));
11418 || TREE_CODE (base
) != VAR_DECL
11419 || !DECL_THREAD_LOCAL_P (base
))
11422 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1);
11423 if (loc_result
== NULL
)
11426 if (MEM_OFFSET (mem
))
11427 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
11432 /* Output debug info about reason why we failed to expand expression as dwarf
11436 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
11438 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
11440 fprintf (dump_file
, "Failed to expand as dwarf: ");
11442 print_generic_expr (dump_file
, expr
, dump_flags
);
11445 fprintf (dump_file
, "\n");
11446 print_rtl (dump_file
, rtl
);
11448 fprintf (dump_file
, "\nReason: %s\n", reason
);
11452 /* Helper function for const_ok_for_output. */
11455 const_ok_for_output_1 (rtx rtl
)
11457 if (GET_CODE (rtl
) == UNSPEC
)
11459 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
11460 we can't express it in the debug info. */
11461 #ifdef ENABLE_CHECKING
11462 /* Don't complain about TLS UNSPECs, those are just too hard to
11463 delegitimize. Note this could be a non-decl SYMBOL_REF such as
11464 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
11465 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
11466 if (XVECLEN (rtl
, 0) == 0
11467 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
11468 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
)
11469 inform (current_function_decl
11470 ? DECL_SOURCE_LOCATION (current_function_decl
)
11471 : UNKNOWN_LOCATION
,
11472 #if NUM_UNSPEC_VALUES > 0
11473 "non-delegitimized UNSPEC %s (%d) found in variable location",
11474 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
11475 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
11478 "non-delegitimized UNSPEC %d found in variable location",
11482 expansion_failed (NULL_TREE
, rtl
,
11483 "UNSPEC hasn't been delegitimized.\n");
11487 if (targetm
.const_not_ok_for_debug_p (rtl
))
11489 expansion_failed (NULL_TREE
, rtl
,
11490 "Expression rejected for debug by the backend.\n");
11494 /* FIXME: Refer to PR60655. It is possible for simplification
11495 of rtl expressions in var tracking to produce such expressions.
11496 We should really identify / validate expressions
11497 enclosed in CONST that can be handled by assemblers on various
11498 targets and only handle legitimate cases here. */
11499 if (GET_CODE (rtl
) != SYMBOL_REF
)
11501 if (GET_CODE (rtl
) == NOT
)
11506 if (CONSTANT_POOL_ADDRESS_P (rtl
))
11509 get_pool_constant_mark (rtl
, &marked
);
11510 /* If all references to this pool constant were optimized away,
11511 it was not output and thus we can't represent it. */
11514 expansion_failed (NULL_TREE
, rtl
,
11515 "Constant was removed from constant pool.\n");
11520 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
11523 /* Avoid references to external symbols in debug info, on several targets
11524 the linker might even refuse to link when linking a shared library,
11525 and in many other cases the relocations for .debug_info/.debug_loc are
11526 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
11527 to be defined within the same shared library or executable are fine. */
11528 if (SYMBOL_REF_EXTERNAL_P (rtl
))
11530 tree decl
= SYMBOL_REF_DECL (rtl
);
11532 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
11534 expansion_failed (NULL_TREE
, rtl
,
11535 "Symbol not defined in current TU.\n");
11543 /* Return true if constant RTL can be emitted in DW_OP_addr or
11544 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
11545 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
11548 const_ok_for_output (rtx rtl
)
11550 if (GET_CODE (rtl
) == SYMBOL_REF
)
11551 return const_ok_for_output_1 (rtl
);
11553 if (GET_CODE (rtl
) == CONST
)
11555 subrtx_var_iterator::array_type array
;
11556 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
11557 if (!const_ok_for_output_1 (*iter
))
11565 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
11566 if possible, NULL otherwise. */
11569 base_type_for_mode (enum machine_mode mode
, bool unsignedp
)
11571 dw_die_ref type_die
;
11572 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
11576 switch (TREE_CODE (type
))
11584 type_die
= lookup_type_die (type
);
11586 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, comp_unit_die ());
11587 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
11592 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
11593 type matching MODE, or, if MODE is narrower than or as wide as
11594 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
11597 static dw_loc_descr_ref
11598 convert_descriptor_to_mode (enum machine_mode mode
, dw_loc_descr_ref op
)
11600 enum machine_mode outer_mode
= mode
;
11601 dw_die_ref type_die
;
11602 dw_loc_descr_ref cvt
;
11604 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
11606 add_loc_descr (&op
, new_loc_descr (DW_OP_GNU_convert
, 0, 0));
11609 type_die
= base_type_for_mode (outer_mode
, 1);
11610 if (type_die
== NULL
)
11612 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11613 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11614 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11615 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11616 add_loc_descr (&op
, cvt
);
11620 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
11622 static dw_loc_descr_ref
11623 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
11624 dw_loc_descr_ref op1
)
11626 dw_loc_descr_ref ret
= op0
;
11627 add_loc_descr (&ret
, op1
);
11628 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11629 if (STORE_FLAG_VALUE
!= 1)
11631 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
11632 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
11637 /* Return location descriptor for signed comparison OP RTL. */
11639 static dw_loc_descr_ref
11640 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11641 enum machine_mode mem_mode
)
11643 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11644 dw_loc_descr_ref op0
, op1
;
11647 if (op_mode
== VOIDmode
)
11648 op_mode
= GET_MODE (XEXP (rtl
, 1));
11649 if (op_mode
== VOIDmode
)
11653 && (GET_MODE_CLASS (op_mode
) != MODE_INT
11654 || GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
))
11657 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11658 VAR_INIT_STATUS_INITIALIZED
);
11659 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11660 VAR_INIT_STATUS_INITIALIZED
);
11662 if (op0
== NULL
|| op1
== NULL
)
11665 if (GET_MODE_CLASS (op_mode
) != MODE_INT
11666 || GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11667 return compare_loc_descriptor (op
, op0
, op1
);
11669 if (GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11671 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
11672 dw_loc_descr_ref cvt
;
11674 if (type_die
== NULL
)
11676 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11677 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11678 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11679 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11680 add_loc_descr (&op0
, cvt
);
11681 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11682 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11683 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11684 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11685 add_loc_descr (&op1
, cvt
);
11686 return compare_loc_descriptor (op
, op0
, op1
);
11689 shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
11690 /* For eq/ne, if the operands are known to be zero-extended,
11691 there is no need to do the fancy shifting up. */
11692 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
11694 dw_loc_descr_ref last0
, last1
;
11695 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11697 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11699 /* deref_size zero extends, and for constants we can check
11700 whether they are zero extended or not. */
11701 if (((last0
->dw_loc_opc
== DW_OP_deref_size
11702 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11703 || (CONST_INT_P (XEXP (rtl
, 0))
11704 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
11705 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
11706 && ((last1
->dw_loc_opc
== DW_OP_deref_size
11707 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11708 || (CONST_INT_P (XEXP (rtl
, 1))
11709 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
11710 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
11711 return compare_loc_descriptor (op
, op0
, op1
);
11713 /* EQ/NE comparison against constant in narrower type than
11714 DWARF2_ADDR_SIZE can be performed either as
11715 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
11718 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
11719 DW_OP_{eq,ne}. Pick whatever is shorter. */
11720 if (CONST_INT_P (XEXP (rtl
, 1))
11721 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
11722 && (size_of_int_loc_descriptor (shift
) + 1
11723 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
)
11724 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
11725 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11726 & GET_MODE_MASK (op_mode
))))
11728 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
11729 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11730 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11731 & GET_MODE_MASK (op_mode
));
11732 return compare_loc_descriptor (op
, op0
, op1
);
11735 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11736 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11737 if (CONST_INT_P (XEXP (rtl
, 1)))
11738 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
);
11741 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11742 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11744 return compare_loc_descriptor (op
, op0
, op1
);
11747 /* Return location descriptor for unsigned comparison OP RTL. */
11749 static dw_loc_descr_ref
11750 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11751 enum machine_mode mem_mode
)
11753 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11754 dw_loc_descr_ref op0
, op1
;
11756 if (op_mode
== VOIDmode
)
11757 op_mode
= GET_MODE (XEXP (rtl
, 1));
11758 if (op_mode
== VOIDmode
)
11760 if (GET_MODE_CLASS (op_mode
) != MODE_INT
)
11763 if (dwarf_strict
&& GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11766 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11767 VAR_INIT_STATUS_INITIALIZED
);
11768 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11769 VAR_INIT_STATUS_INITIALIZED
);
11771 if (op0
== NULL
|| op1
== NULL
)
11774 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
11776 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
11777 dw_loc_descr_ref last0
, last1
;
11778 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11780 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11782 if (CONST_INT_P (XEXP (rtl
, 0)))
11783 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
11784 /* deref_size zero extends, so no need to mask it again. */
11785 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
11786 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11788 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11789 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11791 if (CONST_INT_P (XEXP (rtl
, 1)))
11792 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
11793 /* deref_size zero extends, so no need to mask it again. */
11794 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
11795 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11797 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11798 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11801 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11803 HOST_WIDE_INT bias
= 1;
11804 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11805 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11806 if (CONST_INT_P (XEXP (rtl
, 1)))
11807 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
11808 + INTVAL (XEXP (rtl
, 1)));
11810 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
11813 return compare_loc_descriptor (op
, op0
, op1
);
11816 /* Return location descriptor for {U,S}{MIN,MAX}. */
11818 static dw_loc_descr_ref
11819 minmax_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11820 enum machine_mode mem_mode
)
11822 enum dwarf_location_atom op
;
11823 dw_loc_descr_ref op0
, op1
, ret
;
11824 dw_loc_descr_ref bra_node
, drop_node
;
11827 && (GET_MODE_CLASS (mode
) != MODE_INT
11828 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
))
11831 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11832 VAR_INIT_STATUS_INITIALIZED
);
11833 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11834 VAR_INIT_STATUS_INITIALIZED
);
11836 if (op0
== NULL
|| op1
== NULL
)
11839 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
11840 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
11841 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
11842 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
11844 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11846 HOST_WIDE_INT mask
= GET_MODE_MASK (mode
);
11847 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11848 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11849 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11850 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11852 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
11854 HOST_WIDE_INT bias
= 1;
11855 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11856 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11857 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11860 else if (GET_MODE_CLASS (mode
) == MODE_INT
11861 && GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11863 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (mode
)) * BITS_PER_UNIT
;
11864 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11865 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11866 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11867 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11869 else if (GET_MODE_CLASS (mode
) == MODE_INT
11870 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11872 dw_die_ref type_die
= base_type_for_mode (mode
, 0);
11873 dw_loc_descr_ref cvt
;
11874 if (type_die
== NULL
)
11876 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11877 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11878 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11879 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11880 add_loc_descr (&op0
, cvt
);
11881 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11882 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11883 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11884 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11885 add_loc_descr (&op1
, cvt
);
11888 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
11893 add_loc_descr (&ret
, op1
);
11894 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11895 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
11896 add_loc_descr (&ret
, bra_node
);
11897 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11898 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
11899 add_loc_descr (&ret
, drop_node
);
11900 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11901 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
11902 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
11903 && GET_MODE_CLASS (mode
) == MODE_INT
11904 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11905 ret
= convert_descriptor_to_mode (mode
, ret
);
11909 /* Helper function for mem_loc_descriptor. Perform OP binary op,
11910 but after converting arguments to type_die, afterwards
11911 convert back to unsigned. */
11913 static dw_loc_descr_ref
11914 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
11915 enum machine_mode mode
, enum machine_mode mem_mode
)
11917 dw_loc_descr_ref cvt
, op0
, op1
;
11919 if (type_die
== NULL
)
11921 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11922 VAR_INIT_STATUS_INITIALIZED
);
11923 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11924 VAR_INIT_STATUS_INITIALIZED
);
11925 if (op0
== NULL
|| op1
== NULL
)
11927 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11928 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11929 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11930 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11931 add_loc_descr (&op0
, cvt
);
11932 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11933 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11934 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11935 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11936 add_loc_descr (&op1
, cvt
);
11937 add_loc_descr (&op0
, op1
);
11938 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
11939 return convert_descriptor_to_mode (mode
, op0
);
11942 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
11943 const0 is DW_OP_lit0 or corresponding typed constant,
11944 const1 is DW_OP_lit1 or corresponding typed constant
11945 and constMSB is constant with just the MSB bit set
11947 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11948 L1: const0 DW_OP_swap
11949 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
11950 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11955 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11956 L1: const0 DW_OP_swap
11957 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11958 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11963 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
11964 L1: const1 DW_OP_swap
11965 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11966 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11970 static dw_loc_descr_ref
11971 clz_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11972 enum machine_mode mem_mode
)
11974 dw_loc_descr_ref op0
, ret
, tmp
;
11975 HOST_WIDE_INT valv
;
11976 dw_loc_descr_ref l1jump
, l1label
;
11977 dw_loc_descr_ref l2jump
, l2label
;
11978 dw_loc_descr_ref l3jump
, l3label
;
11979 dw_loc_descr_ref l4jump
, l4label
;
11982 if (GET_MODE_CLASS (mode
) != MODE_INT
11983 || GET_MODE (XEXP (rtl
, 0)) != mode
)
11986 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11987 VAR_INIT_STATUS_INITIALIZED
);
11991 if (GET_CODE (rtl
) == CLZ
)
11993 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11994 valv
= GET_MODE_BITSIZE (mode
);
11996 else if (GET_CODE (rtl
) == FFS
)
11998 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11999 valv
= GET_MODE_BITSIZE (mode
);
12000 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12001 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12002 add_loc_descr (&ret
, l1jump
);
12003 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
12004 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
12005 VAR_INIT_STATUS_INITIALIZED
);
12008 add_loc_descr (&ret
, tmp
);
12009 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12010 add_loc_descr (&ret
, l4jump
);
12011 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
12012 ? const1_rtx
: const0_rtx
,
12014 VAR_INIT_STATUS_INITIALIZED
);
12015 if (l1label
== NULL
)
12017 add_loc_descr (&ret
, l1label
);
12018 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12019 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
12020 add_loc_descr (&ret
, l2label
);
12021 if (GET_CODE (rtl
) != CLZ
)
12023 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
12024 msb
= GEN_INT ((unsigned HOST_WIDE_INT
) 1
12025 << (GET_MODE_BITSIZE (mode
) - 1));
12027 msb
= immed_wide_int_const
12028 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
12029 GET_MODE_PRECISION (mode
)), mode
);
12030 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
12031 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12032 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
12033 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
12035 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
12036 VAR_INIT_STATUS_INITIALIZED
);
12039 add_loc_descr (&ret
, tmp
);
12040 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12041 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12042 add_loc_descr (&ret
, l3jump
);
12043 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12044 VAR_INIT_STATUS_INITIALIZED
);
12047 add_loc_descr (&ret
, tmp
);
12048 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
12049 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
12050 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12051 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
12052 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12053 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12054 add_loc_descr (&ret
, l2jump
);
12055 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
12056 add_loc_descr (&ret
, l3label
);
12057 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
12058 add_loc_descr (&ret
, l4label
);
12059 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12060 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12061 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12062 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12063 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12064 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
12065 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12066 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
12070 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
12071 const1 is DW_OP_lit1 or corresponding typed constant):
12073 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12074 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12078 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12079 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12082 static dw_loc_descr_ref
12083 popcount_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12084 enum machine_mode mem_mode
)
12086 dw_loc_descr_ref op0
, ret
, tmp
;
12087 dw_loc_descr_ref l1jump
, l1label
;
12088 dw_loc_descr_ref l2jump
, l2label
;
12090 if (GET_MODE_CLASS (mode
) != MODE_INT
12091 || GET_MODE (XEXP (rtl
, 0)) != mode
)
12094 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12095 VAR_INIT_STATUS_INITIALIZED
);
12099 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12100 VAR_INIT_STATUS_INITIALIZED
);
12103 add_loc_descr (&ret
, tmp
);
12104 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12105 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
12106 add_loc_descr (&ret
, l1label
);
12107 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12108 add_loc_descr (&ret
, l2jump
);
12109 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12110 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
12111 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12112 VAR_INIT_STATUS_INITIALIZED
);
12115 add_loc_descr (&ret
, tmp
);
12116 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12117 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
12118 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
12119 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12120 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
12121 VAR_INIT_STATUS_INITIALIZED
);
12122 add_loc_descr (&ret
, tmp
);
12123 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12124 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12125 add_loc_descr (&ret
, l1jump
);
12126 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
12127 add_loc_descr (&ret
, l2label
);
12128 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12129 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12130 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12131 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12135 /* BSWAP (constS is initial shift count, either 56 or 24):
12137 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
12138 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
12139 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
12140 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
12141 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
12143 static dw_loc_descr_ref
12144 bswap_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12145 enum machine_mode mem_mode
)
12147 dw_loc_descr_ref op0
, ret
, tmp
;
12148 dw_loc_descr_ref l1jump
, l1label
;
12149 dw_loc_descr_ref l2jump
, l2label
;
12151 if (GET_MODE_CLASS (mode
) != MODE_INT
12152 || BITS_PER_UNIT
!= 8
12153 || (GET_MODE_BITSIZE (mode
) != 32
12154 && GET_MODE_BITSIZE (mode
) != 64))
12157 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12158 VAR_INIT_STATUS_INITIALIZED
);
12163 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12165 VAR_INIT_STATUS_INITIALIZED
);
12168 add_loc_descr (&ret
, tmp
);
12169 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12170 VAR_INIT_STATUS_INITIALIZED
);
12173 add_loc_descr (&ret
, tmp
);
12174 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
12175 add_loc_descr (&ret
, l1label
);
12176 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12178 VAR_INIT_STATUS_INITIALIZED
);
12179 add_loc_descr (&ret
, tmp
);
12180 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
12181 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12182 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12183 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
12184 VAR_INIT_STATUS_INITIALIZED
);
12187 add_loc_descr (&ret
, tmp
);
12188 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12189 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
12190 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12191 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12192 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12193 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12194 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12195 VAR_INIT_STATUS_INITIALIZED
);
12196 add_loc_descr (&ret
, tmp
);
12197 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
12198 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12199 add_loc_descr (&ret
, l2jump
);
12200 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
12201 VAR_INIT_STATUS_INITIALIZED
);
12202 add_loc_descr (&ret
, tmp
);
12203 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12204 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12205 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12206 add_loc_descr (&ret
, l1jump
);
12207 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
12208 add_loc_descr (&ret
, l2label
);
12209 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12210 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
12211 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12212 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12213 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12214 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12218 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
12219 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12220 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
12221 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
12223 ROTATERT is similar:
12224 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
12225 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12226 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
12228 static dw_loc_descr_ref
12229 rotate_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12230 enum machine_mode mem_mode
)
12232 rtx rtlop1
= XEXP (rtl
, 1);
12233 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
12236 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12239 if (GET_MODE (rtlop1
) != VOIDmode
12240 && GET_MODE_BITSIZE (GET_MODE (rtlop1
)) < GET_MODE_BITSIZE (mode
))
12241 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12242 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12243 VAR_INIT_STATUS_INITIALIZED
);
12244 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12245 VAR_INIT_STATUS_INITIALIZED
);
12246 if (op0
== NULL
|| op1
== NULL
)
12248 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
12249 for (i
= 0; i
< 2; i
++)
12251 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
12252 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
12254 VAR_INIT_STATUS_INITIALIZED
);
12255 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12256 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12258 : HOST_BITS_PER_WIDE_INT
== 64
12259 ? DW_OP_const8u
: DW_OP_constu
,
12260 GET_MODE_MASK (mode
), 0);
12263 if (mask
[i
] == NULL
)
12265 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
12268 add_loc_descr (&ret
, op1
);
12269 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12270 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12271 if (GET_CODE (rtl
) == ROTATERT
)
12273 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12274 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12275 GET_MODE_BITSIZE (mode
), 0));
12277 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12278 if (mask
[0] != NULL
)
12279 add_loc_descr (&ret
, mask
[0]);
12280 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
12281 if (mask
[1] != NULL
)
12283 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12284 add_loc_descr (&ret
, mask
[1]);
12285 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12287 if (GET_CODE (rtl
) == ROTATE
)
12289 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12290 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12291 GET_MODE_BITSIZE (mode
), 0));
12293 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12294 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12298 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
12299 for DEBUG_PARAMETER_REF RTL. */
12301 static dw_loc_descr_ref
12302 parameter_ref_descriptor (rtx rtl
)
12304 dw_loc_descr_ref ret
;
12309 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
12310 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
12311 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
12314 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12315 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
12316 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12320 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
12321 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
12326 /* The following routine converts the RTL for a variable or parameter
12327 (resident in memory) into an equivalent Dwarf representation of a
12328 mechanism for getting the address of that same variable onto the top of a
12329 hypothetical "address evaluation" stack.
12331 When creating memory location descriptors, we are effectively transforming
12332 the RTL for a memory-resident object into its Dwarf postfix expression
12333 equivalent. This routine recursively descends an RTL tree, turning
12334 it into Dwarf postfix code as it goes.
12336 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
12338 MEM_MODE is the mode of the memory reference, needed to handle some
12339 autoincrement addressing modes.
12341 Return 0 if we can't represent the location. */
12344 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12345 enum machine_mode mem_mode
,
12346 enum var_init_status initialized
)
12348 dw_loc_descr_ref mem_loc_result
= NULL
;
12349 enum dwarf_location_atom op
;
12350 dw_loc_descr_ref op0
, op1
;
12351 rtx inner
= NULL_RTX
;
12353 if (mode
== VOIDmode
)
12354 mode
= GET_MODE (rtl
);
12356 /* Note that for a dynamically sized array, the location we will generate a
12357 description of here will be the lowest numbered location which is
12358 actually within the array. That's *not* necessarily the same as the
12359 zeroth element of the array. */
12361 rtl
= targetm
.delegitimize_address (rtl
);
12363 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
12366 switch (GET_CODE (rtl
))
12371 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
12374 /* The case of a subreg may arise when we have a local (register)
12375 variable or a formal (register) parameter which doesn't quite fill
12376 up an entire register. For now, just assume that it is
12377 legitimate to make the Dwarf info refer to the whole register which
12378 contains the given subreg. */
12379 if (!subreg_lowpart_p (rtl
))
12381 inner
= SUBREG_REG (rtl
);
12383 if (inner
== NULL_RTX
)
12384 inner
= XEXP (rtl
, 0);
12385 if (GET_MODE_CLASS (mode
) == MODE_INT
12386 && GET_MODE_CLASS (GET_MODE (inner
)) == MODE_INT
12387 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12388 #ifdef POINTERS_EXTEND_UNSIGNED
12389 || (mode
== Pmode
&& mem_mode
!= VOIDmode
)
12392 && GET_MODE_SIZE (GET_MODE (inner
)) <= DWARF2_ADDR_SIZE
)
12394 mem_loc_result
= mem_loc_descriptor (inner
,
12396 mem_mode
, initialized
);
12401 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (inner
)))
12403 if (GET_MODE_SIZE (mode
) != GET_MODE_SIZE (GET_MODE (inner
))
12404 && (GET_MODE_CLASS (mode
) != MODE_INT
12405 || GET_MODE_CLASS (GET_MODE (inner
)) != MODE_INT
))
12409 dw_die_ref type_die
;
12410 dw_loc_descr_ref cvt
;
12412 mem_loc_result
= mem_loc_descriptor (inner
,
12414 mem_mode
, initialized
);
12415 if (mem_loc_result
== NULL
)
12417 type_die
= base_type_for_mode (mode
,
12418 GET_MODE_CLASS (mode
) == MODE_INT
);
12419 if (type_die
== NULL
)
12421 mem_loc_result
= NULL
;
12424 if (GET_MODE_SIZE (mode
)
12425 != GET_MODE_SIZE (GET_MODE (inner
)))
12426 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12428 cvt
= new_loc_descr (DW_OP_GNU_reinterpret
, 0, 0);
12429 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12430 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12431 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12432 add_loc_descr (&mem_loc_result
, cvt
);
12437 if (GET_MODE_CLASS (mode
) != MODE_INT
12438 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12439 && rtl
!= arg_pointer_rtx
12440 && rtl
!= frame_pointer_rtx
12441 #ifdef POINTERS_EXTEND_UNSIGNED
12442 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12446 dw_die_ref type_die
;
12447 unsigned int dbx_regnum
;
12451 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
12453 type_die
= base_type_for_mode (mode
,
12454 GET_MODE_CLASS (mode
) == MODE_INT
);
12455 if (type_die
== NULL
)
12458 dbx_regnum
= dbx_reg_number (rtl
);
12459 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12461 mem_loc_result
= new_loc_descr (DW_OP_GNU_regval_type
,
12463 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12464 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12465 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12468 /* Whenever a register number forms a part of the description of the
12469 method for calculating the (dynamic) address of a memory resident
12470 object, DWARF rules require the register number be referred to as
12471 a "base register". This distinction is not based in any way upon
12472 what category of register the hardware believes the given register
12473 belongs to. This is strictly DWARF terminology we're dealing with
12474 here. Note that in cases where the location of a memory-resident
12475 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12476 OP_CONST (0)) the actual DWARF location descriptor that we generate
12477 may just be OP_BASEREG (basereg). This may look deceptively like
12478 the object in question was allocated to a register (rather than in
12479 memory) so DWARF consumers need to be aware of the subtle
12480 distinction between OP_REG and OP_BASEREG. */
12481 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
12482 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
12483 else if (stack_realign_drap
12485 && crtl
->args
.internal_arg_pointer
== rtl
12486 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
12488 /* If RTL is internal_arg_pointer, which has been optimized
12489 out, use DRAP instead. */
12490 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
12491 VAR_INIT_STATUS_INITIALIZED
);
12497 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12499 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12500 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12503 else if (GET_CODE (rtl
) == ZERO_EXTEND
12504 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12505 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
12506 < HOST_BITS_PER_WIDE_INT
12507 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
12508 to expand zero extend as two shifts instead of
12510 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= 4)
12512 enum machine_mode imode
= GET_MODE (XEXP (rtl
, 0));
12513 mem_loc_result
= op0
;
12514 add_loc_descr (&mem_loc_result
,
12515 int_loc_descriptor (GET_MODE_MASK (imode
)));
12516 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
12518 else if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12520 int shift
= DWARF2_ADDR_SIZE
12521 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
12522 shift
*= BITS_PER_UNIT
;
12523 if (GET_CODE (rtl
) == SIGN_EXTEND
)
12527 mem_loc_result
= op0
;
12528 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12529 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
12530 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12531 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12533 else if (!dwarf_strict
)
12535 dw_die_ref type_die1
, type_die2
;
12536 dw_loc_descr_ref cvt
;
12538 type_die1
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
12539 GET_CODE (rtl
) == ZERO_EXTEND
);
12540 if (type_die1
== NULL
)
12542 type_die2
= base_type_for_mode (mode
, 1);
12543 if (type_die2
== NULL
)
12545 mem_loc_result
= op0
;
12546 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12547 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12548 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
12549 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12550 add_loc_descr (&mem_loc_result
, cvt
);
12551 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12552 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12553 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
12554 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12555 add_loc_descr (&mem_loc_result
, cvt
);
12561 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
12562 if (new_rtl
!= rtl
)
12564 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
12566 if (mem_loc_result
!= NULL
)
12567 return mem_loc_result
;
12570 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
12571 get_address_mode (rtl
), mode
,
12572 VAR_INIT_STATUS_INITIALIZED
);
12573 if (mem_loc_result
== NULL
)
12574 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
12575 if (mem_loc_result
!= NULL
)
12577 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12578 || GET_MODE_CLASS (mode
) != MODE_INT
)
12580 dw_die_ref type_die
;
12581 dw_loc_descr_ref deref
;
12586 = base_type_for_mode (mode
, GET_MODE_CLASS (mode
) == MODE_INT
);
12587 if (type_die
== NULL
)
12589 deref
= new_loc_descr (DW_OP_GNU_deref_type
,
12590 GET_MODE_SIZE (mode
), 0);
12591 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12592 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12593 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12594 add_loc_descr (&mem_loc_result
, deref
);
12596 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
12597 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
12599 add_loc_descr (&mem_loc_result
,
12600 new_loc_descr (DW_OP_deref_size
,
12601 GET_MODE_SIZE (mode
), 0));
12606 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
12609 /* Some ports can transform a symbol ref into a label ref, because
12610 the symbol ref is too far away and has to be dumped into a constant
12614 if ((GET_MODE_CLASS (mode
) != MODE_INT
12615 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
12616 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12617 #ifdef POINTERS_EXTEND_UNSIGNED
12618 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12622 if (GET_CODE (rtl
) == SYMBOL_REF
12623 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
12625 dw_loc_descr_ref temp
;
12627 /* If this is not defined, we have no way to emit the data. */
12628 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
12631 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
12633 mem_loc_result
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
12634 add_loc_descr (&mem_loc_result
, temp
);
12639 if (!const_ok_for_output (rtl
))
12643 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
12644 vec_safe_push (used_rtx_array
, rtl
);
12650 case DEBUG_IMPLICIT_PTR
:
12651 expansion_failed (NULL_TREE
, rtl
,
12652 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
12658 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
12660 if (GET_MODE_CLASS (mode
) != MODE_INT
12661 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12662 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12663 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12666 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
12667 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12669 op0
= one_reg_loc_descriptor (dbx_regnum
,
12670 VAR_INIT_STATUS_INITIALIZED
);
12673 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
12674 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
12676 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12677 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12678 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
12682 gcc_unreachable ();
12685 mem_loc_result
= new_loc_descr (DW_OP_GNU_entry_value
, 0, 0);
12686 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12687 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
12690 case DEBUG_PARAMETER_REF
:
12691 mem_loc_result
= parameter_ref_descriptor (rtl
);
12695 /* Extract the PLUS expression nested inside and fall into
12696 PLUS code below. */
12697 rtl
= XEXP (rtl
, 1);
12702 /* Turn these into a PLUS expression and fall into the PLUS code
12704 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
12705 gen_int_mode (GET_CODE (rtl
) == PRE_INC
12706 ? GET_MODE_UNIT_SIZE (mem_mode
)
12707 : -GET_MODE_UNIT_SIZE (mem_mode
),
12710 /* ... fall through ... */
12714 if (is_based_loc (rtl
)
12715 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12716 || XEXP (rtl
, 0) == arg_pointer_rtx
12717 || XEXP (rtl
, 0) == frame_pointer_rtx
)
12718 && GET_MODE_CLASS (mode
) == MODE_INT
)
12719 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
12720 INTVAL (XEXP (rtl
, 1)),
12721 VAR_INIT_STATUS_INITIALIZED
);
12724 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12725 VAR_INIT_STATUS_INITIALIZED
);
12726 if (mem_loc_result
== 0)
12729 if (CONST_INT_P (XEXP (rtl
, 1))
12730 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12731 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
12734 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12735 VAR_INIT_STATUS_INITIALIZED
);
12738 add_loc_descr (&mem_loc_result
, op1
);
12739 add_loc_descr (&mem_loc_result
,
12740 new_loc_descr (DW_OP_plus
, 0, 0));
12745 /* If a pseudo-reg is optimized away, it is possible for it to
12746 be replaced with a MEM containing a multiply or shift. */
12757 && GET_MODE_CLASS (mode
) == MODE_INT
12758 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12760 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12761 base_type_for_mode (mode
, 0),
12785 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12787 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12788 VAR_INIT_STATUS_INITIALIZED
);
12790 rtx rtlop1
= XEXP (rtl
, 1);
12791 if (GET_MODE (rtlop1
) != VOIDmode
12792 && GET_MODE_BITSIZE (GET_MODE (rtlop1
))
12793 < GET_MODE_BITSIZE (mode
))
12794 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12795 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12796 VAR_INIT_STATUS_INITIALIZED
);
12799 if (op0
== 0 || op1
== 0)
12802 mem_loc_result
= op0
;
12803 add_loc_descr (&mem_loc_result
, op1
);
12804 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12820 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12821 VAR_INIT_STATUS_INITIALIZED
);
12822 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12823 VAR_INIT_STATUS_INITIALIZED
);
12825 if (op0
== 0 || op1
== 0)
12828 mem_loc_result
= op0
;
12829 add_loc_descr (&mem_loc_result
, op1
);
12830 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12834 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
&& !dwarf_strict
)
12836 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
12837 base_type_for_mode (mode
, 0),
12842 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12843 VAR_INIT_STATUS_INITIALIZED
);
12844 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12845 VAR_INIT_STATUS_INITIALIZED
);
12847 if (op0
== 0 || op1
== 0)
12850 mem_loc_result
= op0
;
12851 add_loc_descr (&mem_loc_result
, op1
);
12852 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12853 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12854 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
12855 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
12856 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
12860 if (!dwarf_strict
&& GET_MODE_CLASS (mode
) == MODE_INT
)
12862 if (GET_MODE_CLASS (mode
) > DWARF2_ADDR_SIZE
)
12867 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12868 base_type_for_mode (mode
, 1),
12886 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12887 VAR_INIT_STATUS_INITIALIZED
);
12892 mem_loc_result
= op0
;
12893 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12897 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12898 #ifdef POINTERS_EXTEND_UNSIGNED
12900 && mem_mode
!= VOIDmode
12901 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
12905 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12909 && (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
12910 || GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_DOUBLE_INT
))
12912 dw_die_ref type_die
= base_type_for_mode (mode
, 1);
12913 enum machine_mode amode
;
12914 if (type_die
== NULL
)
12916 amode
= mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
,
12918 if (INTVAL (rtl
) >= 0
12919 && amode
!= BLKmode
12920 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
12921 /* const DW_OP_GNU_convert <XXX> vs.
12922 DW_OP_GNU_const_type <XXX, 1, const>. */
12923 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
12924 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode
))
12926 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12927 op0
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12928 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12929 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12930 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12931 add_loc_descr (&mem_loc_result
, op0
);
12932 return mem_loc_result
;
12934 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0,
12936 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12937 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12938 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12939 if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12940 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
12943 mem_loc_result
->dw_loc_oprnd2
.val_class
12944 = dw_val_class_const_double
;
12945 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12946 = double_int::from_shwi (INTVAL (rtl
));
12954 dw_die_ref type_die
;
12956 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
12957 CONST_DOUBLE rtx could represent either a large integer
12958 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
12959 the value is always a floating point constant.
12961 When it is an integer, a CONST_DOUBLE is used whenever
12962 the constant requires 2 HWIs to be adequately represented.
12963 We output CONST_DOUBLEs as blocks. */
12964 if (mode
== VOIDmode
12965 || (GET_MODE (rtl
) == VOIDmode
12966 && GET_MODE_BITSIZE (mode
) != HOST_BITS_PER_DOUBLE_INT
))
12968 type_die
= base_type_for_mode (mode
,
12969 GET_MODE_CLASS (mode
) == MODE_INT
);
12970 if (type_die
== NULL
)
12972 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
12973 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12974 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12975 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12976 #if TARGET_SUPPORTS_WIDE_INT == 0
12977 if (!SCALAR_FLOAT_MODE_P (mode
))
12979 mem_loc_result
->dw_loc_oprnd2
.val_class
12980 = dw_val_class_const_double
;
12981 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12982 = rtx_to_double_int (rtl
);
12987 unsigned int length
= GET_MODE_SIZE (mode
);
12988 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
12990 insert_float (rtl
, array
);
12991 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
12992 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
12993 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
12994 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
12999 case CONST_WIDE_INT
:
13002 dw_die_ref type_die
;
13004 type_die
= base_type_for_mode (mode
,
13005 GET_MODE_CLASS (mode
) == MODE_INT
);
13006 if (type_die
== NULL
)
13008 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
13009 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13010 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13011 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13012 mem_loc_result
->dw_loc_oprnd2
.val_class
13013 = dw_val_class_wide_int
;
13014 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_cleared_alloc
<wide_int
> ();
13015 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= std::make_pair (rtl
, mode
);
13020 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
13024 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
13028 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
13032 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
13036 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
13040 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
13044 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
13048 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
13052 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
13056 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
13061 if (GET_MODE_CLASS (mode
) != MODE_INT
)
13066 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
13071 if (CONST_INT_P (XEXP (rtl
, 1))
13072 && CONST_INT_P (XEXP (rtl
, 2))
13073 && ((unsigned) INTVAL (XEXP (rtl
, 1))
13074 + (unsigned) INTVAL (XEXP (rtl
, 2))
13075 <= GET_MODE_BITSIZE (mode
))
13076 && GET_MODE_CLASS (mode
) == MODE_INT
13077 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
13078 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
13081 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
13082 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13085 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
13089 mem_loc_result
= op0
;
13090 size
= INTVAL (XEXP (rtl
, 1));
13091 shift
= INTVAL (XEXP (rtl
, 2));
13092 if (BITS_BIG_ENDIAN
)
13093 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
13095 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
13097 add_loc_descr (&mem_loc_result
,
13098 int_loc_descriptor (DWARF2_ADDR_SIZE
13100 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
13102 if (size
!= (int) DWARF2_ADDR_SIZE
)
13104 add_loc_descr (&mem_loc_result
,
13105 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
13106 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13113 dw_loc_descr_ref op2
, bra_node
, drop_node
;
13114 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
13115 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
13116 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
13117 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13118 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
13119 VAR_INIT_STATUS_INITIALIZED
);
13120 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
13121 VAR_INIT_STATUS_INITIALIZED
);
13122 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
13125 mem_loc_result
= op1
;
13126 add_loc_descr (&mem_loc_result
, op2
);
13127 add_loc_descr (&mem_loc_result
, op0
);
13128 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
13129 add_loc_descr (&mem_loc_result
, bra_node
);
13130 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
13131 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
13132 add_loc_descr (&mem_loc_result
, drop_node
);
13133 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13134 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
13139 case FLOAT_TRUNCATE
:
13141 case UNSIGNED_FLOAT
:
13146 dw_die_ref type_die
;
13147 dw_loc_descr_ref cvt
;
13149 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
13150 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
13153 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl
, 0))) == MODE_INT
13154 && (GET_CODE (rtl
) == FLOAT
13155 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)))
13156 <= DWARF2_ADDR_SIZE
))
13158 type_die
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
13159 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
13160 if (type_die
== NULL
)
13162 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13163 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13164 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13165 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13166 add_loc_descr (&op0
, cvt
);
13168 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
13169 if (type_die
== NULL
)
13171 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13172 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13173 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13174 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13175 add_loc_descr (&op0
, cvt
);
13176 if (GET_MODE_CLASS (mode
) == MODE_INT
13177 && (GET_CODE (rtl
) == FIX
13178 || GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
))
13180 op0
= convert_descriptor_to_mode (mode
, op0
);
13184 mem_loc_result
= op0
;
13191 mem_loc_result
= clz_loc_descriptor (rtl
, mode
, mem_mode
);
13196 mem_loc_result
= popcount_loc_descriptor (rtl
, mode
, mem_mode
);
13200 mem_loc_result
= bswap_loc_descriptor (rtl
, mode
, mem_mode
);
13205 mem_loc_result
= rotate_loc_descriptor (rtl
, mode
, mem_mode
);
13209 /* In theory, we could implement the above. */
13210 /* DWARF cannot represent the unsigned compare operations
13235 case FRACT_CONVERT
:
13236 case UNSIGNED_FRACT_CONVERT
:
13238 case UNSIGNED_SAT_FRACT
:
13244 case VEC_DUPLICATE
:
13248 case STRICT_LOW_PART
:
13253 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13254 can't express it in the debug info. This can happen e.g. with some
13259 resolve_one_addr (&rtl
);
13263 #ifdef ENABLE_CHECKING
13264 print_rtl (stderr
, rtl
);
13265 gcc_unreachable ();
13271 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13272 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13274 return mem_loc_result
;
13277 /* Return a descriptor that describes the concatenation of two locations.
13278 This is typically a complex variable. */
13280 static dw_loc_descr_ref
13281 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
13283 dw_loc_descr_ref cc_loc_result
= NULL
;
13284 dw_loc_descr_ref x0_ref
13285 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13286 dw_loc_descr_ref x1_ref
13287 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13289 if (x0_ref
== 0 || x1_ref
== 0)
13292 cc_loc_result
= x0_ref
;
13293 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
13295 add_loc_descr (&cc_loc_result
, x1_ref
);
13296 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
13298 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13299 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13301 return cc_loc_result
;
13304 /* Return a descriptor that describes the concatenation of N
13307 static dw_loc_descr_ref
13308 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
13311 dw_loc_descr_ref cc_loc_result
= NULL
;
13312 unsigned int n
= XVECLEN (concatn
, 0);
13314 for (i
= 0; i
< n
; ++i
)
13316 dw_loc_descr_ref ref
;
13317 rtx x
= XVECEXP (concatn
, 0, i
);
13319 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13323 add_loc_descr (&cc_loc_result
, ref
);
13324 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
13327 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13328 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13330 return cc_loc_result
;
13333 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
13334 for DEBUG_IMPLICIT_PTR RTL. */
13336 static dw_loc_descr_ref
13337 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
13339 dw_loc_descr_ref ret
;
13344 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
13345 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
13346 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
13347 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
13348 ret
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
13349 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13352 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13353 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
13354 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13358 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
13359 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
13364 /* Output a proper Dwarf location descriptor for a variable or parameter
13365 which is either allocated in a register or in a memory location. For a
13366 register, we just generate an OP_REG and the register number. For a
13367 memory location we provide a Dwarf postfix expression describing how to
13368 generate the (dynamic) address of the object onto the address stack.
13370 MODE is mode of the decl if this loc_descriptor is going to be used in
13371 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13372 allowed, VOIDmode otherwise.
13374 If we don't know how to describe it, return 0. */
13376 static dw_loc_descr_ref
13377 loc_descriptor (rtx rtl
, enum machine_mode mode
,
13378 enum var_init_status initialized
)
13380 dw_loc_descr_ref loc_result
= NULL
;
13382 switch (GET_CODE (rtl
))
13385 /* The case of a subreg may arise when we have a local (register)
13386 variable or a formal (register) parameter which doesn't quite fill
13387 up an entire register. For now, just assume that it is
13388 legitimate to make the Dwarf info refer to the whole register which
13389 contains the given subreg. */
13390 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
13391 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
13392 GET_MODE (SUBREG_REG (rtl
)), initialized
);
13398 loc_result
= reg_loc_descriptor (rtl
, initialized
);
13402 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
13403 GET_MODE (rtl
), initialized
);
13404 if (loc_result
== NULL
)
13405 loc_result
= tls_mem_loc_descriptor (rtl
);
13406 if (loc_result
== NULL
)
13408 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
13409 if (new_rtl
!= rtl
)
13410 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
13415 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
13420 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
13425 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
13427 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
13428 if (GET_CODE (loc
) == EXPR_LIST
)
13429 loc
= XEXP (loc
, 0);
13430 loc_result
= loc_descriptor (loc
, mode
, initialized
);
13434 rtl
= XEXP (rtl
, 1);
13439 rtvec par_elems
= XVEC (rtl
, 0);
13440 int num_elem
= GET_NUM_ELEM (par_elems
);
13441 enum machine_mode mode
;
13444 /* Create the first one, so we have something to add to. */
13445 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
13446 VOIDmode
, initialized
);
13447 if (loc_result
== NULL
)
13449 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
13450 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13451 for (i
= 1; i
< num_elem
; i
++)
13453 dw_loc_descr_ref temp
;
13455 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
13456 VOIDmode
, initialized
);
13459 add_loc_descr (&loc_result
, temp
);
13460 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
13461 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13467 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
13468 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
13473 if (mode
== VOIDmode
)
13474 mode
= GET_MODE (rtl
);
13476 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13478 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13480 /* Note that a CONST_DOUBLE rtx could represent either an integer
13481 or a floating-point constant. A CONST_DOUBLE is used whenever
13482 the constant requires more than one word in order to be
13483 adequately represented. We output CONST_DOUBLEs as blocks. */
13484 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13485 GET_MODE_SIZE (mode
), 0);
13486 #if TARGET_SUPPORTS_WIDE_INT == 0
13487 if (!SCALAR_FLOAT_MODE_P (mode
))
13489 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
13490 loc_result
->dw_loc_oprnd2
.v
.val_double
13491 = rtx_to_double_int (rtl
);
13496 unsigned int length
= GET_MODE_SIZE (mode
);
13497 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
13499 insert_float (rtl
, array
);
13500 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13501 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
13502 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
13503 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13508 case CONST_WIDE_INT
:
13509 if (mode
== VOIDmode
)
13510 mode
= GET_MODE (rtl
);
13512 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13514 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13515 GET_MODE_SIZE (mode
), 0);
13516 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
13517 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_cleared_alloc
<wide_int
> ();
13518 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= std::make_pair (rtl
, mode
);
13523 if (mode
== VOIDmode
)
13524 mode
= GET_MODE (rtl
);
13526 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13528 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
13529 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
13530 unsigned char *array
13531 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
13534 enum machine_mode imode
= GET_MODE_INNER (mode
);
13536 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13537 switch (GET_MODE_CLASS (mode
))
13539 case MODE_VECTOR_INT
:
13540 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13542 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13543 insert_wide_int (std::make_pair (elt
, imode
), p
, elt_size
);
13547 case MODE_VECTOR_FLOAT
:
13548 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13550 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13551 insert_float (elt
, p
);
13556 gcc_unreachable ();
13559 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13560 length
* elt_size
, 0);
13561 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13562 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
13563 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
13564 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13569 if (mode
== VOIDmode
13570 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
13571 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
13572 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
13574 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
13579 if (!const_ok_for_output (rtl
))
13582 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
13583 && (dwarf_version
>= 4 || !dwarf_strict
))
13585 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
13586 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13587 vec_safe_push (used_rtx_array
, rtl
);
13591 case DEBUG_IMPLICIT_PTR
:
13592 loc_result
= implicit_ptr_descriptor (rtl
, 0);
13596 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
13597 && CONST_INT_P (XEXP (rtl
, 1)))
13600 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
13606 if ((GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE (rtl
) == mode
13607 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
13608 && dwarf_version
>= 4)
13609 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
13611 /* Value expression. */
13612 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
13614 add_loc_descr (&loc_result
,
13615 new_loc_descr (DW_OP_stack_value
, 0, 0));
13623 /* We need to figure out what section we should use as the base for the
13624 address ranges where a given location is valid.
13625 1. If this particular DECL has a section associated with it, use that.
13626 2. If this function has a section associated with it, use that.
13627 3. Otherwise, use the text section.
13628 XXX: If you split a variable across multiple sections, we won't notice. */
13630 static const char *
13631 secname_for_decl (const_tree decl
)
13633 const char *secname
;
13635 if (VAR_OR_FUNCTION_DECL_P (decl
)
13636 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
13637 && DECL_SECTION_NAME (decl
))
13638 secname
= DECL_SECTION_NAME (decl
);
13639 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
13640 secname
= DECL_SECTION_NAME (current_function_decl
);
13641 else if (cfun
&& in_cold_section_p
)
13642 secname
= crtl
->subsections
.cold_section_label
;
13644 secname
= text_section_label
;
13649 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13652 decl_by_reference_p (tree decl
)
13654 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
13655 || TREE_CODE (decl
) == VAR_DECL
)
13656 && DECL_BY_REFERENCE (decl
));
13659 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13662 static dw_loc_descr_ref
13663 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
13664 enum var_init_status initialized
)
13666 int have_address
= 0;
13667 dw_loc_descr_ref descr
;
13668 enum machine_mode mode
;
13670 if (want_address
!= 2)
13672 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
13674 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13676 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13677 if (GET_CODE (varloc
) == EXPR_LIST
)
13678 varloc
= XEXP (varloc
, 0);
13679 mode
= GET_MODE (varloc
);
13680 if (MEM_P (varloc
))
13682 rtx addr
= XEXP (varloc
, 0);
13683 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
13684 mode
, initialized
);
13689 rtx x
= avoid_constant_pool_reference (varloc
);
13691 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
13696 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
13703 if (GET_CODE (varloc
) == VAR_LOCATION
)
13704 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
13706 mode
= DECL_MODE (loc
);
13707 descr
= loc_descriptor (varloc
, mode
, initialized
);
13714 if (want_address
== 2 && !have_address
13715 && (dwarf_version
>= 4 || !dwarf_strict
))
13717 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
13719 expansion_failed (loc
, NULL_RTX
,
13720 "DWARF address size mismatch");
13723 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13726 /* Show if we can't fill the request for an address. */
13727 if (want_address
&& !have_address
)
13729 expansion_failed (loc
, NULL_RTX
,
13730 "Want address and only have value");
13734 /* If we've got an address and don't want one, dereference. */
13735 if (!want_address
&& have_address
)
13737 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
13738 enum dwarf_location_atom op
;
13740 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
13742 expansion_failed (loc
, NULL_RTX
,
13743 "DWARF address size mismatch");
13746 else if (size
== DWARF2_ADDR_SIZE
)
13749 op
= DW_OP_deref_size
;
13751 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
13757 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
13758 if it is not possible. */
13760 static dw_loc_descr_ref
13761 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
13763 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
13764 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
13765 else if (dwarf_version
>= 3 || !dwarf_strict
)
13766 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
13771 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13772 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
13774 static dw_loc_descr_ref
13775 dw_sra_loc_expr (tree decl
, rtx loc
)
13778 unsigned int padsize
= 0;
13779 dw_loc_descr_ref descr
, *descr_tail
;
13780 unsigned HOST_WIDE_INT decl_size
;
13782 enum var_init_status initialized
;
13784 if (DECL_SIZE (decl
) == NULL
13785 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
13788 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
13790 descr_tail
= &descr
;
13792 for (p
= loc
; p
; p
= XEXP (p
, 1))
13794 unsigned int bitsize
= decl_piece_bitsize (p
);
13795 rtx loc_note
= *decl_piece_varloc_ptr (p
);
13796 dw_loc_descr_ref cur_descr
;
13797 dw_loc_descr_ref
*tail
, last
= NULL
;
13798 unsigned int opsize
= 0;
13800 if (loc_note
== NULL_RTX
13801 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
13803 padsize
+= bitsize
;
13806 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
13807 varloc
= NOTE_VAR_LOCATION (loc_note
);
13808 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
13809 if (cur_descr
== NULL
)
13811 padsize
+= bitsize
;
13815 /* Check that cur_descr either doesn't use
13816 DW_OP_*piece operations, or their sum is equal
13817 to bitsize. Otherwise we can't embed it. */
13818 for (tail
= &cur_descr
; *tail
!= NULL
;
13819 tail
= &(*tail
)->dw_loc_next
)
13820 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
13822 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
13826 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
13828 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
13832 if (last
!= NULL
&& opsize
!= bitsize
)
13834 padsize
+= bitsize
;
13835 /* Discard the current piece of the descriptor and release any
13836 addr_table entries it uses. */
13837 remove_loc_list_addr_table_entries (cur_descr
);
13841 /* If there is a hole, add DW_OP_*piece after empty DWARF
13842 expression, which means that those bits are optimized out. */
13845 if (padsize
> decl_size
)
13847 remove_loc_list_addr_table_entries (cur_descr
);
13848 goto discard_descr
;
13850 decl_size
-= padsize
;
13851 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
13852 if (*descr_tail
== NULL
)
13854 remove_loc_list_addr_table_entries (cur_descr
);
13855 goto discard_descr
;
13857 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13860 *descr_tail
= cur_descr
;
13862 if (bitsize
> decl_size
)
13863 goto discard_descr
;
13864 decl_size
-= bitsize
;
13867 HOST_WIDE_INT offset
= 0;
13868 if (GET_CODE (varloc
) == VAR_LOCATION
13869 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13871 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13872 if (GET_CODE (varloc
) == EXPR_LIST
)
13873 varloc
= XEXP (varloc
, 0);
13877 if (GET_CODE (varloc
) == CONST
13878 || GET_CODE (varloc
) == SIGN_EXTEND
13879 || GET_CODE (varloc
) == ZERO_EXTEND
)
13880 varloc
= XEXP (varloc
, 0);
13881 else if (GET_CODE (varloc
) == SUBREG
)
13882 varloc
= SUBREG_REG (varloc
);
13887 /* DW_OP_bit_size offset should be zero for register
13888 or implicit location descriptions and empty location
13889 descriptions, but for memory addresses needs big endian
13891 if (MEM_P (varloc
))
13893 unsigned HOST_WIDE_INT memsize
13894 = MEM_SIZE (varloc
) * BITS_PER_UNIT
;
13895 if (memsize
!= bitsize
)
13897 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
13898 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
13899 goto discard_descr
;
13900 if (memsize
< bitsize
)
13901 goto discard_descr
;
13902 if (BITS_BIG_ENDIAN
)
13903 offset
= memsize
- bitsize
;
13907 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
13908 if (*descr_tail
== NULL
)
13909 goto discard_descr
;
13910 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13914 /* If there were any non-empty expressions, add padding till the end of
13916 if (descr
!= NULL
&& decl_size
!= 0)
13918 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
13919 if (*descr_tail
== NULL
)
13920 goto discard_descr
;
13925 /* Discard the descriptor and release any addr_table entries it uses. */
13926 remove_loc_list_addr_table_entries (descr
);
13930 /* Return the dwarf representation of the location list LOC_LIST of
13931 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
13934 static dw_loc_list_ref
13935 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
13937 const char *endname
, *secname
;
13939 enum var_init_status initialized
;
13940 struct var_loc_node
*node
;
13941 dw_loc_descr_ref descr
;
13942 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
13943 dw_loc_list_ref list
= NULL
;
13944 dw_loc_list_ref
*listp
= &list
;
13946 /* Now that we know what section we are using for a base,
13947 actually construct the list of locations.
13948 The first location information is what is passed to the
13949 function that creates the location list, and the remaining
13950 locations just get added on to that list.
13951 Note that we only know the start address for a location
13952 (IE location changes), so to build the range, we use
13953 the range [current location start, next location start].
13954 This means we have to special case the last node, and generate
13955 a range of [last location start, end of function label]. */
13957 secname
= secname_for_decl (decl
);
13959 for (node
= loc_list
->first
; node
; node
= node
->next
)
13960 if (GET_CODE (node
->loc
) == EXPR_LIST
13961 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
13963 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13965 /* This requires DW_OP_{,bit_}piece, which is not usable
13966 inside DWARF expressions. */
13967 if (want_address
!= 2)
13969 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13975 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13976 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13977 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
13981 bool range_across_switch
= false;
13982 /* If section switch happens in between node->label
13983 and node->next->label (or end of function) and
13984 we can't emit it as a single entry list,
13985 emit two ranges, first one ending at the end
13986 of first partition and second one starting at the
13987 beginning of second partition. */
13988 if (node
== loc_list
->last_before_switch
13989 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
13990 && current_function_decl
)
13992 endname
= cfun
->fde
->dw_fde_end
;
13993 range_across_switch
= true;
13995 /* The variable has a location between NODE->LABEL and
13996 NODE->NEXT->LABEL. */
13997 else if (node
->next
)
13998 endname
= node
->next
->label
;
13999 /* If the variable has a location at the last label
14000 it keeps its location until the end of function. */
14001 else if (!current_function_decl
)
14002 endname
= text_end_label
;
14005 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
14006 current_function_funcdef_no
);
14007 endname
= ggc_strdup (label_id
);
14010 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
14011 if (TREE_CODE (decl
) == PARM_DECL
14012 && node
== loc_list
->first
14013 && NOTE_P (node
->loc
)
14014 && strcmp (node
->label
, endname
) == 0)
14015 (*listp
)->force
= true;
14016 listp
= &(*listp
)->dw_loc_next
;
14018 if (range_across_switch
)
14020 if (GET_CODE (node
->loc
) == EXPR_LIST
)
14021 descr
= dw_sra_loc_expr (decl
, node
->loc
);
14024 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
14025 varloc
= NOTE_VAR_LOCATION (node
->loc
);
14026 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
14029 gcc_assert (descr
);
14030 /* The variable has a location between NODE->LABEL and
14031 NODE->NEXT->LABEL. */
14033 endname
= node
->next
->label
;
14035 endname
= cfun
->fde
->dw_fde_second_end
;
14036 *listp
= new_loc_list (descr
,
14037 cfun
->fde
->dw_fde_second_begin
,
14039 listp
= &(*listp
)->dw_loc_next
;
14044 /* Try to avoid the overhead of a location list emitting a location
14045 expression instead, but only if we didn't have more than one
14046 location entry in the first place. If some entries were not
14047 representable, we don't want to pretend a single entry that was
14048 applies to the entire scope in which the variable is
14050 if (list
&& loc_list
->first
->next
)
14056 /* Return if the loc_list has only single element and thus can be represented
14057 as location description. */
14060 single_element_loc_list_p (dw_loc_list_ref list
)
14062 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
14063 return !list
->ll_symbol
;
14066 /* To each location in list LIST add loc descr REF. */
14069 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
14071 dw_loc_descr_ref copy
;
14072 add_loc_descr (&list
->expr
, ref
);
14073 list
= list
->dw_loc_next
;
14076 copy
= ggc_alloc
<dw_loc_descr_node
> ();
14077 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
14078 add_loc_descr (&list
->expr
, copy
);
14079 while (copy
->dw_loc_next
)
14081 dw_loc_descr_ref new_copy
= ggc_alloc
<dw_loc_descr_node
> ();
14082 memcpy (new_copy
, copy
->dw_loc_next
, sizeof (dw_loc_descr_node
));
14083 copy
->dw_loc_next
= new_copy
;
14086 list
= list
->dw_loc_next
;
14090 /* Given two lists RET and LIST
14091 produce location list that is result of adding expression in LIST
14092 to expression in RET on each position in program.
14093 Might be destructive on both RET and LIST.
14095 TODO: We handle only simple cases of RET or LIST having at most one
14096 element. General case would inolve sorting the lists in program order
14097 and merging them that will need some additional work.
14098 Adding that will improve quality of debug info especially for SRA-ed
14102 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
14111 if (!list
->dw_loc_next
)
14113 add_loc_descr_to_each (*ret
, list
->expr
);
14116 if (!(*ret
)->dw_loc_next
)
14118 add_loc_descr_to_each (list
, (*ret
)->expr
);
14122 expansion_failed (NULL_TREE
, NULL_RTX
,
14123 "Don't know how to merge two non-trivial"
14124 " location lists.\n");
14129 /* LOC is constant expression. Try a luck, look it up in constant
14130 pool and return its loc_descr of its address. */
14132 static dw_loc_descr_ref
14133 cst_pool_loc_descr (tree loc
)
14135 /* Get an RTL for this, if something has been emitted. */
14136 rtx rtl
= lookup_constant_def (loc
);
14138 if (!rtl
|| !MEM_P (rtl
))
14143 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
14145 /* TODO: We might get more coverage if we was actually delaying expansion
14146 of all expressions till end of compilation when constant pools are fully
14148 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
14150 expansion_failed (loc
, NULL_RTX
,
14151 "CST value in contant pool but not marked.");
14154 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
14155 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
14158 /* Return dw_loc_list representing address of addr_expr LOC
14159 by looking for inner INDIRECT_REF expression and turning
14160 it into simple arithmetics. */
14162 static dw_loc_list_ref
14163 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
)
14166 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14167 enum machine_mode mode
;
14168 int unsignedp
, volatilep
= 0;
14169 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14171 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
14172 &bitsize
, &bitpos
, &offset
, &mode
,
14173 &unsignedp
, &volatilep
, false);
14175 if (bitpos
% BITS_PER_UNIT
)
14177 expansion_failed (loc
, NULL_RTX
, "bitfield access");
14180 if (!INDIRECT_REF_P (obj
))
14182 expansion_failed (obj
,
14183 NULL_RTX
, "no indirect ref in inner refrence");
14186 if (!offset
&& !bitpos
)
14187 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1);
14189 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
14190 && (dwarf_version
>= 4 || !dwarf_strict
))
14192 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0);
14197 /* Variable offset. */
14198 list_ret1
= loc_list_from_tree (offset
, 0);
14199 if (list_ret1
== 0)
14201 add_loc_list (&list_ret
, list_ret1
);
14204 add_loc_descr_to_each (list_ret
,
14205 new_loc_descr (DW_OP_plus
, 0, 0));
14207 bytepos
= bitpos
/ BITS_PER_UNIT
;
14209 add_loc_descr_to_each (list_ret
,
14210 new_loc_descr (DW_OP_plus_uconst
,
14212 else if (bytepos
< 0)
14213 loc_list_plus_const (list_ret
, bytepos
);
14214 add_loc_descr_to_each (list_ret
,
14215 new_loc_descr (DW_OP_stack_value
, 0, 0));
14221 /* Generate Dwarf location list representing LOC.
14222 If WANT_ADDRESS is false, expression computing LOC will be computed
14223 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14224 if WANT_ADDRESS is 2, expression computing address useable in location
14225 will be returned (i.e. DW_OP_reg can be used
14226 to refer to register values). */
14228 static dw_loc_list_ref
14229 loc_list_from_tree (tree loc
, int want_address
)
14231 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
14232 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14233 int have_address
= 0;
14234 enum dwarf_location_atom op
;
14236 /* ??? Most of the time we do not take proper care for sign/zero
14237 extending the values properly. Hopefully this won't be a real
14240 switch (TREE_CODE (loc
))
14243 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
14246 case PLACEHOLDER_EXPR
:
14247 /* This case involves extracting fields from an object to determine the
14248 position of other fields. We don't try to encode this here. The
14249 only user of this is Ada, which encodes the needed information using
14250 the names of types. */
14251 expansion_failed (loc
, NULL_RTX
, "PLACEHOLDER_EXPR");
14255 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
14256 /* There are no opcodes for these operations. */
14259 case PREINCREMENT_EXPR
:
14260 case PREDECREMENT_EXPR
:
14261 case POSTINCREMENT_EXPR
:
14262 case POSTDECREMENT_EXPR
:
14263 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
14264 /* There are no opcodes for these operations. */
14268 /* If we already want an address, see if there is INDIRECT_REF inside
14269 e.g. for &this->field. */
14272 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
14273 (loc
, want_address
== 2);
14276 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
14277 && (ret
= cst_pool_loc_descr (loc
)))
14280 /* Otherwise, process the argument and look for the address. */
14281 if (!list_ret
&& !ret
)
14282 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 1);
14286 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
14292 if (DECL_THREAD_LOCAL_P (loc
))
14295 enum dwarf_location_atom tls_op
;
14296 enum dtprel_bool dtprel
= dtprel_false
;
14298 if (targetm
.have_tls
)
14300 /* If this is not defined, we have no way to emit the
14302 if (!targetm
.asm_out
.output_dwarf_dtprel
)
14305 /* The way DW_OP_GNU_push_tls_address is specified, we
14306 can only look up addresses of objects in the current
14307 module. We used DW_OP_addr as first op, but that's
14308 wrong, because DW_OP_addr is relocated by the debug
14309 info consumer, while DW_OP_GNU_push_tls_address
14310 operand shouldn't be. */
14311 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
14313 dtprel
= dtprel_true
;
14314 tls_op
= DW_OP_GNU_push_tls_address
;
14318 if (!targetm
.emutls
.debug_form_tls_address
14319 || !(dwarf_version
>= 3 || !dwarf_strict
))
14321 /* We stuffed the control variable into the DECL_VALUE_EXPR
14322 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
14323 no longer appear in gimple code. We used the control
14324 variable in specific so that we could pick it up here. */
14325 loc
= DECL_VALUE_EXPR (loc
);
14326 tls_op
= DW_OP_form_tls_address
;
14329 rtl
= rtl_for_decl_location (loc
);
14330 if (rtl
== NULL_RTX
)
14335 rtl
= XEXP (rtl
, 0);
14336 if (! CONSTANT_P (rtl
))
14339 ret
= new_addr_loc_descr (rtl
, dtprel
);
14340 ret1
= new_loc_descr (tls_op
, 0, 0);
14341 add_loc_descr (&ret
, ret1
);
14350 if (DECL_HAS_VALUE_EXPR_P (loc
))
14351 return loc_list_from_tree (DECL_VALUE_EXPR (loc
),
14355 case FUNCTION_DECL
:
14358 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
14360 if (loc_list
&& loc_list
->first
)
14362 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
14363 have_address
= want_address
!= 0;
14366 rtl
= rtl_for_decl_location (loc
);
14367 if (rtl
== NULL_RTX
)
14369 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
14372 else if (CONST_INT_P (rtl
))
14374 HOST_WIDE_INT val
= INTVAL (rtl
);
14375 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14376 val
&= GET_MODE_MASK (DECL_MODE (loc
));
14377 ret
= int_loc_descriptor (val
);
14379 else if (GET_CODE (rtl
) == CONST_STRING
)
14381 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
14384 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
14385 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
14388 enum machine_mode mode
, mem_mode
;
14390 /* Certain constructs can only be represented at top-level. */
14391 if (want_address
== 2)
14393 ret
= loc_descriptor (rtl
, VOIDmode
,
14394 VAR_INIT_STATUS_INITIALIZED
);
14399 mode
= GET_MODE (rtl
);
14400 mem_mode
= VOIDmode
;
14404 mode
= get_address_mode (rtl
);
14405 rtl
= XEXP (rtl
, 0);
14408 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
14409 VAR_INIT_STATUS_INITIALIZED
);
14412 expansion_failed (loc
, rtl
,
14413 "failed to produce loc descriptor for rtl");
14419 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
14426 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14430 case TARGET_MEM_REF
:
14434 case COMPOUND_EXPR
:
14435 return loc_list_from_tree (TREE_OPERAND (loc
, 1), want_address
);
14438 case VIEW_CONVERT_EXPR
:
14441 return loc_list_from_tree (TREE_OPERAND (loc
, 0), want_address
);
14443 case COMPONENT_REF
:
14444 case BIT_FIELD_REF
:
14446 case ARRAY_RANGE_REF
:
14447 case REALPART_EXPR
:
14448 case IMAGPART_EXPR
:
14451 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14452 enum machine_mode mode
;
14453 int unsignedp
, volatilep
= 0;
14455 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
14456 &unsignedp
, &volatilep
, false);
14458 gcc_assert (obj
!= loc
);
14460 list_ret
= loc_list_from_tree (obj
,
14462 && !bitpos
&& !offset
? 2 : 1);
14463 /* TODO: We can extract value of the small expression via shifting even
14464 for nonzero bitpos. */
14467 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
14469 expansion_failed (loc
, NULL_RTX
,
14470 "bitfield access");
14474 if (offset
!= NULL_TREE
)
14476 /* Variable offset. */
14477 list_ret1
= loc_list_from_tree (offset
, 0);
14478 if (list_ret1
== 0)
14480 add_loc_list (&list_ret
, list_ret1
);
14483 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
14486 bytepos
= bitpos
/ BITS_PER_UNIT
;
14488 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
14489 else if (bytepos
< 0)
14490 loc_list_plus_const (list_ret
, bytepos
);
14497 if ((want_address
|| !tree_fits_shwi_p (loc
))
14498 && (ret
= cst_pool_loc_descr (loc
)))
14500 else if (want_address
== 2
14501 && tree_fits_shwi_p (loc
)
14502 && (ret
= address_of_int_loc_descriptor
14503 (int_size_in_bytes (TREE_TYPE (loc
)),
14504 tree_to_shwi (loc
))))
14506 else if (tree_fits_shwi_p (loc
))
14507 ret
= int_loc_descriptor (tree_to_shwi (loc
));
14510 expansion_failed (loc
, NULL_RTX
,
14511 "Integer operand is not host integer");
14520 if ((ret
= cst_pool_loc_descr (loc
)))
14523 /* We can construct small constants here using int_loc_descriptor. */
14524 expansion_failed (loc
, NULL_RTX
,
14525 "constructor or constant not in constant pool");
14528 case TRUTH_AND_EXPR
:
14529 case TRUTH_ANDIF_EXPR
:
14534 case TRUTH_XOR_EXPR
:
14539 case TRUTH_OR_EXPR
:
14540 case TRUTH_ORIF_EXPR
:
14545 case FLOOR_DIV_EXPR
:
14546 case CEIL_DIV_EXPR
:
14547 case ROUND_DIV_EXPR
:
14548 case TRUNC_DIV_EXPR
:
14549 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14558 case FLOOR_MOD_EXPR
:
14559 case CEIL_MOD_EXPR
:
14560 case ROUND_MOD_EXPR
:
14561 case TRUNC_MOD_EXPR
:
14562 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14567 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14568 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14569 if (list_ret
== 0 || list_ret1
== 0)
14572 add_loc_list (&list_ret
, list_ret1
);
14575 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14576 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14577 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
14578 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14579 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14591 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
14594 case POINTER_PLUS_EXPR
:
14597 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
14599 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14603 loc_list_plus_const (list_ret
, tree_to_shwi (TREE_OPERAND (loc
, 1)));
14611 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14618 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14625 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14632 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14647 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14648 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14649 if (list_ret
== 0 || list_ret1
== 0)
14652 add_loc_list (&list_ret
, list_ret1
);
14655 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14658 case TRUTH_NOT_EXPR
:
14672 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14676 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14682 const enum tree_code code
=
14683 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
14685 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
14686 build2 (code
, integer_type_node
,
14687 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
14688 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
14691 /* ... fall through ... */
14695 dw_loc_descr_ref lhs
14696 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
14697 dw_loc_list_ref rhs
14698 = loc_list_from_tree (TREE_OPERAND (loc
, 2), 0);
14699 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
14701 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14702 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
14705 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14706 add_loc_descr_to_each (list_ret
, bra_node
);
14708 add_loc_list (&list_ret
, rhs
);
14709 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14710 add_loc_descr_to_each (list_ret
, jump_node
);
14712 add_loc_descr_to_each (list_ret
, lhs
);
14713 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14714 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
14716 /* ??? Need a node to point the skip at. Use a nop. */
14717 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14718 add_loc_descr_to_each (list_ret
, tmp
);
14719 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14720 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14724 case FIX_TRUNC_EXPR
:
14728 /* Leave front-end specific codes as simply unknown. This comes
14729 up, for instance, with the C STMT_EXPR. */
14730 if ((unsigned int) TREE_CODE (loc
)
14731 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
14733 expansion_failed (loc
, NULL_RTX
,
14734 "language specific tree node");
14738 #ifdef ENABLE_CHECKING
14739 /* Otherwise this is a generic code; we should just lists all of
14740 these explicitly. We forgot one. */
14741 gcc_unreachable ();
14743 /* In a release build, we want to degrade gracefully: better to
14744 generate incomplete debugging information than to crash. */
14749 if (!ret
&& !list_ret
)
14752 if (want_address
== 2 && !have_address
14753 && (dwarf_version
>= 4 || !dwarf_strict
))
14755 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
14757 expansion_failed (loc
, NULL_RTX
,
14758 "DWARF address size mismatch");
14762 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14764 add_loc_descr_to_each (list_ret
,
14765 new_loc_descr (DW_OP_stack_value
, 0, 0));
14768 /* Show if we can't fill the request for an address. */
14769 if (want_address
&& !have_address
)
14771 expansion_failed (loc
, NULL_RTX
,
14772 "Want address and only have value");
14776 gcc_assert (!ret
|| !list_ret
);
14778 /* If we've got an address and don't want one, dereference. */
14779 if (!want_address
&& have_address
)
14781 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
14783 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
14785 expansion_failed (loc
, NULL_RTX
,
14786 "DWARF address size mismatch");
14789 else if (size
== DWARF2_ADDR_SIZE
)
14792 op
= DW_OP_deref_size
;
14795 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
14797 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
14800 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
14805 /* Same as above but return only single location expression. */
14806 static dw_loc_descr_ref
14807 loc_descriptor_from_tree (tree loc
, int want_address
)
14809 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
);
14812 if (ret
->dw_loc_next
)
14814 expansion_failed (loc
, NULL_RTX
,
14815 "Location list where only loc descriptor needed");
14821 /* Given a value, round it up to the lowest multiple of `boundary'
14822 which is not less than the value itself. */
14824 static inline HOST_WIDE_INT
14825 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
14827 return (((value
+ boundary
- 1) / boundary
) * boundary
);
14830 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
14831 pointer to the declared type for the relevant field variable, or return
14832 `integer_type_node' if the given node turns out to be an
14833 ERROR_MARK node. */
14836 field_type (const_tree decl
)
14840 if (TREE_CODE (decl
) == ERROR_MARK
)
14841 return integer_type_node
;
14843 type
= DECL_BIT_FIELD_TYPE (decl
);
14844 if (type
== NULL_TREE
)
14845 type
= TREE_TYPE (decl
);
14850 /* Given a pointer to a tree node, return the alignment in bits for
14851 it, or else return BITS_PER_WORD if the node actually turns out to
14852 be an ERROR_MARK node. */
14854 static inline unsigned
14855 simple_type_align_in_bits (const_tree type
)
14857 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
14860 static inline unsigned
14861 simple_decl_align_in_bits (const_tree decl
)
14863 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
14866 /* Return the result of rounding T up to ALIGN. */
14868 static inline offset_int
14869 round_up_to_align (const offset_int
&t
, unsigned int align
)
14871 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
14874 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
14875 lowest addressed byte of the "containing object" for the given FIELD_DECL,
14876 or return 0 if we are unable to determine what that offset is, either
14877 because the argument turns out to be a pointer to an ERROR_MARK node, or
14878 because the offset is actually variable. (We can't handle the latter case
14881 static HOST_WIDE_INT
14882 field_byte_offset (const_tree decl
)
14884 offset_int object_offset_in_bits
;
14885 offset_int object_offset_in_bytes
;
14886 offset_int bitpos_int
;
14888 if (TREE_CODE (decl
) == ERROR_MARK
)
14891 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
14893 /* We cannot yet cope with fields whose positions are variable, so
14894 for now, when we see such things, we simply return 0. Someday, we may
14895 be able to handle such cases, but it will be damn difficult. */
14896 if (TREE_CODE (bit_position (decl
)) != INTEGER_CST
)
14899 bitpos_int
= wi::to_offset (bit_position (decl
));
14901 #ifdef PCC_BITFIELD_TYPE_MATTERS
14902 if (PCC_BITFIELD_TYPE_MATTERS
)
14905 tree field_size_tree
;
14906 offset_int deepest_bitpos
;
14907 offset_int field_size_in_bits
;
14908 unsigned int type_align_in_bits
;
14909 unsigned int decl_align_in_bits
;
14910 offset_int type_size_in_bits
;
14912 type
= field_type (decl
);
14913 type_size_in_bits
= offset_int_type_size_in_bits (type
);
14914 type_align_in_bits
= simple_type_align_in_bits (type
);
14916 field_size_tree
= DECL_SIZE (decl
);
14918 /* The size could be unspecified if there was an error, or for
14919 a flexible array member. */
14920 if (!field_size_tree
)
14921 field_size_tree
= bitsize_zero_node
;
14923 /* If the size of the field is not constant, use the type size. */
14924 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
14925 field_size_in_bits
= wi::to_offset (field_size_tree
);
14927 field_size_in_bits
= type_size_in_bits
;
14929 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
14931 /* The GCC front-end doesn't make any attempt to keep track of the
14932 starting bit offset (relative to the start of the containing
14933 structure type) of the hypothetical "containing object" for a
14934 bit-field. Thus, when computing the byte offset value for the
14935 start of the "containing object" of a bit-field, we must deduce
14936 this information on our own. This can be rather tricky to do in
14937 some cases. For example, handling the following structure type
14938 definition when compiling for an i386/i486 target (which only
14939 aligns long long's to 32-bit boundaries) can be very tricky:
14941 struct S { int field1; long long field2:31; };
14943 Fortunately, there is a simple rule-of-thumb which can be used
14944 in such cases. When compiling for an i386/i486, GCC will
14945 allocate 8 bytes for the structure shown above. It decides to
14946 do this based upon one simple rule for bit-field allocation.
14947 GCC allocates each "containing object" for each bit-field at
14948 the first (i.e. lowest addressed) legitimate alignment boundary
14949 (based upon the required minimum alignment for the declared
14950 type of the field) which it can possibly use, subject to the
14951 condition that there is still enough available space remaining
14952 in the containing object (when allocated at the selected point)
14953 to fully accommodate all of the bits of the bit-field itself.
14955 This simple rule makes it obvious why GCC allocates 8 bytes for
14956 each object of the structure type shown above. When looking
14957 for a place to allocate the "containing object" for `field2',
14958 the compiler simply tries to allocate a 64-bit "containing
14959 object" at each successive 32-bit boundary (starting at zero)
14960 until it finds a place to allocate that 64- bit field such that
14961 at least 31 contiguous (and previously unallocated) bits remain
14962 within that selected 64 bit field. (As it turns out, for the
14963 example above, the compiler finds it is OK to allocate the
14964 "containing object" 64-bit field at bit-offset zero within the
14967 Here we attempt to work backwards from the limited set of facts
14968 we're given, and we try to deduce from those facts, where GCC
14969 must have believed that the containing object started (within
14970 the structure type). The value we deduce is then used (by the
14971 callers of this routine) to generate DW_AT_location and
14972 DW_AT_bit_offset attributes for fields (both bit-fields and, in
14973 the case of DW_AT_location, regular fields as well). */
14975 /* Figure out the bit-distance from the start of the structure to
14976 the "deepest" bit of the bit-field. */
14977 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
14979 /* This is the tricky part. Use some fancy footwork to deduce
14980 where the lowest addressed bit of the containing object must
14982 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14984 /* Round up to type_align by default. This works best for
14986 object_offset_in_bits
14987 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
14989 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
14991 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14993 /* Round up to decl_align instead. */
14994 object_offset_in_bits
14995 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
14999 #endif /* PCC_BITFIELD_TYPE_MATTERS */
15000 object_offset_in_bits
= bitpos_int
;
15002 object_offset_in_bytes
15003 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
15004 return object_offset_in_bytes
.to_shwi ();
15007 /* The following routines define various Dwarf attributes and any data
15008 associated with them. */
15010 /* Add a location description attribute value to a DIE.
15012 This emits location attributes suitable for whole variables and
15013 whole parameters. Note that the location attributes for struct fields are
15014 generated by the routine `data_member_location_attribute' below. */
15017 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
15018 dw_loc_list_ref descr
)
15022 if (single_element_loc_list_p (descr
))
15023 add_AT_loc (die
, attr_kind
, descr
->expr
);
15025 add_AT_loc_list (die
, attr_kind
, descr
);
15028 /* Add DW_AT_accessibility attribute to DIE if needed. */
15031 add_accessibility_attribute (dw_die_ref die
, tree decl
)
15033 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
15034 children, otherwise the default is DW_ACCESS_public. In DWARF2
15035 the default has always been DW_ACCESS_public. */
15036 if (TREE_PROTECTED (decl
))
15037 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
15038 else if (TREE_PRIVATE (decl
))
15040 if (dwarf_version
== 2
15041 || die
->die_parent
== NULL
15042 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
15043 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
15045 else if (dwarf_version
> 2
15047 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
15048 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
15051 /* Attach the specialized form of location attribute used for data members of
15052 struct and union types. In the special case of a FIELD_DECL node which
15053 represents a bit-field, the "offset" part of this special location
15054 descriptor must indicate the distance in bytes from the lowest-addressed
15055 byte of the containing struct or union type to the lowest-addressed byte of
15056 the "containing object" for the bit-field. (See the `field_byte_offset'
15059 For any given bit-field, the "containing object" is a hypothetical object
15060 (of some integral or enum type) within which the given bit-field lives. The
15061 type of this hypothetical "containing object" is always the same as the
15062 declared type of the individual bit-field itself (for GCC anyway... the
15063 DWARF spec doesn't actually mandate this). Note that it is the size (in
15064 bytes) of the hypothetical "containing object" which will be given in the
15065 DW_AT_byte_size attribute for this bit-field. (See the
15066 `byte_size_attribute' function below.) It is also used when calculating the
15067 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15068 function below.) */
15071 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
15073 HOST_WIDE_INT offset
;
15074 dw_loc_descr_ref loc_descr
= 0;
15076 if (TREE_CODE (decl
) == TREE_BINFO
)
15078 /* We're working on the TAG_inheritance for a base class. */
15079 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
15081 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15082 aren't at a fixed offset from all (sub)objects of the same
15083 type. We need to extract the appropriate offset from our
15084 vtable. The following dwarf expression means
15086 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15088 This is specific to the V3 ABI, of course. */
15090 dw_loc_descr_ref tmp
;
15092 /* Make a copy of the object address. */
15093 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
15094 add_loc_descr (&loc_descr
, tmp
);
15096 /* Extract the vtable address. */
15097 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
15098 add_loc_descr (&loc_descr
, tmp
);
15100 /* Calculate the address of the offset. */
15101 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
15102 gcc_assert (offset
< 0);
15104 tmp
= int_loc_descriptor (-offset
);
15105 add_loc_descr (&loc_descr
, tmp
);
15106 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
15107 add_loc_descr (&loc_descr
, tmp
);
15109 /* Extract the offset. */
15110 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
15111 add_loc_descr (&loc_descr
, tmp
);
15113 /* Add it to the object address. */
15114 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
15115 add_loc_descr (&loc_descr
, tmp
);
15118 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
15121 offset
= field_byte_offset (decl
);
15125 if (dwarf_version
> 2)
15127 /* Don't need to output a location expression, just the constant. */
15129 add_AT_int (die
, DW_AT_data_member_location
, offset
);
15131 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
15136 enum dwarf_location_atom op
;
15138 /* The DWARF2 standard says that we should assume that the structure
15139 address is already on the stack, so we can specify a structure
15140 field address by using DW_OP_plus_uconst. */
15141 op
= DW_OP_plus_uconst
;
15142 loc_descr
= new_loc_descr (op
, offset
, 0);
15146 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
15149 /* Writes integer values to dw_vec_const array. */
15152 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
15156 *dest
++ = val
& 0xff;
15162 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15164 static HOST_WIDE_INT
15165 extract_int (const unsigned char *src
, unsigned int size
)
15167 HOST_WIDE_INT val
= 0;
15173 val
|= *--src
& 0xff;
15179 /* Writes wide_int values to dw_vec_const array. */
15182 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
15186 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
15188 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
15192 /* We'd have to extend this code to support odd sizes. */
15193 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
15195 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
15197 if (WORDS_BIG_ENDIAN
)
15198 for (i
= n
- 1; i
>= 0; i
--)
15200 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
15201 dest
+= sizeof (HOST_WIDE_INT
);
15204 for (i
= 0; i
< n
; i
++)
15206 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
15207 dest
+= sizeof (HOST_WIDE_INT
);
15211 /* Writes floating point values to dw_vec_const array. */
15214 insert_float (const_rtx rtl
, unsigned char *array
)
15216 REAL_VALUE_TYPE rv
;
15220 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
15221 real_to_target (val
, &rv
, GET_MODE (rtl
));
15223 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15224 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
15226 insert_int (val
[i
], 4, array
);
15231 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15232 does not have a "location" either in memory or in a register. These
15233 things can arise in GNU C when a constant is passed as an actual parameter
15234 to an inlined function. They can also arise in C++ where declared
15235 constants do not necessarily get memory "homes". */
15238 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
15240 switch (GET_CODE (rtl
))
15244 HOST_WIDE_INT val
= INTVAL (rtl
);
15247 add_AT_int (die
, DW_AT_const_value
, val
);
15249 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
15253 case CONST_WIDE_INT
:
15254 add_AT_wide (die
, DW_AT_const_value
,
15255 std::make_pair (rtl
, GET_MODE (rtl
)));
15259 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15260 floating-point constant. A CONST_DOUBLE is used whenever the
15261 constant requires more than one word in order to be adequately
15264 enum machine_mode mode
= GET_MODE (rtl
);
15266 if (TARGET_SUPPORTS_WIDE_INT
== 0 && !SCALAR_FLOAT_MODE_P (mode
))
15267 add_AT_double (die
, DW_AT_const_value
,
15268 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
15271 unsigned int length
= GET_MODE_SIZE (mode
);
15272 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
15274 insert_float (rtl
, array
);
15275 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
15282 enum machine_mode mode
= GET_MODE (rtl
);
15283 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
15284 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
15285 unsigned char *array
15286 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
15289 enum machine_mode imode
= GET_MODE_INNER (mode
);
15291 switch (GET_MODE_CLASS (mode
))
15293 case MODE_VECTOR_INT
:
15294 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15296 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15297 insert_wide_int (std::make_pair (elt
, imode
), p
, elt_size
);
15301 case MODE_VECTOR_FLOAT
:
15302 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15304 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15305 insert_float (elt
, p
);
15310 gcc_unreachable ();
15313 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
15318 if (dwarf_version
>= 4 || !dwarf_strict
)
15320 dw_loc_descr_ref loc_result
;
15321 resolve_one_addr (&rtl
);
15323 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15324 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
15325 add_AT_loc (die
, DW_AT_location
, loc_result
);
15326 vec_safe_push (used_rtx_array
, rtl
);
15332 if (CONSTANT_P (XEXP (rtl
, 0)))
15333 return add_const_value_attribute (die
, XEXP (rtl
, 0));
15336 if (!const_ok_for_output (rtl
))
15339 if (dwarf_version
>= 4 || !dwarf_strict
)
15344 /* In cases where an inlined instance of an inline function is passed
15345 the address of an `auto' variable (which is local to the caller) we
15346 can get a situation where the DECL_RTL of the artificial local
15347 variable (for the inlining) which acts as a stand-in for the
15348 corresponding formal parameter (of the inline function) will look
15349 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15350 exactly a compile-time constant expression, but it isn't the address
15351 of the (artificial) local variable either. Rather, it represents the
15352 *value* which the artificial local variable always has during its
15353 lifetime. We currently have no way to represent such quasi-constant
15354 values in Dwarf, so for now we just punt and generate nothing. */
15362 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
15363 && MEM_READONLY_P (rtl
)
15364 && GET_MODE (rtl
) == BLKmode
)
15366 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
15372 /* No other kinds of rtx should be possible here. */
15373 gcc_unreachable ();
15378 /* Determine whether the evaluation of EXPR references any variables
15379 or functions which aren't otherwise used (and therefore may not be
15382 reference_to_unused (tree
* tp
, int * walk_subtrees
,
15383 void * data ATTRIBUTE_UNUSED
)
15385 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
15386 *walk_subtrees
= 0;
15388 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
15389 && ! TREE_ASM_WRITTEN (*tp
))
15391 /* ??? The C++ FE emits debug information for using decls, so
15392 putting gcc_unreachable here falls over. See PR31899. For now
15393 be conservative. */
15394 else if (!symtab
->global_info_ready
15395 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
15397 else if (TREE_CODE (*tp
) == VAR_DECL
)
15399 varpool_node
*node
= varpool_node::get (*tp
);
15400 if (!node
|| !node
->definition
)
15403 else if (TREE_CODE (*tp
) == FUNCTION_DECL
15404 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
15406 /* The call graph machinery must have finished analyzing,
15407 optimizing and gimplifying the CU by now.
15408 So if *TP has no call graph node associated
15409 to it, it means *TP will not be emitted. */
15410 if (!cgraph_node::get (*tp
))
15413 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
15419 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15420 for use in a later add_const_value_attribute call. */
15423 rtl_for_decl_init (tree init
, tree type
)
15425 rtx rtl
= NULL_RTX
;
15429 /* If a variable is initialized with a string constant without embedded
15430 zeros, build CONST_STRING. */
15431 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
15433 tree enttype
= TREE_TYPE (type
);
15434 tree domain
= TYPE_DOMAIN (type
);
15435 enum machine_mode mode
= TYPE_MODE (enttype
);
15437 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
15439 && integer_zerop (TYPE_MIN_VALUE (domain
))
15440 && compare_tree_int (TYPE_MAX_VALUE (domain
),
15441 TREE_STRING_LENGTH (init
) - 1) == 0
15442 && ((size_t) TREE_STRING_LENGTH (init
)
15443 == strlen (TREE_STRING_POINTER (init
)) + 1))
15445 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
15446 ggc_strdup (TREE_STRING_POINTER (init
)));
15447 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
15448 MEM_READONLY_P (rtl
) = 1;
15451 /* Other aggregates, and complex values, could be represented using
15453 else if (AGGREGATE_TYPE_P (type
)
15454 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
15455 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
15456 || TREE_CODE (type
) == COMPLEX_TYPE
)
15458 /* Vectors only work if their mode is supported by the target.
15459 FIXME: generic vectors ought to work too. */
15460 else if (TREE_CODE (type
) == VECTOR_TYPE
15461 && !VECTOR_MODE_P (TYPE_MODE (type
)))
15463 /* If the initializer is something that we know will expand into an
15464 immediate RTL constant, expand it now. We must be careful not to
15465 reference variables which won't be output. */
15466 else if (initializer_constant_valid_p (init
, type
)
15467 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
15469 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15471 if (TREE_CODE (type
) == VECTOR_TYPE
)
15472 switch (TREE_CODE (init
))
15477 if (TREE_CONSTANT (init
))
15479 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
15480 bool constant_p
= true;
15482 unsigned HOST_WIDE_INT ix
;
15484 /* Even when ctor is constant, it might contain non-*_CST
15485 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15486 belong into VECTOR_CST nodes. */
15487 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
15488 if (!CONSTANT_CLASS_P (value
))
15490 constant_p
= false;
15496 init
= build_vector_from_ctor (type
, elts
);
15506 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
15508 /* If expand_expr returns a MEM, it wasn't immediate. */
15509 gcc_assert (!rtl
|| !MEM_P (rtl
));
15515 /* Generate RTL for the variable DECL to represent its location. */
15518 rtl_for_decl_location (tree decl
)
15522 /* Here we have to decide where we are going to say the parameter "lives"
15523 (as far as the debugger is concerned). We only have a couple of
15524 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15526 DECL_RTL normally indicates where the parameter lives during most of the
15527 activation of the function. If optimization is enabled however, this
15528 could be either NULL or else a pseudo-reg. Both of those cases indicate
15529 that the parameter doesn't really live anywhere (as far as the code
15530 generation parts of GCC are concerned) during most of the function's
15531 activation. That will happen (for example) if the parameter is never
15532 referenced within the function.
15534 We could just generate a location descriptor here for all non-NULL
15535 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15536 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15537 where DECL_RTL is NULL or is a pseudo-reg.
15539 Note however that we can only get away with using DECL_INCOMING_RTL as
15540 a backup substitute for DECL_RTL in certain limited cases. In cases
15541 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15542 we can be sure that the parameter was passed using the same type as it is
15543 declared to have within the function, and that its DECL_INCOMING_RTL
15544 points us to a place where a value of that type is passed.
15546 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15547 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15548 because in these cases DECL_INCOMING_RTL points us to a value of some
15549 type which is *different* from the type of the parameter itself. Thus,
15550 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15551 such cases, the debugger would end up (for example) trying to fetch a
15552 `float' from a place which actually contains the first part of a
15553 `double'. That would lead to really incorrect and confusing
15554 output at debug-time.
15556 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15557 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15558 are a couple of exceptions however. On little-endian machines we can
15559 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15560 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15561 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15562 when (on a little-endian machine) a non-prototyped function has a
15563 parameter declared to be of type `short' or `char'. In such cases,
15564 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15565 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15566 passed `int' value. If the debugger then uses that address to fetch
15567 a `short' or a `char' (on a little-endian machine) the result will be
15568 the correct data, so we allow for such exceptional cases below.
15570 Note that our goal here is to describe the place where the given formal
15571 parameter lives during most of the function's activation (i.e. between the
15572 end of the prologue and the start of the epilogue). We'll do that as best
15573 as we can. Note however that if the given formal parameter is modified
15574 sometime during the execution of the function, then a stack backtrace (at
15575 debug-time) will show the function as having been called with the *new*
15576 value rather than the value which was originally passed in. This happens
15577 rarely enough that it is not a major problem, but it *is* a problem, and
15578 I'd like to fix it.
15580 A future version of dwarf2out.c may generate two additional attributes for
15581 any given DW_TAG_formal_parameter DIE which will describe the "passed
15582 type" and the "passed location" for the given formal parameter in addition
15583 to the attributes we now generate to indicate the "declared type" and the
15584 "active location" for each parameter. This additional set of attributes
15585 could be used by debuggers for stack backtraces. Separately, note that
15586 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15587 This happens (for example) for inlined-instances of inline function formal
15588 parameters which are never referenced. This really shouldn't be
15589 happening. All PARM_DECL nodes should get valid non-NULL
15590 DECL_INCOMING_RTL values. FIXME. */
15592 /* Use DECL_RTL as the "location" unless we find something better. */
15593 rtl
= DECL_RTL_IF_SET (decl
);
15595 /* When generating abstract instances, ignore everything except
15596 constants, symbols living in memory, and symbols living in
15597 fixed registers. */
15598 if (! reload_completed
)
15601 && (CONSTANT_P (rtl
)
15603 && CONSTANT_P (XEXP (rtl
, 0)))
15605 && TREE_CODE (decl
) == VAR_DECL
15606 && TREE_STATIC (decl
))))
15608 rtl
= targetm
.delegitimize_address (rtl
);
15613 else if (TREE_CODE (decl
) == PARM_DECL
)
15615 if (rtl
== NULL_RTX
15616 || is_pseudo_reg (rtl
)
15618 && is_pseudo_reg (XEXP (rtl
, 0))
15619 && DECL_INCOMING_RTL (decl
)
15620 && MEM_P (DECL_INCOMING_RTL (decl
))
15621 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
15623 tree declared_type
= TREE_TYPE (decl
);
15624 tree passed_type
= DECL_ARG_TYPE (decl
);
15625 enum machine_mode dmode
= TYPE_MODE (declared_type
);
15626 enum machine_mode pmode
= TYPE_MODE (passed_type
);
15628 /* This decl represents a formal parameter which was optimized out.
15629 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15630 all cases where (rtl == NULL_RTX) just below. */
15631 if (dmode
== pmode
)
15632 rtl
= DECL_INCOMING_RTL (decl
);
15633 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
15634 && SCALAR_INT_MODE_P (dmode
)
15635 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
15636 && DECL_INCOMING_RTL (decl
))
15638 rtx inc
= DECL_INCOMING_RTL (decl
);
15641 else if (MEM_P (inc
))
15643 if (BYTES_BIG_ENDIAN
)
15644 rtl
= adjust_address_nv (inc
, dmode
,
15645 GET_MODE_SIZE (pmode
)
15646 - GET_MODE_SIZE (dmode
));
15653 /* If the parm was passed in registers, but lives on the stack, then
15654 make a big endian correction if the mode of the type of the
15655 parameter is not the same as the mode of the rtl. */
15656 /* ??? This is the same series of checks that are made in dbxout.c before
15657 we reach the big endian correction code there. It isn't clear if all
15658 of these checks are necessary here, but keeping them all is the safe
15660 else if (MEM_P (rtl
)
15661 && XEXP (rtl
, 0) != const0_rtx
15662 && ! CONSTANT_P (XEXP (rtl
, 0))
15663 /* Not passed in memory. */
15664 && !MEM_P (DECL_INCOMING_RTL (decl
))
15665 /* Not passed by invisible reference. */
15666 && (!REG_P (XEXP (rtl
, 0))
15667 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
15668 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
15669 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
15670 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
15673 /* Big endian correction check. */
15674 && BYTES_BIG_ENDIAN
15675 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
15676 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
15679 enum machine_mode addr_mode
= get_address_mode (rtl
);
15680 int offset
= (UNITS_PER_WORD
15681 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
15683 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15684 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
15687 else if (TREE_CODE (decl
) == VAR_DECL
15690 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
15691 && BYTES_BIG_ENDIAN
)
15693 enum machine_mode addr_mode
= get_address_mode (rtl
);
15694 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
15695 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
15697 /* If a variable is declared "register" yet is smaller than
15698 a register, then if we store the variable to memory, it
15699 looks like we're storing a register-sized value, when in
15700 fact we are not. We need to adjust the offset of the
15701 storage location to reflect the actual value's bytes,
15702 else gdb will not be able to display it. */
15704 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15705 plus_constant (addr_mode
, XEXP (rtl
, 0),
15709 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15710 and will have been substituted directly into all expressions that use it.
15711 C does not have such a concept, but C++ and other languages do. */
15712 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
15713 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
15716 rtl
= targetm
.delegitimize_address (rtl
);
15718 /* If we don't look past the constant pool, we risk emitting a
15719 reference to a constant pool entry that isn't referenced from
15720 code, and thus is not emitted. */
15722 rtl
= avoid_constant_pool_reference (rtl
);
15724 /* Try harder to get a rtl. If this symbol ends up not being emitted
15725 in the current CU, resolve_addr will remove the expression referencing
15727 if (rtl
== NULL_RTX
15728 && TREE_CODE (decl
) == VAR_DECL
15729 && !DECL_EXTERNAL (decl
)
15730 && TREE_STATIC (decl
)
15731 && DECL_NAME (decl
)
15732 && !DECL_HARD_REGISTER (decl
)
15733 && DECL_MODE (decl
) != VOIDmode
)
15735 rtl
= make_decl_rtl_for_debug (decl
);
15737 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
15738 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
15745 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15746 returned. If so, the decl for the COMMON block is returned, and the
15747 value is the offset into the common block for the symbol. */
15750 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
15752 tree val_expr
, cvar
;
15753 enum machine_mode mode
;
15754 HOST_WIDE_INT bitsize
, bitpos
;
15756 int unsignedp
, volatilep
= 0;
15758 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15759 it does not have a value (the offset into the common area), or if it
15760 is thread local (as opposed to global) then it isn't common, and shouldn't
15761 be handled as such. */
15762 if (TREE_CODE (decl
) != VAR_DECL
15763 || !TREE_STATIC (decl
)
15764 || !DECL_HAS_VALUE_EXPR_P (decl
)
15768 val_expr
= DECL_VALUE_EXPR (decl
);
15769 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
15772 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
,
15773 &mode
, &unsignedp
, &volatilep
, true);
15775 if (cvar
== NULL_TREE
15776 || TREE_CODE (cvar
) != VAR_DECL
15777 || DECL_ARTIFICIAL (cvar
)
15778 || !TREE_PUBLIC (cvar
))
15782 if (offset
!= NULL
)
15784 if (!tree_fits_shwi_p (offset
))
15786 *value
= tree_to_shwi (offset
);
15789 *value
+= bitpos
/ BITS_PER_UNIT
;
15794 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
15795 data attribute for a variable or a parameter. We generate the
15796 DW_AT_const_value attribute only in those cases where the given variable
15797 or parameter does not have a true "location" either in memory or in a
15798 register. This can happen (for example) when a constant is passed as an
15799 actual argument in a call to an inline function. (It's possible that
15800 these things can crop up in other ways also.) Note that one type of
15801 constant value which can be passed into an inlined function is a constant
15802 pointer. This can happen for example if an actual argument in an inlined
15803 function call evaluates to a compile-time constant address.
15805 CACHE_P is true if it is worth caching the location list for DECL,
15806 so that future calls can reuse it rather than regenerate it from scratch.
15807 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
15808 since we will need to refer to them each time the function is inlined. */
15811 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
,
15812 enum dwarf_attribute attr
)
15815 dw_loc_list_ref list
;
15816 var_loc_list
*loc_list
;
15817 cached_dw_loc_list
*cache
;
15820 if (TREE_CODE (decl
) == ERROR_MARK
)
15823 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
15824 || TREE_CODE (decl
) == RESULT_DECL
);
15826 /* Try to get some constant RTL for this decl, and use that as the value of
15829 rtl
= rtl_for_decl_location (decl
);
15830 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15831 && add_const_value_attribute (die
, rtl
))
15834 /* See if we have single element location list that is equivalent to
15835 a constant value. That way we are better to use add_const_value_attribute
15836 rather than expanding constant value equivalent. */
15837 loc_list
= lookup_decl_loc (decl
);
15840 && loc_list
->first
->next
== NULL
15841 && NOTE_P (loc_list
->first
->loc
)
15842 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
15843 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
15845 struct var_loc_node
*node
;
15847 node
= loc_list
->first
;
15848 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
15849 if (GET_CODE (rtl
) == EXPR_LIST
)
15850 rtl
= XEXP (rtl
, 0);
15851 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15852 && add_const_value_attribute (die
, rtl
))
15855 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
15856 list several times. See if we've already cached the contents. */
15858 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
15862 cache
= (cached_dw_loc_list
*)
15863 htab_find_with_hash (cached_dw_loc_list_table
, decl
, DECL_UID (decl
));
15865 list
= cache
->loc_list
;
15869 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2);
15870 /* It is usually worth caching this result if the decl is from
15871 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
15872 if (cache_p
&& list
&& list
->dw_loc_next
)
15874 slot
= htab_find_slot_with_hash (cached_dw_loc_list_table
, decl
,
15875 DECL_UID (decl
), INSERT
);
15876 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
15877 cache
->decl_id
= DECL_UID (decl
);
15878 cache
->loc_list
= list
;
15884 add_AT_location_description (die
, attr
, list
);
15887 /* None of that worked, so it must not really have a location;
15888 try adding a constant value attribute from the DECL_INITIAL. */
15889 return tree_add_const_value_attribute_for_decl (die
, decl
);
15892 /* Add VARIABLE and DIE into deferred locations list. */
15895 defer_location (tree variable
, dw_die_ref die
)
15897 deferred_locations entry
;
15898 entry
.variable
= variable
;
15900 vec_safe_push (deferred_locations_list
, entry
);
15903 /* Helper function for tree_add_const_value_attribute. Natively encode
15904 initializer INIT into an array. Return true if successful. */
15907 native_encode_initializer (tree init
, unsigned char *array
, int size
)
15911 if (init
== NULL_TREE
)
15915 switch (TREE_CODE (init
))
15918 type
= TREE_TYPE (init
);
15919 if (TREE_CODE (type
) == ARRAY_TYPE
)
15921 tree enttype
= TREE_TYPE (type
);
15922 enum machine_mode mode
= TYPE_MODE (enttype
);
15924 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
15926 if (int_size_in_bytes (type
) != size
)
15928 if (size
> TREE_STRING_LENGTH (init
))
15930 memcpy (array
, TREE_STRING_POINTER (init
),
15931 TREE_STRING_LENGTH (init
));
15932 memset (array
+ TREE_STRING_LENGTH (init
),
15933 '\0', size
- TREE_STRING_LENGTH (init
));
15936 memcpy (array
, TREE_STRING_POINTER (init
), size
);
15941 type
= TREE_TYPE (init
);
15942 if (int_size_in_bytes (type
) != size
)
15944 if (TREE_CODE (type
) == ARRAY_TYPE
)
15946 HOST_WIDE_INT min_index
;
15947 unsigned HOST_WIDE_INT cnt
;
15948 int curpos
= 0, fieldsize
;
15949 constructor_elt
*ce
;
15951 if (TYPE_DOMAIN (type
) == NULL_TREE
15952 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
15955 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
15956 if (fieldsize
<= 0)
15959 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
15960 memset (array
, '\0', size
);
15961 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15963 tree val
= ce
->value
;
15964 tree index
= ce
->index
;
15966 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15967 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
15970 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
15975 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
15978 curpos
= pos
+ fieldsize
;
15979 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15981 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
15982 - tree_to_shwi (TREE_OPERAND (index
, 0));
15983 while (count
-- > 0)
15986 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
15987 curpos
+= fieldsize
;
15990 gcc_assert (curpos
<= size
);
15994 else if (TREE_CODE (type
) == RECORD_TYPE
15995 || TREE_CODE (type
) == UNION_TYPE
)
15997 tree field
= NULL_TREE
;
15998 unsigned HOST_WIDE_INT cnt
;
15999 constructor_elt
*ce
;
16001 if (int_size_in_bytes (type
) != size
)
16004 if (TREE_CODE (type
) == RECORD_TYPE
)
16005 field
= TYPE_FIELDS (type
);
16007 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
16009 tree val
= ce
->value
;
16010 int pos
, fieldsize
;
16012 if (ce
->index
!= 0)
16018 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
16021 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
16022 && TYPE_DOMAIN (TREE_TYPE (field
))
16023 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
16025 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
16026 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
16028 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
16029 pos
= int_byte_position (field
);
16030 gcc_assert (pos
+ fieldsize
<= size
);
16032 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
16038 case VIEW_CONVERT_EXPR
:
16039 case NON_LVALUE_EXPR
:
16040 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
16042 return native_encode_expr (init
, array
, size
) == size
;
16046 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16047 attribute is the const value T. */
16050 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
16053 tree type
= TREE_TYPE (t
);
16056 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
16060 gcc_assert (!DECL_P (init
));
16062 rtl
= rtl_for_decl_init (init
, type
);
16064 return add_const_value_attribute (die
, rtl
);
16065 /* If the host and target are sane, try harder. */
16066 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
16067 && initializer_constant_valid_p (init
, type
))
16069 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
16070 if (size
> 0 && (int) size
== size
)
16072 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
16074 if (native_encode_initializer (init
, array
, size
))
16076 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
16085 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16086 attribute is the const value of T, where T is an integral constant
16087 variable with static storage duration
16088 (so it can't be a PARM_DECL or a RESULT_DECL). */
16091 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
16095 || (TREE_CODE (decl
) != VAR_DECL
16096 && TREE_CODE (decl
) != CONST_DECL
)
16097 || (TREE_CODE (decl
) == VAR_DECL
16098 && !TREE_STATIC (decl
)))
16101 if (TREE_READONLY (decl
)
16102 && ! TREE_THIS_VOLATILE (decl
)
16103 && DECL_INITIAL (decl
))
16108 /* Don't add DW_AT_const_value if abstract origin already has one. */
16109 if (get_AT (var_die
, DW_AT_const_value
))
16112 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
16115 /* Convert the CFI instructions for the current function into a
16116 location list. This is used for DW_AT_frame_base when we targeting
16117 a dwarf2 consumer that does not support the dwarf3
16118 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16121 static dw_loc_list_ref
16122 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
16126 dw_loc_list_ref list
, *list_tail
;
16128 dw_cfa_location last_cfa
, next_cfa
;
16129 const char *start_label
, *last_label
, *section
;
16130 dw_cfa_location remember
;
16133 gcc_assert (fde
!= NULL
);
16135 section
= secname_for_decl (current_function_decl
);
16139 memset (&next_cfa
, 0, sizeof (next_cfa
));
16140 next_cfa
.reg
= INVALID_REGNUM
;
16141 remember
= next_cfa
;
16143 start_label
= fde
->dw_fde_begin
;
16145 /* ??? Bald assumption that the CIE opcode list does not contain
16146 advance opcodes. */
16147 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
16148 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16150 last_cfa
= next_cfa
;
16151 last_label
= start_label
;
16153 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
16155 /* If the first partition contained no CFI adjustments, the
16156 CIE opcodes apply to the whole first partition. */
16157 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16158 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
16159 list_tail
=&(*list_tail
)->dw_loc_next
;
16160 start_label
= last_label
= fde
->dw_fde_second_begin
;
16163 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
16165 switch (cfi
->dw_cfi_opc
)
16167 case DW_CFA_set_loc
:
16168 case DW_CFA_advance_loc1
:
16169 case DW_CFA_advance_loc2
:
16170 case DW_CFA_advance_loc4
:
16171 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16173 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16174 start_label
, last_label
, section
);
16176 list_tail
= &(*list_tail
)->dw_loc_next
;
16177 last_cfa
= next_cfa
;
16178 start_label
= last_label
;
16180 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
16183 case DW_CFA_advance_loc
:
16184 /* The encoding is complex enough that we should never emit this. */
16185 gcc_unreachable ();
16188 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16191 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
16193 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16195 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16196 start_label
, last_label
, section
);
16198 list_tail
= &(*list_tail
)->dw_loc_next
;
16199 last_cfa
= next_cfa
;
16200 start_label
= last_label
;
16202 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16203 start_label
, fde
->dw_fde_end
, section
);
16204 list_tail
= &(*list_tail
)->dw_loc_next
;
16205 start_label
= last_label
= fde
->dw_fde_second_begin
;
16209 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16211 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16212 start_label
, last_label
, section
);
16213 list_tail
= &(*list_tail
)->dw_loc_next
;
16214 start_label
= last_label
;
16217 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
16219 fde
->dw_fde_second_begin
16220 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
16223 if (list
&& list
->dw_loc_next
)
16229 /* Compute a displacement from the "steady-state frame pointer" to the
16230 frame base (often the same as the CFA), and store it in
16231 frame_pointer_fb_offset. OFFSET is added to the displacement
16232 before the latter is negated. */
16235 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
16239 #ifdef FRAME_POINTER_CFA_OFFSET
16240 reg
= frame_pointer_rtx
;
16241 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
16243 reg
= arg_pointer_rtx
;
16244 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
16247 elim
= (ira_use_lra_p
16248 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
16249 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
16250 if (GET_CODE (elim
) == PLUS
)
16252 offset
+= INTVAL (XEXP (elim
, 1));
16253 elim
= XEXP (elim
, 0);
16256 frame_pointer_fb_offset
= -offset
;
16258 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
16259 in which to eliminate. This is because it's stack pointer isn't
16260 directly accessible as a register within the ISA. To work around
16261 this, assume that while we cannot provide a proper value for
16262 frame_pointer_fb_offset, we won't need one either. */
16263 frame_pointer_fb_offset_valid
16264 = ((SUPPORTS_STACK_ALIGNMENT
16265 && (elim
== hard_frame_pointer_rtx
16266 || elim
== stack_pointer_rtx
))
16267 || elim
== (frame_pointer_needed
16268 ? hard_frame_pointer_rtx
16269 : stack_pointer_rtx
));
16272 /* Generate a DW_AT_name attribute given some string value to be included as
16273 the value of the attribute. */
16276 add_name_attribute (dw_die_ref die
, const char *name_string
)
16278 if (name_string
!= NULL
&& *name_string
!= 0)
16280 if (demangle_name_func
)
16281 name_string
= (*demangle_name_func
) (name_string
);
16283 add_AT_string (die
, DW_AT_name
, name_string
);
16287 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
16288 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
16289 of TYPE accordingly.
16291 ??? This is a temporary measure until after we're able to generate
16292 regular DWARF for the complex Ada type system. */
16295 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
16296 dw_die_ref context_die
)
16299 dw_die_ref dtype_die
;
16301 if (!lang_hooks
.types
.descriptive_type
)
16304 dtype
= lang_hooks
.types
.descriptive_type (type
);
16308 dtype_die
= lookup_type_die (dtype
);
16311 gen_type_die (dtype
, context_die
);
16312 dtype_die
= lookup_type_die (dtype
);
16313 gcc_assert (dtype_die
);
16316 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
16319 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
16321 static const char *
16322 comp_dir_string (void)
16326 static const char *cached_wd
= NULL
;
16328 if (cached_wd
!= NULL
)
16331 wd
= get_src_pwd ();
16335 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
16339 wdlen
= strlen (wd
);
16340 wd1
= ggc_vec_alloc
<char> (wdlen
+ 2);
16342 wd1
[wdlen
] = DIR_SEPARATOR
;
16343 wd1
[wdlen
+ 1] = 0;
16347 cached_wd
= remap_debug_filename (wd
);
16351 /* Generate a DW_AT_comp_dir attribute for DIE. */
16354 add_comp_dir_attribute (dw_die_ref die
)
16356 const char * wd
= comp_dir_string ();
16358 add_AT_string (die
, DW_AT_comp_dir
, wd
);
16361 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16365 lower_bound_default (void)
16367 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
16372 case DW_LANG_C_plus_plus
:
16374 case DW_LANG_ObjC_plus_plus
:
16377 case DW_LANG_Fortran77
:
16378 case DW_LANG_Fortran90
:
16379 case DW_LANG_Fortran95
:
16383 case DW_LANG_Python
:
16384 return dwarf_version
>= 4 ? 0 : -1;
16385 case DW_LANG_Ada95
:
16386 case DW_LANG_Ada83
:
16387 case DW_LANG_Cobol74
:
16388 case DW_LANG_Cobol85
:
16389 case DW_LANG_Pascal83
:
16390 case DW_LANG_Modula2
:
16392 return dwarf_version
>= 4 ? 1 : -1;
16398 /* Given a tree node describing an array bound (either lower or upper) output
16399 a representation for that bound. */
16402 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
16404 switch (TREE_CODE (bound
))
16409 /* All fixed-bounds are represented by INTEGER_CST nodes. */
16412 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (bound
));
16415 /* Use the default if possible. */
16416 if (bound_attr
== DW_AT_lower_bound
16417 && tree_fits_shwi_p (bound
)
16418 && (dflt
= lower_bound_default ()) != -1
16419 && tree_to_shwi (bound
) == dflt
)
16422 /* If HOST_WIDE_INT is big enough then represent the bound as
16423 a constant value. We need to choose a form based on
16424 whether the type is signed or unsigned. We cannot just
16425 call add_AT_unsigned if the value itself is positive
16426 (add_AT_unsigned might add the unsigned value encoded as
16427 DW_FORM_data[1248]). Some DWARF consumers will lookup the
16428 bounds type and then sign extend any unsigned values found
16429 for signed types. This is needed only for
16430 DW_AT_{lower,upper}_bound, since for most other attributes,
16431 consumers will treat DW_FORM_data[1248] as unsigned values,
16432 regardless of the underlying type. */
16433 else if (prec
<= HOST_BITS_PER_WIDE_INT
16434 || tree_fits_uhwi_p (bound
))
16436 if (TYPE_UNSIGNED (TREE_TYPE (bound
)))
16437 add_AT_unsigned (subrange_die
, bound_attr
,
16438 TREE_INT_CST_LOW (bound
));
16440 add_AT_int (subrange_die
, bound_attr
, TREE_INT_CST_LOW (bound
));
16443 /* Otherwise represent the bound as an unsigned value with
16444 the precision of its type. The precision and signedness
16445 of the type will be necessary to re-interpret it
16447 add_AT_wide (subrange_die
, bound_attr
, bound
);
16452 case VIEW_CONVERT_EXPR
:
16453 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
16463 dw_die_ref decl_die
= lookup_decl_die (bound
);
16465 /* ??? Can this happen, or should the variable have been bound
16466 first? Probably it can, since I imagine that we try to create
16467 the types of parameters in the order in which they exist in
16468 the list, and won't have created a forward reference to a
16469 later parameter. */
16470 if (decl_die
!= NULL
)
16472 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16480 /* Otherwise try to create a stack operation procedure to
16481 evaluate the value of the array bound. */
16483 dw_die_ref ctx
, decl_die
;
16484 dw_loc_list_ref list
;
16486 list
= loc_list_from_tree (bound
, 2);
16487 if (list
== NULL
|| single_element_loc_list_p (list
))
16489 /* If DW_AT_*bound is not a reference nor constant, it is
16490 a DWARF expression rather than location description.
16491 For that loc_list_from_tree (bound, 0) is needed.
16492 If that fails to give a single element list,
16493 fall back to outputting this as a reference anyway. */
16494 dw_loc_list_ref list2
= loc_list_from_tree (bound
, 0);
16495 if (list2
&& single_element_loc_list_p (list2
))
16497 add_AT_loc (subrange_die
, bound_attr
, list2
->expr
);
16504 if (current_function_decl
== 0)
16505 ctx
= comp_unit_die ();
16507 ctx
= lookup_decl_die (current_function_decl
);
16509 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
16510 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
16511 add_type_attribute (decl_die
, TREE_TYPE (bound
), TYPE_QUAL_CONST
, ctx
);
16512 add_AT_location_description (decl_die
, DW_AT_location
, list
);
16513 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16519 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16520 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16521 Note that the block of subscript information for an array type also
16522 includes information about the element type of the given array type. */
16525 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
16527 unsigned dimension_number
;
16529 dw_die_ref subrange_die
;
16531 for (dimension_number
= 0;
16532 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
16533 type
= TREE_TYPE (type
), dimension_number
++)
16535 tree domain
= TYPE_DOMAIN (type
);
16537 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
16540 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16541 and (in GNU C only) variable bounds. Handle all three forms
16543 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
16546 /* We have an array type with specified bounds. */
16547 lower
= TYPE_MIN_VALUE (domain
);
16548 upper
= TYPE_MAX_VALUE (domain
);
16550 /* Define the index type. */
16551 if (TREE_TYPE (domain
))
16553 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16554 TREE_TYPE field. We can't emit debug info for this
16555 because it is an unnamed integral type. */
16556 if (TREE_CODE (domain
) == INTEGER_TYPE
16557 && TYPE_NAME (domain
) == NULL_TREE
16558 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
16559 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
16562 add_type_attribute (subrange_die
, TREE_TYPE (domain
),
16563 TYPE_UNQUALIFIED
, type_die
);
16566 /* ??? If upper is NULL, the array has unspecified length,
16567 but it does have a lower bound. This happens with Fortran
16569 Since the debugger is definitely going to need to know N
16570 to produce useful results, go ahead and output the lower
16571 bound solo, and hope the debugger can cope. */
16573 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
16575 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
16578 /* Otherwise we have an array type with an unspecified length. The
16579 DWARF-2 spec does not say how to handle this; let's just leave out the
16584 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
16587 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
16589 dw_die_ref decl_die
;
16590 HOST_WIDE_INT size
;
16592 switch (TREE_CODE (tree_node
))
16597 case ENUMERAL_TYPE
:
16600 case QUAL_UNION_TYPE
:
16601 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
16602 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
16604 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
16607 size
= int_size_in_bytes (tree_node
);
16610 /* For a data member of a struct or union, the DW_AT_byte_size is
16611 generally given as the number of bytes normally allocated for an
16612 object of the *declared* type of the member itself. This is true
16613 even for bit-fields. */
16614 size
= int_size_in_bytes (field_type (tree_node
));
16617 gcc_unreachable ();
16620 /* Note that `size' might be -1 when we get to this point. If it is, that
16621 indicates that the byte size of the entity in question is variable. We
16622 have no good way of expressing this fact in Dwarf at the present time,
16623 when location description was not used by the caller code instead. */
16625 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
16628 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16629 which specifies the distance in bits from the highest order bit of the
16630 "containing object" for the bit-field to the highest order bit of the
16633 For any given bit-field, the "containing object" is a hypothetical object
16634 (of some integral or enum type) within which the given bit-field lives. The
16635 type of this hypothetical "containing object" is always the same as the
16636 declared type of the individual bit-field itself. The determination of the
16637 exact location of the "containing object" for a bit-field is rather
16638 complicated. It's handled by the `field_byte_offset' function (above).
16640 Note that it is the size (in bytes) of the hypothetical "containing object"
16641 which will be given in the DW_AT_byte_size attribute for this bit-field.
16642 (See `byte_size_attribute' above). */
16645 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
16647 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
16648 tree type
= DECL_BIT_FIELD_TYPE (decl
);
16649 HOST_WIDE_INT bitpos_int
;
16650 HOST_WIDE_INT highest_order_object_bit_offset
;
16651 HOST_WIDE_INT highest_order_field_bit_offset
;
16652 HOST_WIDE_INT bit_offset
;
16654 /* Must be a field and a bit field. */
16655 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
16657 /* We can't yet handle bit-fields whose offsets are variable, so if we
16658 encounter such things, just return without generating any attribute
16659 whatsoever. Likewise for variable or too large size. */
16660 if (! tree_fits_shwi_p (bit_position (decl
))
16661 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
16664 bitpos_int
= int_bit_position (decl
);
16666 /* Note that the bit offset is always the distance (in bits) from the
16667 highest-order bit of the "containing object" to the highest-order bit of
16668 the bit-field itself. Since the "high-order end" of any object or field
16669 is different on big-endian and little-endian machines, the computation
16670 below must take account of these differences. */
16671 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
16672 highest_order_field_bit_offset
= bitpos_int
;
16674 if (! BYTES_BIG_ENDIAN
)
16676 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
16677 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
16681 = (! BYTES_BIG_ENDIAN
16682 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
16683 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
16685 if (bit_offset
< 0)
16686 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
16688 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
16691 /* For a FIELD_DECL node which represents a bit field, output an attribute
16692 which specifies the length in bits of the given field. */
16695 add_bit_size_attribute (dw_die_ref die
, tree decl
)
16697 /* Must be a field and a bit field. */
16698 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
16699 && DECL_BIT_FIELD_TYPE (decl
));
16701 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
16702 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
16705 /* If the compiled language is ANSI C, then add a 'prototyped'
16706 attribute, if arg types are given for the parameters of a function. */
16709 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
16711 if (get_AT_unsigned (comp_unit_die (), DW_AT_language
) == DW_LANG_C89
16712 && prototype_p (func_type
))
16713 add_AT_flag (die
, DW_AT_prototyped
, 1);
16716 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
16717 by looking in either the type declaration or object declaration
16720 static inline dw_die_ref
16721 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
16723 dw_die_ref origin_die
= NULL
;
16725 if (TREE_CODE (origin
) != FUNCTION_DECL
)
16727 /* We may have gotten separated from the block for the inlined
16728 function, if we're in an exception handler or some such; make
16729 sure that the abstract function has been written out.
16731 Doing this for nested functions is wrong, however; functions are
16732 distinct units, and our context might not even be inline. */
16736 fn
= TYPE_STUB_DECL (fn
);
16738 fn
= decl_function_context (fn
);
16740 dwarf2out_abstract_function (fn
);
16743 if (DECL_P (origin
))
16744 origin_die
= lookup_decl_die (origin
);
16745 else if (TYPE_P (origin
))
16746 origin_die
= lookup_type_die (origin
);
16748 /* XXX: Functions that are never lowered don't always have correct block
16749 trees (in the case of java, they simply have no block tree, in some other
16750 languages). For these functions, there is nothing we can really do to
16751 output correct debug info for inlined functions in all cases. Rather
16752 than die, we'll just produce deficient debug info now, in that we will
16753 have variables without a proper abstract origin. In the future, when all
16754 functions are lowered, we should re-add a gcc_assert (origin_die)
16758 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
16762 /* We do not currently support the pure_virtual attribute. */
16765 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
16767 if (DECL_VINDEX (func_decl
))
16769 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
16771 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
16772 add_AT_loc (die
, DW_AT_vtable_elem_location
,
16773 new_loc_descr (DW_OP_constu
,
16774 tree_to_shwi (DECL_VINDEX (func_decl
)),
16777 /* GNU extension: Record what type this method came from originally. */
16778 if (debug_info_level
> DINFO_LEVEL_TERSE
16779 && DECL_CONTEXT (func_decl
))
16780 add_AT_die_ref (die
, DW_AT_containing_type
,
16781 lookup_type_die (DECL_CONTEXT (func_decl
)));
16785 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
16786 given decl. This used to be a vendor extension until after DWARF 4
16787 standardized it. */
16790 add_linkage_attr (dw_die_ref die
, tree decl
)
16792 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
16794 /* Mimic what assemble_name_raw does with a leading '*'. */
16795 if (name
[0] == '*')
16798 if (dwarf_version
>= 4)
16799 add_AT_string (die
, DW_AT_linkage_name
, name
);
16801 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
16804 /* Add source coordinate attributes for the given decl. */
16807 add_src_coords_attributes (dw_die_ref die
, tree decl
)
16809 expanded_location s
;
16811 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
16813 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
16814 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
16815 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
16818 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
16821 add_linkage_name (dw_die_ref die
, tree decl
)
16823 if (debug_info_level
> DINFO_LEVEL_NONE
16824 && (TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
16825 && TREE_PUBLIC (decl
)
16826 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
16827 && die
->die_tag
!= DW_TAG_member
)
16829 /* Defer until we have an assembler name set. */
16830 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
16832 limbo_die_node
*asm_name
;
16834 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
16835 asm_name
->die
= die
;
16836 asm_name
->created_for
= decl
;
16837 asm_name
->next
= deferred_asm_name
;
16838 deferred_asm_name
= asm_name
;
16840 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
16841 add_linkage_attr (die
, decl
);
16845 /* Add a DW_AT_name attribute and source coordinate attribute for the
16846 given decl, but only if it actually has a name. */
16849 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
16853 decl_name
= DECL_NAME (decl
);
16854 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
16856 const char *name
= dwarf2_name (decl
, 0);
16858 add_name_attribute (die
, name
);
16859 if (! DECL_ARTIFICIAL (decl
))
16860 add_src_coords_attributes (die
, decl
);
16862 add_linkage_name (die
, decl
);
16865 #ifdef VMS_DEBUGGING_INFO
16866 /* Get the function's name, as described by its RTL. This may be different
16867 from the DECL_NAME name used in the source file. */
16868 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
16870 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
16871 XEXP (DECL_RTL (decl
), 0), false);
16872 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
16874 #endif /* VMS_DEBUGGING_INFO */
16877 #ifdef VMS_DEBUGGING_INFO
16878 /* Output the debug main pointer die for VMS */
16881 dwarf2out_vms_debug_main_pointer (void)
16883 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
16886 /* Allocate the VMS debug main subprogram die. */
16887 die
= ggc_cleared_alloc
<die_node
> ();
16888 die
->die_tag
= DW_TAG_subprogram
;
16889 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
16890 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
16891 current_function_funcdef_no
);
16892 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
16894 /* Make it the first child of comp_unit_die (). */
16895 die
->die_parent
= comp_unit_die ();
16896 if (comp_unit_die ()->die_child
)
16898 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
16899 comp_unit_die ()->die_child
->die_sib
= die
;
16903 die
->die_sib
= die
;
16904 comp_unit_die ()->die_child
= die
;
16907 #endif /* VMS_DEBUGGING_INFO */
16909 /* Push a new declaration scope. */
16912 push_decl_scope (tree scope
)
16914 vec_safe_push (decl_scope_table
, scope
);
16917 /* Pop a declaration scope. */
16920 pop_decl_scope (void)
16922 decl_scope_table
->pop ();
16925 /* walk_tree helper function for uses_local_type, below. */
16928 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
16931 *walk_subtrees
= 0;
16934 tree name
= TYPE_NAME (*tp
);
16935 if (name
&& DECL_P (name
) && decl_function_context (name
))
16941 /* If TYPE involves a function-local type (including a local typedef to a
16942 non-local type), returns that type; otherwise returns NULL_TREE. */
16945 uses_local_type (tree type
)
16947 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
16951 /* Return the DIE for the scope that immediately contains this type.
16952 Non-named types that do not involve a function-local type get global
16953 scope. Named types nested in namespaces or other types get their
16954 containing scope. All other types (i.e. function-local named types) get
16955 the current active scope. */
16958 scope_die_for (tree t
, dw_die_ref context_die
)
16960 dw_die_ref scope_die
= NULL
;
16961 tree containing_scope
;
16963 /* Non-types always go in the current scope. */
16964 gcc_assert (TYPE_P (t
));
16966 /* Use the scope of the typedef, rather than the scope of the type
16968 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
16969 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
16971 containing_scope
= TYPE_CONTEXT (t
);
16973 /* Use the containing namespace if there is one. */
16974 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
16976 if (context_die
== lookup_decl_die (containing_scope
))
16978 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
16979 context_die
= get_context_die (containing_scope
);
16981 containing_scope
= NULL_TREE
;
16984 /* Ignore function type "scopes" from the C frontend. They mean that
16985 a tagged type is local to a parmlist of a function declarator, but
16986 that isn't useful to DWARF. */
16987 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
16988 containing_scope
= NULL_TREE
;
16990 if (SCOPE_FILE_SCOPE_P (containing_scope
))
16992 /* If T uses a local type keep it local as well, to avoid references
16993 to function-local DIEs from outside the function. */
16994 if (current_function_decl
&& uses_local_type (t
))
16995 scope_die
= context_die
;
16997 scope_die
= comp_unit_die ();
16999 else if (TYPE_P (containing_scope
))
17001 /* For types, we can just look up the appropriate DIE. */
17002 if (debug_info_level
> DINFO_LEVEL_TERSE
)
17003 scope_die
= get_context_die (containing_scope
);
17006 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
17007 if (scope_die
== NULL
)
17008 scope_die
= comp_unit_die ();
17012 scope_die
= context_die
;
17017 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
17020 local_scope_p (dw_die_ref context_die
)
17022 for (; context_die
; context_die
= context_die
->die_parent
)
17023 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
17024 || context_die
->die_tag
== DW_TAG_subprogram
)
17030 /* Returns nonzero if CONTEXT_DIE is a class. */
17033 class_scope_p (dw_die_ref context_die
)
17035 return (context_die
17036 && (context_die
->die_tag
== DW_TAG_structure_type
17037 || context_die
->die_tag
== DW_TAG_class_type
17038 || context_die
->die_tag
== DW_TAG_interface_type
17039 || context_die
->die_tag
== DW_TAG_union_type
));
17042 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17043 whether or not to treat a DIE in this context as a declaration. */
17046 class_or_namespace_scope_p (dw_die_ref context_die
)
17048 return (class_scope_p (context_die
)
17049 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
17052 /* Many forms of DIEs require a "type description" attribute. This
17053 routine locates the proper "type descriptor" die for the type given
17054 by 'type' plus any additional qualifiers given by 'cv_quals', and
17055 adds a DW_AT_type attribute below the given die. */
17058 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
17059 dw_die_ref context_die
)
17061 enum tree_code code
= TREE_CODE (type
);
17062 dw_die_ref type_die
= NULL
;
17064 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17065 or fixed-point type, use the inner type. This is because we have no
17066 support for unnamed types in base_type_die. This can happen if this is
17067 an Ada subrange type. Correct solution is emit a subrange type die. */
17068 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
17069 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
17070 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
17072 if (code
== ERROR_MARK
17073 /* Handle a special case. For functions whose return type is void, we
17074 generate *no* type attribute. (Note that no object may have type
17075 `void', so this only applies to function return types). */
17076 || code
== VOID_TYPE
)
17079 type_die
= modified_type_die (type
,
17080 cv_quals
| TYPE_QUALS_NO_ADDR_SPACE (type
),
17083 if (type_die
!= NULL
)
17084 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
17087 /* Given an object die, add the calling convention attribute for the
17088 function call type. */
17090 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
17092 enum dwarf_calling_convention value
= DW_CC_normal
;
17094 value
= ((enum dwarf_calling_convention
)
17095 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
17098 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
17100 /* DWARF 2 doesn't provide a way to identify a program's source-level
17101 entry point. DW_AT_calling_convention attributes are only meant
17102 to describe functions' calling conventions. However, lacking a
17103 better way to signal the Fortran main program, we used this for
17104 a long time, following existing custom. Now, DWARF 4 has
17105 DW_AT_main_subprogram, which we add below, but some tools still
17106 rely on the old way, which we thus keep. */
17107 value
= DW_CC_program
;
17109 if (dwarf_version
>= 4 || !dwarf_strict
)
17110 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
17113 /* Only add the attribute if the backend requests it, and
17114 is not DW_CC_normal. */
17115 if (value
&& (value
!= DW_CC_normal
))
17116 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
17119 /* Given a tree pointer to a struct, class, union, or enum type node, return
17120 a pointer to the (string) tag name for the given type, or zero if the type
17121 was declared without a tag. */
17123 static const char *
17124 type_tag (const_tree type
)
17126 const char *name
= 0;
17128 if (TYPE_NAME (type
) != 0)
17132 /* Find the IDENTIFIER_NODE for the type name. */
17133 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
17134 && !TYPE_NAMELESS (type
))
17135 t
= TYPE_NAME (type
);
17137 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17138 a TYPE_DECL node, regardless of whether or not a `typedef' was
17140 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
17141 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
17143 /* We want to be extra verbose. Don't call dwarf_name if
17144 DECL_NAME isn't set. The default hook for decl_printable_name
17145 doesn't like that, and in this context it's correct to return
17146 0, instead of "<anonymous>" or the like. */
17147 if (DECL_NAME (TYPE_NAME (type
))
17148 && !DECL_NAMELESS (TYPE_NAME (type
)))
17149 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
17152 /* Now get the name as a string, or invent one. */
17153 if (!name
&& t
!= 0)
17154 name
= IDENTIFIER_POINTER (t
);
17157 return (name
== 0 || *name
== '\0') ? 0 : name
;
17160 /* Return the type associated with a data member, make a special check
17161 for bit field types. */
17164 member_declared_type (const_tree member
)
17166 return (DECL_BIT_FIELD_TYPE (member
)
17167 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
17170 /* Get the decl's label, as described by its RTL. This may be different
17171 from the DECL_NAME name used in the source file. */
17174 static const char *
17175 decl_start_label (tree decl
)
17178 const char *fnname
;
17180 x
= DECL_RTL (decl
);
17181 gcc_assert (MEM_P (x
));
17184 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
17186 fnname
= XSTR (x
, 0);
17191 /* These routines generate the internal representation of the DIE's for
17192 the compilation unit. Debugging information is collected by walking
17193 the declaration trees passed in from dwarf2out_decl(). */
17196 gen_array_type_die (tree type
, dw_die_ref context_die
)
17198 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17199 dw_die_ref array_die
;
17201 /* GNU compilers represent multidimensional array types as sequences of one
17202 dimensional array types whose element types are themselves array types.
17203 We sometimes squish that down to a single array_type DIE with multiple
17204 subscripts in the Dwarf debugging info. The draft Dwarf specification
17205 say that we are allowed to do this kind of compression in C, because
17206 there is no difference between an array of arrays and a multidimensional
17207 array. We don't do this for Ada to remain as close as possible to the
17208 actual representation, which is especially important against the language
17209 flexibilty wrt arrays of variable size. */
17211 bool collapse_nested_arrays
= !is_ada ();
17214 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17215 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17216 if (TYPE_STRING_FLAG (type
)
17217 && TREE_CODE (type
) == ARRAY_TYPE
17219 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
17221 HOST_WIDE_INT size
;
17223 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
17224 add_name_attribute (array_die
, type_tag (type
));
17225 equate_type_number_to_die (type
, array_die
);
17226 size
= int_size_in_bytes (type
);
17228 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17229 else if (TYPE_DOMAIN (type
) != NULL_TREE
17230 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
17231 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
17233 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
17234 dw_loc_list_ref loc
= loc_list_from_tree (szdecl
, 2);
17236 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
17237 if (loc
&& size
> 0)
17239 add_AT_location_description (array_die
, DW_AT_string_length
, loc
);
17240 if (size
!= DWARF2_ADDR_SIZE
)
17241 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17247 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17248 add_name_attribute (array_die
, type_tag (type
));
17249 equate_type_number_to_die (type
, array_die
);
17251 if (TREE_CODE (type
) == VECTOR_TYPE
)
17252 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
17254 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17256 && TREE_CODE (type
) == ARRAY_TYPE
17257 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
17258 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
17259 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17262 /* We default the array ordering. SDB will probably do
17263 the right things even if DW_AT_ordering is not present. It's not even
17264 an issue until we start to get into multidimensional arrays anyway. If
17265 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17266 then we'll have to put the DW_AT_ordering attribute back in. (But if
17267 and when we find out that we need to put these in, we will only do so
17268 for multidimensional arrays. */
17269 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
17272 if (TREE_CODE (type
) == VECTOR_TYPE
)
17274 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
17275 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17276 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
);
17277 add_bound_info (subrange_die
, DW_AT_upper_bound
,
17278 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
17281 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
17283 /* Add representation of the type of the elements of this array type and
17284 emit the corresponding DIE if we haven't done it already. */
17285 element_type
= TREE_TYPE (type
);
17286 if (collapse_nested_arrays
)
17287 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
17289 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
17291 element_type
= TREE_TYPE (element_type
);
17294 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
, context_die
);
17296 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
17297 if (TYPE_ARTIFICIAL (type
))
17298 add_AT_flag (array_die
, DW_AT_artificial
, 1);
17300 if (get_AT (array_die
, DW_AT_name
))
17301 add_pubtype (type
, array_die
);
17304 static dw_loc_descr_ref
17305 descr_info_loc (tree val
, tree base_decl
)
17307 HOST_WIDE_INT size
;
17308 dw_loc_descr_ref loc
, loc2
;
17309 enum dwarf_location_atom op
;
17311 if (val
== base_decl
)
17312 return new_loc_descr (DW_OP_push_object_address
, 0, 0);
17314 switch (TREE_CODE (val
))
17317 return descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17319 return loc_descriptor_from_tree (val
, 0);
17321 if (tree_fits_shwi_p (val
))
17322 return int_loc_descriptor (tree_to_shwi (val
));
17325 size
= int_size_in_bytes (TREE_TYPE (val
));
17328 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17331 if (size
== DWARF2_ADDR_SIZE
)
17332 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref
, 0, 0));
17334 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref_size
, size
, 0));
17336 case POINTER_PLUS_EXPR
:
17338 if (tree_fits_uhwi_p (TREE_OPERAND (val
, 1))
17339 && tree_to_uhwi (TREE_OPERAND (val
, 1)) < 16384)
17341 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17344 loc_descr_plus_const (&loc
, tree_to_shwi (TREE_OPERAND (val
, 1)));
17350 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17353 loc2
= descr_info_loc (TREE_OPERAND (val
, 1), base_decl
);
17356 add_loc_descr (&loc
, loc2
);
17357 add_loc_descr (&loc2
, new_loc_descr (op
, 0, 0));
17379 add_descr_info_field (dw_die_ref die
, enum dwarf_attribute attr
,
17380 tree val
, tree base_decl
)
17382 dw_loc_descr_ref loc
;
17384 if (tree_fits_shwi_p (val
))
17386 add_AT_unsigned (die
, attr
, tree_to_shwi (val
));
17390 loc
= descr_info_loc (val
, base_decl
);
17394 add_AT_loc (die
, attr
, loc
);
17397 /* This routine generates DIE for array with hidden descriptor, details
17398 are filled into *info by a langhook. */
17401 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
17402 dw_die_ref context_die
)
17404 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17405 dw_die_ref array_die
;
17408 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17409 add_name_attribute (array_die
, type_tag (type
));
17410 equate_type_number_to_die (type
, array_die
);
17412 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17414 && info
->ndimensions
>= 2)
17415 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17417 if (info
->data_location
)
17418 add_descr_info_field (array_die
, DW_AT_data_location
, info
->data_location
,
17420 if (info
->associated
)
17421 add_descr_info_field (array_die
, DW_AT_associated
, info
->associated
,
17423 if (info
->allocated
)
17424 add_descr_info_field (array_die
, DW_AT_allocated
, info
->allocated
,
17427 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
17429 dw_die_ref subrange_die
17430 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17432 if (info
->dimen
[dim
].lower_bound
)
17434 /* If it is the default value, omit it. */
17437 if (tree_fits_shwi_p (info
->dimen
[dim
].lower_bound
)
17438 && (dflt
= lower_bound_default ()) != -1
17439 && tree_to_shwi (info
->dimen
[dim
].lower_bound
) == dflt
)
17442 add_descr_info_field (subrange_die
, DW_AT_lower_bound
,
17443 info
->dimen
[dim
].lower_bound
,
17446 if (info
->dimen
[dim
].upper_bound
)
17447 add_descr_info_field (subrange_die
, DW_AT_upper_bound
,
17448 info
->dimen
[dim
].upper_bound
,
17450 if (info
->dimen
[dim
].stride
)
17451 add_descr_info_field (subrange_die
, DW_AT_byte_stride
,
17452 info
->dimen
[dim
].stride
,
17456 gen_type_die (info
->element_type
, context_die
);
17457 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
17460 if (get_AT (array_die
, DW_AT_name
))
17461 add_pubtype (type
, array_die
);
17466 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
17468 tree origin
= decl_ultimate_origin (decl
);
17469 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
17471 if (origin
!= NULL
)
17472 add_abstract_origin_attribute (decl_die
, origin
);
17475 add_name_and_src_coords_attributes (decl_die
, decl
);
17476 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
17477 TYPE_UNQUALIFIED
, context_die
);
17480 if (DECL_ABSTRACT_P (decl
))
17481 equate_decl_number_to_die (decl
, decl_die
);
17483 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
17487 /* Walk through the list of incomplete types again, trying once more to
17488 emit full debugging info for them. */
17491 retry_incomplete_types (void)
17495 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
17496 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
17497 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
17500 /* Determine what tag to use for a record type. */
17502 static enum dwarf_tag
17503 record_type_tag (tree type
)
17505 if (! lang_hooks
.types
.classify_record
)
17506 return DW_TAG_structure_type
;
17508 switch (lang_hooks
.types
.classify_record (type
))
17510 case RECORD_IS_STRUCT
:
17511 return DW_TAG_structure_type
;
17513 case RECORD_IS_CLASS
:
17514 return DW_TAG_class_type
;
17516 case RECORD_IS_INTERFACE
:
17517 if (dwarf_version
>= 3 || !dwarf_strict
)
17518 return DW_TAG_interface_type
;
17519 return DW_TAG_structure_type
;
17522 gcc_unreachable ();
17526 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17527 include all of the information about the enumeration values also. Each
17528 enumerated type name/value is listed as a child of the enumerated type
17532 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
17534 dw_die_ref type_die
= lookup_type_die (type
);
17536 if (type_die
== NULL
)
17538 type_die
= new_die (DW_TAG_enumeration_type
,
17539 scope_die_for (type
, context_die
), type
);
17540 equate_type_number_to_die (type
, type_die
);
17541 add_name_attribute (type_die
, type_tag (type
));
17542 if (dwarf_version
>= 4 || !dwarf_strict
)
17544 if (ENUM_IS_SCOPED (type
))
17545 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
17546 if (ENUM_IS_OPAQUE (type
))
17547 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17550 else if (! TYPE_SIZE (type
))
17553 remove_AT (type_die
, DW_AT_declaration
);
17555 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17556 given enum type is incomplete, do not generate the DW_AT_byte_size
17557 attribute or the DW_AT_element_list attribute. */
17558 if (TYPE_SIZE (type
))
17562 TREE_ASM_WRITTEN (type
) = 1;
17563 add_byte_size_attribute (type_die
, type
);
17564 if (dwarf_version
>= 3 || !dwarf_strict
)
17566 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
17567 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
,
17570 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
17572 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
17573 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
17576 /* If the first reference to this type was as the return type of an
17577 inline function, then it may not have a parent. Fix this now. */
17578 if (type_die
->die_parent
== NULL
)
17579 add_child_die (scope_die_for (type
, context_die
), type_die
);
17581 for (link
= TYPE_VALUES (type
);
17582 link
!= NULL
; link
= TREE_CHAIN (link
))
17584 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
17585 tree value
= TREE_VALUE (link
);
17587 add_name_attribute (enum_die
,
17588 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
17590 if (TREE_CODE (value
) == CONST_DECL
)
17591 value
= DECL_INITIAL (value
);
17593 if (simple_type_size_in_bits (TREE_TYPE (value
))
17594 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
17596 /* For constant forms created by add_AT_unsigned DWARF
17597 consumers (GDB, elfutils, etc.) always zero extend
17598 the value. Only when the actual value is negative
17599 do we need to use add_AT_int to generate a constant
17600 form that can represent negative values. */
17601 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
17602 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
17603 add_AT_unsigned (enum_die
, DW_AT_const_value
,
17604 (unsigned HOST_WIDE_INT
) val
);
17606 add_AT_int (enum_die
, DW_AT_const_value
, val
);
17609 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
17610 that here. TODO: This should be re-worked to use correct
17611 signed/unsigned double tags for all cases. */
17612 add_AT_wide (enum_die
, DW_AT_const_value
, value
);
17615 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
17616 if (TYPE_ARTIFICIAL (type
))
17617 add_AT_flag (type_die
, DW_AT_artificial
, 1);
17620 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17622 add_pubtype (type
, type_die
);
17627 /* Generate a DIE to represent either a real live formal parameter decl or to
17628 represent just the type of some formal parameter position in some function
17631 Note that this routine is a bit unusual because its argument may be a
17632 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17633 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17634 node. If it's the former then this function is being called to output a
17635 DIE to represent a formal parameter object (or some inlining thereof). If
17636 it's the latter, then this function is only being called to output a
17637 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17638 argument type of some subprogram type.
17639 If EMIT_NAME_P is true, name and source coordinate attributes
17643 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
17644 dw_die_ref context_die
)
17646 tree node_or_origin
= node
? node
: origin
;
17647 tree ultimate_origin
;
17648 dw_die_ref parm_die
17649 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
17651 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
17653 case tcc_declaration
:
17654 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
17655 if (node
|| ultimate_origin
)
17656 origin
= ultimate_origin
;
17657 if (origin
!= NULL
)
17658 add_abstract_origin_attribute (parm_die
, origin
);
17659 else if (emit_name_p
)
17660 add_name_and_src_coords_attributes (parm_die
, node
);
17662 || (! DECL_ABSTRACT_P (node_or_origin
)
17663 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
17664 decl_function_context
17665 (node_or_origin
))))
17667 tree type
= TREE_TYPE (node_or_origin
);
17668 if (decl_by_reference_p (node_or_origin
))
17669 add_type_attribute (parm_die
, TREE_TYPE (type
),
17670 TYPE_UNQUALIFIED
, context_die
);
17672 add_type_attribute (parm_die
, type
,
17673 decl_quals (node_or_origin
),
17676 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
17677 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17679 if (node
&& node
!= origin
)
17680 equate_decl_number_to_die (node
, parm_die
);
17681 if (! DECL_ABSTRACT_P (node_or_origin
))
17682 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
17683 node
== NULL
, DW_AT_location
);
17688 /* We were called with some kind of a ..._TYPE node. */
17689 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
,
17694 gcc_unreachable ();
17700 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17701 children DW_TAG_formal_parameter DIEs representing the arguments of the
17704 PARM_PACK must be a function parameter pack.
17705 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17706 must point to the subsequent arguments of the function PACK_ARG belongs to.
17707 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17708 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17709 following the last one for which a DIE was generated. */
17712 gen_formal_parameter_pack_die (tree parm_pack
,
17714 dw_die_ref subr_die
,
17718 dw_die_ref parm_pack_die
;
17720 gcc_assert (parm_pack
17721 && lang_hooks
.function_parameter_pack_p (parm_pack
)
17724 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
17725 add_src_coords_attributes (parm_pack_die
, parm_pack
);
17727 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
17729 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
17732 gen_formal_parameter_die (arg
, NULL
,
17733 false /* Don't emit name attribute. */,
17738 return parm_pack_die
;
17741 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17742 at the end of an (ANSI prototyped) formal parameters list. */
17745 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
17747 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
17750 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17751 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17752 parameters as specified in some function type specification (except for
17753 those which appear as part of a function *definition*). */
17756 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
17759 tree formal_type
= NULL
;
17760 tree first_parm_type
;
17763 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
17765 arg
= DECL_ARGUMENTS (function_or_method_type
);
17766 function_or_method_type
= TREE_TYPE (function_or_method_type
);
17771 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
17773 /* Make our first pass over the list of formal parameter types and output a
17774 DW_TAG_formal_parameter DIE for each one. */
17775 for (link
= first_parm_type
; link
; )
17777 dw_die_ref parm_die
;
17779 formal_type
= TREE_VALUE (link
);
17780 if (formal_type
== void_type_node
)
17783 /* Output a (nameless) DIE to represent the formal parameter itself. */
17784 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
17785 true /* Emit name attribute. */,
17787 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
17788 && link
== first_parm_type
)
17790 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17791 if (dwarf_version
>= 3 || !dwarf_strict
)
17792 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
17794 else if (arg
&& DECL_ARTIFICIAL (arg
))
17795 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17797 link
= TREE_CHAIN (link
);
17799 arg
= DECL_CHAIN (arg
);
17802 /* If this function type has an ellipsis, add a
17803 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
17804 if (formal_type
!= void_type_node
)
17805 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
17807 /* Make our second (and final) pass over the list of formal parameter types
17808 and output DIEs to represent those types (as necessary). */
17809 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
17810 link
&& TREE_VALUE (link
);
17811 link
= TREE_CHAIN (link
))
17812 gen_type_die (TREE_VALUE (link
), context_die
);
17815 /* We want to generate the DIE for TYPE so that we can generate the
17816 die for MEMBER, which has been defined; we will need to refer back
17817 to the member declaration nested within TYPE. If we're trying to
17818 generate minimal debug info for TYPE, processing TYPE won't do the
17819 trick; we need to attach the member declaration by hand. */
17822 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
17824 gen_type_die (type
, context_die
);
17826 /* If we're trying to avoid duplicate debug info, we may not have
17827 emitted the member decl for this function. Emit it now. */
17828 if (TYPE_STUB_DECL (type
)
17829 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
17830 && ! lookup_decl_die (member
))
17832 dw_die_ref type_die
;
17833 gcc_assert (!decl_ultimate_origin (member
));
17835 push_decl_scope (type
);
17836 type_die
= lookup_type_die_strip_naming_typedef (type
);
17837 if (TREE_CODE (member
) == FUNCTION_DECL
)
17838 gen_subprogram_die (member
, type_die
);
17839 else if (TREE_CODE (member
) == FIELD_DECL
)
17841 /* Ignore the nameless fields that are used to skip bits but handle
17842 C++ anonymous unions and structs. */
17843 if (DECL_NAME (member
) != NULL_TREE
17844 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
17845 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
17847 gen_type_die (member_declared_type (member
), type_die
);
17848 gen_field_die (member
, type_die
);
17852 gen_variable_die (member
, NULL_TREE
, type_die
);
17858 /* Forward declare these functions, because they are mutually recursive
17859 with their set_block_* pairing functions. */
17860 static void set_decl_origin_self (tree
);
17861 static void set_decl_abstract_flags (tree
, int);
17863 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
17864 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
17865 that it points to the node itself, thus indicating that the node is its
17866 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
17867 the given node is NULL, recursively descend the decl/block tree which
17868 it is the root of, and for each other ..._DECL or BLOCK node contained
17869 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
17870 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
17871 values to point to themselves. */
17874 set_block_origin_self (tree stmt
)
17876 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
17878 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
17883 for (local_decl
= BLOCK_VARS (stmt
);
17884 local_decl
!= NULL_TREE
;
17885 local_decl
= DECL_CHAIN (local_decl
))
17886 if (! DECL_EXTERNAL (local_decl
))
17887 set_decl_origin_self (local_decl
); /* Potential recursion. */
17893 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17894 subblock
!= NULL_TREE
;
17895 subblock
= BLOCK_CHAIN (subblock
))
17896 set_block_origin_self (subblock
); /* Recurse. */
17901 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
17902 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
17903 node to so that it points to the node itself, thus indicating that the
17904 node represents its own (abstract) origin. Additionally, if the
17905 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
17906 the decl/block tree of which the given node is the root of, and for
17907 each other ..._DECL or BLOCK node contained therein whose
17908 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
17909 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
17910 point to themselves. */
17913 set_decl_origin_self (tree decl
)
17915 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
17917 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
17918 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17922 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17923 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
17924 if (DECL_INITIAL (decl
) != NULL_TREE
17925 && DECL_INITIAL (decl
) != error_mark_node
)
17926 set_block_origin_self (DECL_INITIAL (decl
));
17931 /* Given a pointer to some BLOCK node, and a boolean value to set the
17932 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
17933 the given block, and for all local decls and all local sub-blocks
17934 (recursively) which are contained therein. */
17937 set_block_abstract_flags (tree stmt
, int setting
)
17943 BLOCK_ABSTRACT (stmt
) = setting
;
17945 for (local_decl
= BLOCK_VARS (stmt
);
17946 local_decl
!= NULL_TREE
;
17947 local_decl
= DECL_CHAIN (local_decl
))
17948 if (! DECL_EXTERNAL (local_decl
))
17949 set_decl_abstract_flags (local_decl
, setting
);
17951 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
17953 local_decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
17954 if ((TREE_CODE (local_decl
) == VAR_DECL
&& !TREE_STATIC (local_decl
))
17955 || TREE_CODE (local_decl
) == PARM_DECL
)
17956 set_decl_abstract_flags (local_decl
, setting
);
17959 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17960 subblock
!= NULL_TREE
;
17961 subblock
= BLOCK_CHAIN (subblock
))
17962 set_block_abstract_flags (subblock
, setting
);
17965 /* Given a pointer to some ..._DECL node, and a boolean value to set the
17966 "abstract" flags to, set that value into the DECL_ABSTRACT_P flag for the
17967 given decl, and (in the case where the decl is a FUNCTION_DECL) also
17968 set the abstract flags for all of the parameters, local vars, local
17969 blocks and sub-blocks (recursively) to the same setting. */
17972 set_decl_abstract_flags (tree decl
, int setting
)
17974 DECL_ABSTRACT_P (decl
) = setting
;
17975 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17979 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17980 DECL_ABSTRACT_P (arg
) = setting
;
17981 if (DECL_INITIAL (decl
) != NULL_TREE
17982 && DECL_INITIAL (decl
) != error_mark_node
)
17983 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
17987 /* Generate the DWARF2 info for the "abstract" instance of a function which we
17988 may later generate inlined and/or out-of-line instances of. */
17991 dwarf2out_abstract_function (tree decl
)
17993 dw_die_ref old_die
;
17997 htab_t old_decl_loc_table
;
17998 htab_t old_cached_dw_loc_list_table
;
17999 int old_call_site_count
, old_tail_call_site_count
;
18000 struct call_arg_loc_node
*old_call_arg_locations
;
18002 /* Make sure we have the actual abstract inline, not a clone. */
18003 decl
= DECL_ORIGIN (decl
);
18005 old_die
= lookup_decl_die (decl
);
18006 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
18007 /* We've already generated the abstract instance. */
18010 /* We can be called while recursively when seeing block defining inlined subroutine
18011 DIE. Be sure to not clobber the outer location table nor use it or we would
18012 get locations in abstract instantces. */
18013 old_decl_loc_table
= decl_loc_table
;
18014 decl_loc_table
= NULL
;
18015 old_cached_dw_loc_list_table
= cached_dw_loc_list_table
;
18016 cached_dw_loc_list_table
= NULL
;
18017 old_call_arg_locations
= call_arg_locations
;
18018 call_arg_locations
= NULL
;
18019 old_call_site_count
= call_site_count
;
18020 call_site_count
= -1;
18021 old_tail_call_site_count
= tail_call_site_count
;
18022 tail_call_site_count
= -1;
18024 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
18025 we don't get confused by DECL_ABSTRACT_P. */
18026 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18028 context
= decl_class_context (decl
);
18030 gen_type_die_for_member
18031 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die ());
18034 /* Pretend we've just finished compiling this function. */
18035 save_fn
= current_function_decl
;
18036 current_function_decl
= decl
;
18038 was_abstract
= DECL_ABSTRACT_P (decl
);
18039 set_decl_abstract_flags (decl
, 1);
18040 dwarf2out_decl (decl
);
18041 if (! was_abstract
)
18042 set_decl_abstract_flags (decl
, 0);
18044 current_function_decl
= save_fn
;
18045 decl_loc_table
= old_decl_loc_table
;
18046 cached_dw_loc_list_table
= old_cached_dw_loc_list_table
;
18047 call_arg_locations
= old_call_arg_locations
;
18048 call_site_count
= old_call_site_count
;
18049 tail_call_site_count
= old_tail_call_site_count
;
18052 /* Helper function of premark_used_types() which gets called through
18055 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18056 marked as unused by prune_unused_types. */
18059 premark_used_types_helper (tree
const &type
, void *)
18063 die
= lookup_type_die (type
);
18065 die
->die_perennial_p
= 1;
18069 /* Helper function of premark_types_used_by_global_vars which gets called
18070 through htab_traverse.
18072 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18073 marked as unused by prune_unused_types. The DIE of the type is marked
18074 only if the global variable using the type will actually be emitted. */
18077 premark_types_used_by_global_vars_helper (void **slot
,
18078 void *data ATTRIBUTE_UNUSED
)
18080 struct types_used_by_vars_entry
*entry
;
18083 entry
= (struct types_used_by_vars_entry
*) *slot
;
18084 gcc_assert (entry
->type
!= NULL
18085 && entry
->var_decl
!= NULL
);
18086 die
= lookup_type_die (entry
->type
);
18089 /* Ask cgraph if the global variable really is to be emitted.
18090 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18091 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
18092 if (node
&& node
->definition
)
18094 die
->die_perennial_p
= 1;
18095 /* Keep the parent DIEs as well. */
18096 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
18097 die
->die_perennial_p
= 1;
18103 /* Mark all members of used_types_hash as perennial. */
18106 premark_used_types (struct function
*fun
)
18108 if (fun
&& fun
->used_types_hash
)
18109 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
18112 /* Mark all members of types_used_by_vars_entry as perennial. */
18115 premark_types_used_by_global_vars (void)
18117 if (types_used_by_vars_hash
)
18118 htab_traverse (types_used_by_vars_hash
,
18119 premark_types_used_by_global_vars_helper
, NULL
);
18122 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
18123 for CA_LOC call arg loc node. */
18126 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
18127 struct call_arg_loc_node
*ca_loc
)
18129 dw_die_ref stmt_die
= NULL
, die
;
18130 tree block
= ca_loc
->block
;
18133 && block
!= DECL_INITIAL (decl
)
18134 && TREE_CODE (block
) == BLOCK
)
18136 if (block_map
.length () > BLOCK_NUMBER (block
))
18137 stmt_die
= block_map
[BLOCK_NUMBER (block
)];
18140 block
= BLOCK_SUPERCONTEXT (block
);
18142 if (stmt_die
== NULL
)
18143 stmt_die
= subr_die
;
18144 die
= new_die (DW_TAG_GNU_call_site
, stmt_die
, NULL_TREE
);
18145 add_AT_lbl_id (die
, DW_AT_low_pc
, ca_loc
->label
);
18146 if (ca_loc
->tail_call_p
)
18147 add_AT_flag (die
, DW_AT_GNU_tail_call
, 1);
18148 if (ca_loc
->symbol_ref
)
18150 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
18152 add_AT_die_ref (die
, DW_AT_abstract_origin
, tdie
);
18154 add_AT_addr (die
, DW_AT_abstract_origin
, ca_loc
->symbol_ref
, false);
18159 /* Generate a DIE to represent a declared function (either file-scope or
18163 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
18165 tree origin
= decl_ultimate_origin (decl
);
18166 dw_die_ref subr_die
;
18168 dw_die_ref old_die
= lookup_decl_die (decl
);
18169 int declaration
= (current_function_decl
!= decl
18170 || class_or_namespace_scope_p (context_die
));
18172 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
18174 /* It is possible to have both DECL_ABSTRACT_P and DECLARATION be true if we
18175 started to generate the abstract instance of an inline, decided to output
18176 its containing class, and proceeded to emit the declaration of the inline
18177 from the member list for the class. If so, DECLARATION takes priority;
18178 we'll get back to the abstract instance when done with the class. */
18180 /* The class-scope declaration DIE must be the primary DIE. */
18181 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
18184 gcc_assert (!old_die
);
18187 /* Now that the C++ front end lazily declares artificial member fns, we
18188 might need to retrofit the declaration into its class. */
18189 if (!declaration
&& !origin
&& !old_die
18190 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
18191 && !class_or_namespace_scope_p (context_die
)
18192 && debug_info_level
> DINFO_LEVEL_TERSE
)
18193 old_die
= force_decl_die (decl
);
18195 if (origin
!= NULL
)
18197 gcc_assert (!declaration
|| local_scope_p (context_die
));
18199 /* Fixup die_parent for the abstract instance of a nested
18200 inline function. */
18201 if (old_die
&& old_die
->die_parent
== NULL
)
18202 add_child_die (context_die
, old_die
);
18204 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18205 add_abstract_origin_attribute (subr_die
, origin
);
18206 /* This is where the actual code for a cloned function is.
18207 Let's emit linkage name attribute for it. This helps
18208 debuggers to e.g, set breakpoints into
18209 constructors/destructors when the user asks "break
18211 add_linkage_name (subr_die
, decl
);
18215 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18216 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18218 if (!get_AT_flag (old_die
, DW_AT_declaration
)
18219 /* We can have a normal definition following an inline one in the
18220 case of redefinition of GNU C extern inlines.
18221 It seems reasonable to use AT_specification in this case. */
18222 && !get_AT (old_die
, DW_AT_inline
))
18224 /* Detect and ignore this case, where we are trying to output
18225 something we have already output. */
18229 /* If the definition comes from the same place as the declaration,
18230 maybe use the old DIE. We always want the DIE for this function
18231 that has the *_pc attributes to be under comp_unit_die so the
18232 debugger can find it. We also need to do this for abstract
18233 instances of inlines, since the spec requires the out-of-line copy
18234 to have the same parent. For local class methods, this doesn't
18235 apply; we just use the old DIE. */
18236 if ((is_cu_die (old_die
->die_parent
) || context_die
== NULL
)
18237 && (DECL_ARTIFICIAL (decl
)
18238 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
18239 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
18240 == (unsigned) s
.line
))))
18242 subr_die
= old_die
;
18244 /* Clear out the declaration attribute and the formal parameters.
18245 Do not remove all children, because it is possible that this
18246 declaration die was forced using force_decl_die(). In such
18247 cases die that forced declaration die (e.g. TAG_imported_module)
18248 is one of the children that we do not want to remove. */
18249 remove_AT (subr_die
, DW_AT_declaration
);
18250 remove_AT (subr_die
, DW_AT_object_pointer
);
18251 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
18255 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18256 add_AT_specification (subr_die
, old_die
);
18257 add_pubname (decl
, subr_die
);
18258 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18259 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
18260 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18261 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
18263 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
18264 emit the real type on the definition die. */
18265 if (is_cxx() && debug_info_level
> DINFO_LEVEL_TERSE
)
18267 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
18268 if (die
== auto_die
|| die
== decltype_auto_die
)
18269 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18270 TYPE_UNQUALIFIED
, context_die
);
18276 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18278 if (TREE_PUBLIC (decl
))
18279 add_AT_flag (subr_die
, DW_AT_external
, 1);
18281 add_name_and_src_coords_attributes (subr_die
, decl
);
18282 add_pubname (decl
, subr_die
);
18283 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18285 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
18286 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18287 TYPE_UNQUALIFIED
, context_die
);
18290 add_pure_or_virtual_attribute (subr_die
, decl
);
18291 if (DECL_ARTIFICIAL (decl
))
18292 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18294 add_accessibility_attribute (subr_die
, decl
);
18299 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18301 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
18303 /* If this is an explicit function declaration then generate
18304 a DW_AT_explicit attribute. */
18305 if (lang_hooks
.decls
.function_decl_explicit_p (decl
)
18306 && (dwarf_version
>= 3 || !dwarf_strict
))
18307 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
18309 /* The first time we see a member function, it is in the context of
18310 the class to which it belongs. We make sure of this by emitting
18311 the class first. The next time is the definition, which is
18312 handled above. The two may come from the same source text.
18314 Note that force_decl_die() forces function declaration die. It is
18315 later reused to represent definition. */
18316 equate_decl_number_to_die (decl
, subr_die
);
18319 else if (DECL_ABSTRACT_P (decl
))
18321 if (DECL_DECLARED_INLINE_P (decl
))
18323 if (cgraph_function_possibly_inlined_p (decl
))
18324 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
18326 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
18330 if (cgraph_function_possibly_inlined_p (decl
))
18331 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
18333 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
18336 if (DECL_DECLARED_INLINE_P (decl
)
18337 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
18338 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18340 equate_decl_number_to_die (decl
, subr_die
);
18342 else if (!DECL_EXTERNAL (decl
))
18344 HOST_WIDE_INT cfa_fb_offset
;
18345 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
18347 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18348 equate_decl_number_to_die (decl
, subr_die
);
18350 gcc_checking_assert (fun
);
18351 if (!flag_reorder_blocks_and_partition
)
18353 dw_fde_ref fde
= fun
->fde
;
18354 if (fde
->dw_fde_begin
)
18356 /* We have already generated the labels. */
18357 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18358 fde
->dw_fde_end
, false);
18362 /* Create start/end labels and add the range. */
18363 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
18364 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
18365 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
18366 current_function_funcdef_no
);
18367 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
18368 current_function_funcdef_no
);
18369 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
18373 #if VMS_DEBUGGING_INFO
18374 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18375 Section 2.3 Prologue and Epilogue Attributes:
18376 When a breakpoint is set on entry to a function, it is generally
18377 desirable for execution to be suspended, not on the very first
18378 instruction of the function, but rather at a point after the
18379 function's frame has been set up, after any language defined local
18380 declaration processing has been completed, and before execution of
18381 the first statement of the function begins. Debuggers generally
18382 cannot properly determine where this point is. Similarly for a
18383 breakpoint set on exit from a function. The prologue and epilogue
18384 attributes allow a compiler to communicate the location(s) to use. */
18387 if (fde
->dw_fde_vms_end_prologue
)
18388 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
18389 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
18391 if (fde
->dw_fde_vms_begin_epilogue
)
18392 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
18393 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
18400 /* Generate pubnames entries for the split function code ranges. */
18401 dw_fde_ref fde
= fun
->fde
;
18403 if (fde
->dw_fde_second_begin
)
18405 if (dwarf_version
>= 3 || !dwarf_strict
)
18407 /* We should use ranges for non-contiguous code section
18408 addresses. Use the actual code range for the initial
18409 section, since the HOT/COLD labels might precede an
18410 alignment offset. */
18411 bool range_list_added
= false;
18412 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
18413 fde
->dw_fde_end
, &range_list_added
,
18415 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
18416 fde
->dw_fde_second_end
,
18417 &range_list_added
, false);
18418 if (range_list_added
)
18423 /* There is no real support in DW2 for this .. so we make
18424 a work-around. First, emit the pub name for the segment
18425 containing the function label. Then make and emit a
18426 simplified subprogram DIE for the second segment with the
18427 name pre-fixed by __hot/cold_sect_of_. We use the same
18428 linkage name for the second die so that gdb will find both
18429 sections when given "b foo". */
18430 const char *name
= NULL
;
18431 tree decl_name
= DECL_NAME (decl
);
18432 dw_die_ref seg_die
;
18434 /* Do the 'primary' section. */
18435 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18436 fde
->dw_fde_end
, false);
18438 /* Build a minimal DIE for the secondary section. */
18439 seg_die
= new_die (DW_TAG_subprogram
,
18440 subr_die
->die_parent
, decl
);
18442 if (TREE_PUBLIC (decl
))
18443 add_AT_flag (seg_die
, DW_AT_external
, 1);
18445 if (decl_name
!= NULL
18446 && IDENTIFIER_POINTER (decl_name
) != NULL
)
18448 name
= dwarf2_name (decl
, 1);
18449 if (! DECL_ARTIFICIAL (decl
))
18450 add_src_coords_attributes (seg_die
, decl
);
18452 add_linkage_name (seg_die
, decl
);
18454 gcc_assert (name
!= NULL
);
18455 add_pure_or_virtual_attribute (seg_die
, decl
);
18456 if (DECL_ARTIFICIAL (decl
))
18457 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
18459 name
= concat ("__second_sect_of_", name
, NULL
);
18460 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
18461 fde
->dw_fde_second_end
, false);
18462 add_name_attribute (seg_die
, name
);
18463 if (want_pubnames ())
18464 add_pubname_string (name
, seg_die
);
18468 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
18472 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
18474 /* We define the "frame base" as the function's CFA. This is more
18475 convenient for several reasons: (1) It's stable across the prologue
18476 and epilogue, which makes it better than just a frame pointer,
18477 (2) With dwarf3, there exists a one-byte encoding that allows us
18478 to reference the .debug_frame data by proxy, but failing that,
18479 (3) We can at least reuse the code inspection and interpretation
18480 code that determines the CFA position at various points in the
18482 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
18484 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
18485 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
18489 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
18490 if (list
->dw_loc_next
)
18491 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
18493 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
18496 /* Compute a displacement from the "steady-state frame pointer" to
18497 the CFA. The former is what all stack slots and argument slots
18498 will reference in the rtl; the latter is what we've told the
18499 debugger about. We'll need to adjust all frame_base references
18500 by this displacement. */
18501 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
18503 if (fun
->static_chain_decl
)
18504 add_AT_location_description (subr_die
, DW_AT_static_link
,
18505 loc_list_from_tree (fun
->static_chain_decl
, 2));
18508 /* Generate child dies for template paramaters. */
18509 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18510 gen_generic_params_dies (decl
);
18512 /* Now output descriptions of the arguments for this function. This gets
18513 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18514 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18515 `...' at the end of the formal parameter list. In order to find out if
18516 there was a trailing ellipsis or not, we must instead look at the type
18517 associated with the FUNCTION_DECL. This will be a node of type
18518 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18519 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18520 an ellipsis at the end. */
18522 /* In the case where we are describing a mere function declaration, all we
18523 need to do here (and all we *can* do here) is to describe the *types* of
18524 its formal parameters. */
18525 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
18527 else if (declaration
)
18528 gen_formal_types_die (decl
, subr_die
);
18531 /* Generate DIEs to represent all known formal parameters. */
18532 tree parm
= DECL_ARGUMENTS (decl
);
18533 tree generic_decl
= lang_hooks
.decls
.get_generic_function_decl (decl
);
18534 tree generic_decl_parm
= generic_decl
18535 ? DECL_ARGUMENTS (generic_decl
)
18538 /* Now we want to walk the list of parameters of the function and
18539 emit their relevant DIEs.
18541 We consider the case of DECL being an instance of a generic function
18542 as well as it being a normal function.
18544 If DECL is an instance of a generic function we walk the
18545 parameters of the generic function declaration _and_ the parameters of
18546 DECL itself. This is useful because we want to emit specific DIEs for
18547 function parameter packs and those are declared as part of the
18548 generic function declaration. In that particular case,
18549 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18550 That DIE has children DIEs representing the set of arguments
18551 of the pack. Note that the set of pack arguments can be empty.
18552 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18555 Otherwise, we just consider the parameters of DECL. */
18556 while (generic_decl_parm
|| parm
)
18558 if (generic_decl_parm
18559 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
18560 gen_formal_parameter_pack_die (generic_decl_parm
,
18565 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, subr_die
);
18567 if (parm
== DECL_ARGUMENTS (decl
)
18568 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
18570 && (dwarf_version
>= 3 || !dwarf_strict
))
18571 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
18573 parm
= DECL_CHAIN (parm
);
18576 if (generic_decl_parm
)
18577 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
18580 /* Decide whether we need an unspecified_parameters DIE at the end.
18581 There are 2 more cases to do this for: 1) the ansi ... declaration -
18582 this is detectable when the end of the arg list is not a
18583 void_type_node 2) an unprototyped function declaration (not a
18584 definition). This just means that we have no info about the
18585 parameters at all. */
18586 if (prototype_p (TREE_TYPE (decl
)))
18588 /* This is the prototyped case, check for.... */
18589 if (stdarg_p (TREE_TYPE (decl
)))
18590 gen_unspecified_parameters_die (decl
, subr_die
);
18592 else if (DECL_INITIAL (decl
) == NULL_TREE
)
18593 gen_unspecified_parameters_die (decl
, subr_die
);
18596 /* Output Dwarf info for all of the stuff within the body of the function
18597 (if it has one - it may be just a declaration). */
18598 outer_scope
= DECL_INITIAL (decl
);
18600 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18601 a function. This BLOCK actually represents the outermost binding contour
18602 for the function, i.e. the contour in which the function's formal
18603 parameters and labels get declared. Curiously, it appears that the front
18604 end doesn't actually put the PARM_DECL nodes for the current function onto
18605 the BLOCK_VARS list for this outer scope, but are strung off of the
18606 DECL_ARGUMENTS list for the function instead.
18608 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18609 the LABEL_DECL nodes for the function however, and we output DWARF info
18610 for those in decls_for_scope. Just within the `outer_scope' there will be
18611 a BLOCK node representing the function's outermost pair of curly braces,
18612 and any blocks used for the base and member initializers of a C++
18613 constructor function. */
18614 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
18616 int call_site_note_count
= 0;
18617 int tail_call_site_note_count
= 0;
18619 /* Emit a DW_TAG_variable DIE for a named return value. */
18620 if (DECL_NAME (DECL_RESULT (decl
)))
18621 gen_decl_die (DECL_RESULT (decl
), NULL
, subr_die
);
18623 current_function_has_inlines
= 0;
18624 decls_for_scope (outer_scope
, subr_die
, 0);
18626 if (call_arg_locations
&& !dwarf_strict
)
18628 struct call_arg_loc_node
*ca_loc
;
18629 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
18631 dw_die_ref die
= NULL
;
18632 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
18635 for (arg
= NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
);
18636 arg
; arg
= next_arg
)
18638 dw_loc_descr_ref reg
, val
;
18639 enum machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
18640 dw_die_ref cdie
, tdie
= NULL
;
18642 next_arg
= XEXP (arg
, 1);
18643 if (REG_P (XEXP (XEXP (arg
, 0), 0))
18645 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
18646 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
18647 && REGNO (XEXP (XEXP (arg
, 0), 0))
18648 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
18649 next_arg
= XEXP (next_arg
, 1);
18650 if (mode
== VOIDmode
)
18652 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
18653 if (mode
== VOIDmode
)
18654 mode
= GET_MODE (XEXP (arg
, 0));
18656 if (mode
== VOIDmode
|| mode
== BLKmode
)
18658 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
18660 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18661 tloc
= XEXP (XEXP (arg
, 0), 1);
18664 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
18665 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
18667 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18668 tlocc
= XEXP (XEXP (arg
, 0), 1);
18672 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
18673 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
18674 VAR_INIT_STATUS_INITIALIZED
);
18675 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
18677 rtx mem
= XEXP (XEXP (arg
, 0), 0);
18678 reg
= mem_loc_descriptor (XEXP (mem
, 0),
18679 get_address_mode (mem
),
18681 VAR_INIT_STATUS_INITIALIZED
);
18683 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
18684 == DEBUG_PARAMETER_REF
)
18687 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
18688 tdie
= lookup_decl_die (tdecl
);
18695 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
18696 != DEBUG_PARAMETER_REF
)
18698 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
18700 VAR_INIT_STATUS_INITIALIZED
);
18704 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18705 cdie
= new_die (DW_TAG_GNU_call_site_parameter
, die
,
18708 add_AT_loc (cdie
, DW_AT_location
, reg
);
18709 else if (tdie
!= NULL
)
18710 add_AT_die_ref (cdie
, DW_AT_abstract_origin
, tdie
);
18711 add_AT_loc (cdie
, DW_AT_GNU_call_site_value
, val
);
18712 if (next_arg
!= XEXP (arg
, 1))
18714 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
18715 if (mode
== VOIDmode
)
18716 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
18717 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
18720 VAR_INIT_STATUS_INITIALIZED
);
18722 add_AT_loc (cdie
, DW_AT_GNU_call_site_data_value
, val
);
18726 && (ca_loc
->symbol_ref
|| tloc
))
18727 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18728 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
18730 dw_loc_descr_ref tval
= NULL
;
18732 if (tloc
!= NULL_RTX
)
18733 tval
= mem_loc_descriptor (tloc
,
18734 GET_MODE (tloc
) == VOIDmode
18735 ? Pmode
: GET_MODE (tloc
),
18737 VAR_INIT_STATUS_INITIALIZED
);
18739 add_AT_loc (die
, DW_AT_GNU_call_site_target
, tval
);
18740 else if (tlocc
!= NULL_RTX
)
18742 tval
= mem_loc_descriptor (tlocc
,
18743 GET_MODE (tlocc
) == VOIDmode
18744 ? Pmode
: GET_MODE (tlocc
),
18746 VAR_INIT_STATUS_INITIALIZED
);
18748 add_AT_loc (die
, DW_AT_GNU_call_site_target_clobbered
,
18754 call_site_note_count
++;
18755 if (ca_loc
->tail_call_p
)
18756 tail_call_site_note_count
++;
18760 call_arg_locations
= NULL
;
18761 call_arg_loc_last
= NULL
;
18762 if (tail_call_site_count
>= 0
18763 && tail_call_site_count
== tail_call_site_note_count
18766 if (call_site_count
>= 0
18767 && call_site_count
== call_site_note_count
)
18768 add_AT_flag (subr_die
, DW_AT_GNU_all_call_sites
, 1);
18770 add_AT_flag (subr_die
, DW_AT_GNU_all_tail_call_sites
, 1);
18772 call_site_count
= -1;
18773 tail_call_site_count
= -1;
18776 if (subr_die
!= old_die
)
18777 /* Add the calling convention attribute if requested. */
18778 add_calling_convention_attribute (subr_die
, decl
);
18781 /* Returns a hash value for X (which really is a die_struct). */
18784 common_block_die_table_hash (const void *x
)
18786 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18787 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
18790 /* Return nonzero if decl_id and die_parent of die_struct X is the same
18791 as decl_id and die_parent of die_struct Y. */
18794 common_block_die_table_eq (const void *x
, const void *y
)
18796 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18797 const_dw_die_ref e
= (const_dw_die_ref
) y
;
18798 return d
->decl_id
== e
->decl_id
&& d
->die_parent
== e
->die_parent
;
18801 /* Generate a DIE to represent a declared data object.
18802 Either DECL or ORIGIN must be non-null. */
18805 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
18807 HOST_WIDE_INT off
= 0;
18809 tree decl_or_origin
= decl
? decl
: origin
;
18810 tree ultimate_origin
;
18811 dw_die_ref var_die
;
18812 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
18813 dw_die_ref origin_die
;
18814 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
18815 || class_or_namespace_scope_p (context_die
));
18816 bool specialization_p
= false;
18818 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
18819 if (decl
|| ultimate_origin
)
18820 origin
= ultimate_origin
;
18821 com_decl
= fortran_common (decl_or_origin
, &off
);
18823 /* Symbol in common gets emitted as a child of the common block, in the form
18824 of a data member. */
18827 dw_die_ref com_die
;
18828 dw_loc_list_ref loc
;
18829 die_node com_die_arg
;
18831 var_die
= lookup_decl_die (decl_or_origin
);
18834 if (get_AT (var_die
, DW_AT_location
) == NULL
)
18836 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2);
18841 /* Optimize the common case. */
18842 if (single_element_loc_list_p (loc
)
18843 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18844 && loc
->expr
->dw_loc_next
== NULL
18845 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
18848 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18849 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18850 = plus_constant (GET_MODE (x
), x
, off
);
18853 loc_list_plus_const (loc
, off
);
18855 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18856 remove_AT (var_die
, DW_AT_declaration
);
18862 if (common_block_die_table
== NULL
)
18863 common_block_die_table
18864 = htab_create_ggc (10, common_block_die_table_hash
,
18865 common_block_die_table_eq
, NULL
);
18867 com_die_arg
.decl_id
= DECL_UID (com_decl
);
18868 com_die_arg
.die_parent
= context_die
;
18869 com_die
= (dw_die_ref
) htab_find (common_block_die_table
, &com_die_arg
);
18870 loc
= loc_list_from_tree (com_decl
, 2);
18871 if (com_die
== NULL
)
18874 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
18877 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
18878 add_name_and_src_coords_attributes (com_die
, com_decl
);
18881 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18882 /* Avoid sharing the same loc descriptor between
18883 DW_TAG_common_block and DW_TAG_variable. */
18884 loc
= loc_list_from_tree (com_decl
, 2);
18886 else if (DECL_EXTERNAL (decl
))
18887 add_AT_flag (com_die
, DW_AT_declaration
, 1);
18888 if (want_pubnames ())
18889 add_pubname_string (cnam
, com_die
); /* ??? needed? */
18890 com_die
->decl_id
= DECL_UID (com_decl
);
18891 slot
= htab_find_slot (common_block_die_table
, com_die
, INSERT
);
18892 *slot
= (void *) com_die
;
18894 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
18896 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18897 loc
= loc_list_from_tree (com_decl
, 2);
18898 remove_AT (com_die
, DW_AT_declaration
);
18900 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
18901 add_name_and_src_coords_attributes (var_die
, decl
);
18902 add_type_attribute (var_die
, TREE_TYPE (decl
), decl_quals (decl
),
18904 add_AT_flag (var_die
, DW_AT_external
, 1);
18909 /* Optimize the common case. */
18910 if (single_element_loc_list_p (loc
)
18911 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18912 && loc
->expr
->dw_loc_next
== NULL
18913 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
18915 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18916 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18917 = plus_constant (GET_MODE (x
), x
, off
);
18920 loc_list_plus_const (loc
, off
);
18922 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18924 else if (DECL_EXTERNAL (decl
))
18925 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18926 equate_decl_number_to_die (decl
, var_die
);
18930 /* If the compiler emitted a definition for the DECL declaration
18931 and if we already emitted a DIE for it, don't emit a second
18932 DIE for it again. Allow re-declarations of DECLs that are
18933 inside functions, though. */
18934 if (old_die
&& declaration
&& !local_scope_p (context_die
))
18937 /* For static data members, the declaration in the class is supposed
18938 to have DW_TAG_member tag; the specification should still be
18939 DW_TAG_variable referencing the DW_TAG_member DIE. */
18940 if (declaration
&& class_scope_p (context_die
))
18941 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
18943 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
18946 if (origin
!= NULL
)
18947 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
18949 /* Loop unrolling can create multiple blocks that refer to the same
18950 static variable, so we must test for the DW_AT_declaration flag.
18952 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
18953 copy decls and set the DECL_ABSTRACT_P flag on them instead of
18956 ??? Duplicated blocks have been rewritten to use .debug_ranges.
18958 ??? The declare_in_namespace support causes us to get two DIEs for one
18959 variable, both of which are declarations. We want to avoid considering
18960 one to be a specification, so we must test that this DIE is not a
18962 else if (old_die
&& TREE_STATIC (decl
) && ! declaration
18963 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
18965 /* This is a definition of a C++ class level static. */
18966 add_AT_specification (var_die
, old_die
);
18967 specialization_p
= true;
18968 if (DECL_NAME (decl
))
18970 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18971 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18973 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18974 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
18976 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18977 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
18979 if (old_die
->die_tag
== DW_TAG_member
)
18980 add_linkage_name (var_die
, decl
);
18984 add_name_and_src_coords_attributes (var_die
, decl
);
18986 if ((origin
== NULL
&& !specialization_p
)
18988 && !DECL_ABSTRACT_P (decl_or_origin
)
18989 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
18990 decl_function_context
18991 (decl_or_origin
))))
18993 tree type
= TREE_TYPE (decl_or_origin
);
18995 if (decl_by_reference_p (decl_or_origin
))
18996 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
,
18999 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
19003 if (origin
== NULL
&& !specialization_p
)
19005 if (TREE_PUBLIC (decl
))
19006 add_AT_flag (var_die
, DW_AT_external
, 1);
19008 if (DECL_ARTIFICIAL (decl
))
19009 add_AT_flag (var_die
, DW_AT_artificial
, 1);
19011 add_accessibility_attribute (var_die
, decl
);
19015 add_AT_flag (var_die
, DW_AT_declaration
, 1);
19017 if (decl
&& (DECL_ABSTRACT_P (decl
) || declaration
|| old_die
== NULL
))
19018 equate_decl_number_to_die (decl
, var_die
);
19021 && (! DECL_ABSTRACT_P (decl_or_origin
)
19022 /* Local static vars are shared between all clones/inlines,
19023 so emit DW_AT_location on the abstract DIE if DECL_RTL is
19025 || (TREE_CODE (decl_or_origin
) == VAR_DECL
19026 && TREE_STATIC (decl_or_origin
)
19027 && DECL_RTL_SET_P (decl_or_origin
)))
19028 /* When abstract origin already has DW_AT_location attribute, no need
19029 to add it again. */
19030 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
19032 if (TREE_CODE (decl_or_origin
) == VAR_DECL
&& TREE_STATIC (decl_or_origin
)
19033 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin
)))
19034 defer_location (decl_or_origin
, var_die
);
19036 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
19037 decl
== NULL
, DW_AT_location
);
19038 add_pubname (decl_or_origin
, var_die
);
19041 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
19044 /* Generate a DIE to represent a named constant. */
19047 gen_const_die (tree decl
, dw_die_ref context_die
)
19049 dw_die_ref const_die
;
19050 tree type
= TREE_TYPE (decl
);
19052 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
19053 add_name_and_src_coords_attributes (const_die
, decl
);
19054 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, context_die
);
19055 if (TREE_PUBLIC (decl
))
19056 add_AT_flag (const_die
, DW_AT_external
, 1);
19057 if (DECL_ARTIFICIAL (decl
))
19058 add_AT_flag (const_die
, DW_AT_artificial
, 1);
19059 tree_add_const_value_attribute_for_decl (const_die
, decl
);
19062 /* Generate a DIE to represent a label identifier. */
19065 gen_label_die (tree decl
, dw_die_ref context_die
)
19067 tree origin
= decl_ultimate_origin (decl
);
19068 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
19070 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
19072 if (origin
!= NULL
)
19073 add_abstract_origin_attribute (lbl_die
, origin
);
19075 add_name_and_src_coords_attributes (lbl_die
, decl
);
19077 if (DECL_ABSTRACT_P (decl
))
19078 equate_decl_number_to_die (decl
, lbl_die
);
19081 insn
= DECL_RTL_IF_SET (decl
);
19083 /* Deleted labels are programmer specified labels which have been
19084 eliminated because of various optimizations. We still emit them
19085 here so that it is possible to put breakpoints on them. */
19089 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
19091 /* When optimization is enabled (via -O) some parts of the compiler
19092 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19093 represent source-level labels which were explicitly declared by
19094 the user. This really shouldn't be happening though, so catch
19095 it if it ever does happen. */
19096 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
19098 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
19099 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
19103 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
19104 && CODE_LABEL_NUMBER (insn
) != -1)
19106 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
19107 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
19112 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19113 attributes to the DIE for a block STMT, to describe where the inlined
19114 function was called from. This is similar to add_src_coords_attributes. */
19117 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
19119 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
19121 if (dwarf_version
>= 3 || !dwarf_strict
)
19123 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
19124 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
19129 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19130 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19133 add_high_low_attributes (tree stmt
, dw_die_ref die
)
19135 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
19137 if (BLOCK_FRAGMENT_CHAIN (stmt
)
19138 && (dwarf_version
>= 3 || !dwarf_strict
))
19140 tree chain
, superblock
= NULL_TREE
;
19142 dw_attr_ref attr
= NULL
;
19144 if (inlined_function_outer_scope_p (stmt
))
19146 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19147 BLOCK_NUMBER (stmt
));
19148 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
19151 /* Optimize duplicate .debug_ranges lists or even tails of
19152 lists. If this BLOCK has same ranges as its supercontext,
19153 lookup DW_AT_ranges attribute in the supercontext (and
19154 recursively so), verify that the ranges_table contains the
19155 right values and use it instead of adding a new .debug_range. */
19156 for (chain
= stmt
, pdie
= die
;
19157 BLOCK_SAME_RANGE (chain
);
19158 chain
= BLOCK_SUPERCONTEXT (chain
))
19160 dw_attr_ref new_attr
;
19162 pdie
= pdie
->die_parent
;
19165 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
19167 new_attr
= get_AT (pdie
, DW_AT_ranges
);
19168 if (new_attr
== NULL
19169 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
19172 superblock
= BLOCK_SUPERCONTEXT (chain
);
19175 && (ranges_table
[attr
->dw_attr_val
.v
.val_offset
19176 / 2 / DWARF2_ADDR_SIZE
].num
19177 == BLOCK_NUMBER (superblock
))
19178 && BLOCK_FRAGMENT_CHAIN (superblock
))
19180 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
19181 / 2 / DWARF2_ADDR_SIZE
;
19182 unsigned long supercnt
= 0, thiscnt
= 0;
19183 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
19184 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
19187 gcc_checking_assert (ranges_table
[off
+ supercnt
].num
19188 == BLOCK_NUMBER (chain
));
19190 gcc_checking_assert (ranges_table
[off
+ supercnt
+ 1].num
== 0);
19191 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19192 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
19194 gcc_assert (supercnt
>= thiscnt
);
19195 add_AT_range_list (die
, DW_AT_ranges
,
19196 ((off
+ supercnt
- thiscnt
)
19197 * 2 * DWARF2_ADDR_SIZE
),
19202 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
), false);
19204 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19207 add_ranges (chain
);
19208 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
19215 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
19216 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19217 BLOCK_NUMBER (stmt
));
19218 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
19219 BLOCK_NUMBER (stmt
));
19220 add_AT_low_high_pc (die
, label
, label_high
, false);
19224 /* Generate a DIE for a lexical block. */
19227 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19229 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
19231 if (call_arg_locations
)
19233 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19234 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19235 block_map
[BLOCK_NUMBER (stmt
)] = stmt_die
;
19238 if (! BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
19239 add_high_low_attributes (stmt
, stmt_die
);
19241 decls_for_scope (stmt
, stmt_die
, depth
);
19244 /* Generate a DIE for an inlined subprogram. */
19247 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
19251 /* The instance of function that is effectively being inlined shall not
19253 gcc_assert (! BLOCK_ABSTRACT (stmt
));
19255 decl
= block_ultimate_origin (stmt
);
19257 /* Emit info for the abstract instance first, if we haven't yet. We
19258 must emit this even if the block is abstract, otherwise when we
19259 emit the block below (or elsewhere), we may end up trying to emit
19260 a die whose origin die hasn't been emitted, and crashing. */
19261 dwarf2out_abstract_function (decl
);
19263 if (! BLOCK_ABSTRACT (stmt
))
19265 dw_die_ref subr_die
19266 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
19268 if (call_arg_locations
)
19270 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19271 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19272 block_map
[BLOCK_NUMBER (stmt
)] = subr_die
;
19274 add_abstract_origin_attribute (subr_die
, decl
);
19275 if (TREE_ASM_WRITTEN (stmt
))
19276 add_high_low_attributes (stmt
, subr_die
);
19277 add_call_src_coords_attributes (stmt
, subr_die
);
19279 decls_for_scope (stmt
, subr_die
, depth
);
19280 current_function_has_inlines
= 1;
19284 /* Generate a DIE for a field in a record, or structure. */
19287 gen_field_die (tree decl
, dw_die_ref context_die
)
19289 dw_die_ref decl_die
;
19291 if (TREE_TYPE (decl
) == error_mark_node
)
19294 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
19295 add_name_and_src_coords_attributes (decl_die
, decl
);
19296 add_type_attribute (decl_die
, member_declared_type (decl
),
19297 decl_quals (decl
), context_die
);
19299 if (DECL_BIT_FIELD_TYPE (decl
))
19301 add_byte_size_attribute (decl_die
, decl
);
19302 add_bit_size_attribute (decl_die
, decl
);
19303 add_bit_offset_attribute (decl_die
, decl
);
19306 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
19307 add_data_member_location_attribute (decl_die
, decl
);
19309 if (DECL_ARTIFICIAL (decl
))
19310 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
19312 add_accessibility_attribute (decl_die
, decl
);
19314 /* Equate decl number to die, so that we can look up this decl later on. */
19315 equate_decl_number_to_die (decl
, decl_die
);
19319 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19320 Use modified_type_die instead.
19321 We keep this code here just in case these types of DIEs may be needed to
19322 represent certain things in other languages (e.g. Pascal) someday. */
19325 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
19328 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
19330 equate_type_number_to_die (type
, ptr_die
);
19331 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
,
19333 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19336 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19337 Use modified_type_die instead.
19338 We keep this code here just in case these types of DIEs may be needed to
19339 represent certain things in other languages (e.g. Pascal) someday. */
19342 gen_reference_type_die (tree type
, dw_die_ref context_die
)
19344 dw_die_ref ref_die
, scope_die
= scope_die_for (type
, context_die
);
19346 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
19347 ref_die
= new_die (DW_TAG_rvalue_reference_type
, scope_die
, type
);
19349 ref_die
= new_die (DW_TAG_reference_type
, scope_die
, type
);
19351 equate_type_number_to_die (type
, ref_die
);
19352 add_type_attribute (ref_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
,
19354 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19358 /* Generate a DIE for a pointer to a member type. */
19361 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
19364 = new_die (DW_TAG_ptr_to_member_type
,
19365 scope_die_for (type
, context_die
), type
);
19367 equate_type_number_to_die (type
, ptr_die
);
19368 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
19369 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
19370 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
,
19374 typedef const char *dchar_p
; /* For DEF_VEC_P. */
19376 static char *producer_string
;
19378 /* Return a heap allocated producer string including command line options
19379 if -grecord-gcc-switches. */
19382 gen_producer_string (void)
19385 auto_vec
<dchar_p
> switches
;
19386 const char *language_string
= lang_hooks
.name
;
19387 char *producer
, *tail
;
19389 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
19390 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
19392 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
19393 switch (save_decoded_options
[j
].opt_index
)
19400 case OPT_auxbase_strip
:
19409 case OPT_SPECIAL_unknown
:
19410 case OPT_SPECIAL_ignore
:
19411 case OPT_SPECIAL_program_name
:
19412 case OPT_SPECIAL_input_file
:
19413 case OPT_grecord_gcc_switches
:
19414 case OPT_gno_record_gcc_switches
:
19415 case OPT__output_pch_
:
19416 case OPT_fdiagnostics_show_location_
:
19417 case OPT_fdiagnostics_show_option
:
19418 case OPT_fdiagnostics_show_caret
:
19419 case OPT_fdiagnostics_color_
:
19420 case OPT_fverbose_asm
:
19422 case OPT__sysroot_
:
19424 case OPT_nostdinc__
:
19425 /* Ignore these. */
19428 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
19429 & CL_NO_DWARF_RECORD
)
19431 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
19433 switch (save_decoded_options
[j
].canonical_option
[0][1])
19440 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
19447 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
19448 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
19452 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
19454 sprintf (tail
, "%s %s", language_string
, version_string
);
19457 FOR_EACH_VEC_ELT (switches
, j
, p
)
19461 memcpy (tail
+ 1, p
, len
);
19469 /* Generate the DIE for the compilation unit. */
19472 gen_compile_unit_die (const char *filename
)
19475 const char *language_string
= lang_hooks
.name
;
19478 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
19482 add_name_attribute (die
, filename
);
19483 /* Don't add cwd for <built-in>. */
19484 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
19485 add_comp_dir_attribute (die
);
19488 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
19490 /* If our producer is LTO try to figure out a common language to use
19491 from the global list of translation units. */
19492 if (strcmp (language_string
, "GNU GIMPLE") == 0)
19496 const char *common_lang
= NULL
;
19498 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
19500 if (!TRANSLATION_UNIT_LANGUAGE (t
))
19503 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
19504 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
19506 else if (strncmp (common_lang
, "GNU C", 5) == 0
19507 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
19508 /* Mixing C and C++ is ok, use C++ in that case. */
19509 common_lang
= "GNU C++";
19512 /* Fall back to C. */
19513 common_lang
= NULL
;
19519 language_string
= common_lang
;
19522 language
= DW_LANG_C89
;
19523 if (strcmp (language_string
, "GNU C++") == 0)
19524 language
= DW_LANG_C_plus_plus
;
19525 else if (strcmp (language_string
, "GNU F77") == 0)
19526 language
= DW_LANG_Fortran77
;
19527 else if (strcmp (language_string
, "GNU Pascal") == 0)
19528 language
= DW_LANG_Pascal83
;
19529 else if (dwarf_version
>= 3 || !dwarf_strict
)
19531 if (strcmp (language_string
, "GNU Ada") == 0)
19532 language
= DW_LANG_Ada95
;
19533 else if (strcmp (language_string
, "GNU Fortran") == 0)
19534 language
= DW_LANG_Fortran95
;
19535 else if (strcmp (language_string
, "GNU Java") == 0)
19536 language
= DW_LANG_Java
;
19537 else if (strcmp (language_string
, "GNU Objective-C") == 0)
19538 language
= DW_LANG_ObjC
;
19539 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
19540 language
= DW_LANG_ObjC_plus_plus
;
19541 else if (dwarf_version
>= 5 || !dwarf_strict
)
19543 if (strcmp (language_string
, "GNU Go") == 0)
19544 language
= DW_LANG_Go
;
19547 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
19548 else if (strcmp (language_string
, "GNU Fortran") == 0)
19549 language
= DW_LANG_Fortran90
;
19551 add_AT_unsigned (die
, DW_AT_language
, language
);
19555 case DW_LANG_Fortran77
:
19556 case DW_LANG_Fortran90
:
19557 case DW_LANG_Fortran95
:
19558 /* Fortran has case insensitive identifiers and the front-end
19559 lowercases everything. */
19560 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
19563 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19569 /* Generate the DIE for a base class. */
19572 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
19574 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
19576 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, context_die
);
19577 add_data_member_location_attribute (die
, binfo
);
19579 if (BINFO_VIRTUAL_P (binfo
))
19580 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
19582 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19583 children, otherwise the default is DW_ACCESS_public. In DWARF2
19584 the default has always been DW_ACCESS_private. */
19585 if (access
== access_public_node
)
19587 if (dwarf_version
== 2
19588 || context_die
->die_tag
== DW_TAG_class_type
)
19589 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19591 else if (access
== access_protected_node
)
19592 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19593 else if (dwarf_version
> 2
19594 && context_die
->die_tag
!= DW_TAG_class_type
)
19595 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19598 /* Generate a DIE for a class member. */
19601 gen_member_die (tree type
, dw_die_ref context_die
)
19604 tree binfo
= TYPE_BINFO (type
);
19607 /* If this is not an incomplete type, output descriptions of each of its
19608 members. Note that as we output the DIEs necessary to represent the
19609 members of this record or union type, we will also be trying to output
19610 DIEs to represent the *types* of those members. However the `type'
19611 function (above) will specifically avoid generating type DIEs for member
19612 types *within* the list of member DIEs for this (containing) type except
19613 for those types (of members) which are explicitly marked as also being
19614 members of this (containing) type themselves. The g++ front- end can
19615 force any given type to be treated as a member of some other (containing)
19616 type by setting the TYPE_CONTEXT of the given (member) type to point to
19617 the TREE node representing the appropriate (containing) type. */
19619 /* First output info about the base classes. */
19622 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
19626 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
19627 gen_inheritance_die (base
,
19628 (accesses
? (*accesses
)[i
] : access_public_node
),
19632 /* Now output info about the data members and type members. */
19633 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
19635 /* If we thought we were generating minimal debug info for TYPE
19636 and then changed our minds, some of the member declarations
19637 may have already been defined. Don't define them again, but
19638 do put them in the right order. */
19640 child
= lookup_decl_die (member
);
19642 splice_child_die (context_die
, child
);
19644 gen_decl_die (member
, NULL
, context_die
);
19647 /* Now output info about the function members (if any). */
19648 for (member
= TYPE_METHODS (type
); member
; member
= DECL_CHAIN (member
))
19650 /* Don't include clones in the member list. */
19651 if (DECL_ABSTRACT_ORIGIN (member
))
19654 child
= lookup_decl_die (member
);
19656 splice_child_die (context_die
, child
);
19658 gen_decl_die (member
, NULL
, context_die
);
19662 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19663 is set, we pretend that the type was never defined, so we only get the
19664 member DIEs needed by later specification DIEs. */
19667 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
19668 enum debug_info_usage usage
)
19670 dw_die_ref type_die
= lookup_type_die (type
);
19671 dw_die_ref scope_die
= 0;
19673 int complete
= (TYPE_SIZE (type
)
19674 && (! TYPE_STUB_DECL (type
)
19675 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
19676 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
19677 complete
= complete
&& should_emit_struct_debug (type
, usage
);
19679 if (type_die
&& ! complete
)
19682 if (TYPE_CONTEXT (type
) != NULL_TREE
19683 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19684 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
19687 scope_die
= scope_die_for (type
, context_die
);
19689 /* Generate child dies for template paramaters. */
19690 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
19691 schedule_generic_params_dies_gen (type
);
19693 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
19694 /* First occurrence of type or toplevel definition of nested class. */
19696 dw_die_ref old_die
= type_die
;
19698 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
19699 ? record_type_tag (type
) : DW_TAG_union_type
,
19701 equate_type_number_to_die (type
, type_die
);
19703 add_AT_specification (type_die
, old_die
);
19705 add_name_attribute (type_die
, type_tag (type
));
19708 remove_AT (type_die
, DW_AT_declaration
);
19710 /* If this type has been completed, then give it a byte_size attribute and
19711 then give a list of members. */
19712 if (complete
&& !ns_decl
)
19714 /* Prevent infinite recursion in cases where the type of some member of
19715 this type is expressed in terms of this type itself. */
19716 TREE_ASM_WRITTEN (type
) = 1;
19717 add_byte_size_attribute (type_die
, type
);
19718 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
19720 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
19721 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
19724 /* If the first reference to this type was as the return type of an
19725 inline function, then it may not have a parent. Fix this now. */
19726 if (type_die
->die_parent
== NULL
)
19727 add_child_die (scope_die
, type_die
);
19729 push_decl_scope (type
);
19730 gen_member_die (type
, type_die
);
19733 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
19734 if (TYPE_ARTIFICIAL (type
))
19735 add_AT_flag (type_die
, DW_AT_artificial
, 1);
19737 /* GNU extension: Record what type our vtable lives in. */
19738 if (TYPE_VFIELD (type
))
19740 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
19742 gen_type_die (vtype
, context_die
);
19743 add_AT_die_ref (type_die
, DW_AT_containing_type
,
19744 lookup_type_die (vtype
));
19749 add_AT_flag (type_die
, DW_AT_declaration
, 1);
19751 /* We don't need to do this for function-local types. */
19752 if (TYPE_STUB_DECL (type
)
19753 && ! decl_function_context (TYPE_STUB_DECL (type
)))
19754 vec_safe_push (incomplete_types
, type
);
19757 if (get_AT (type_die
, DW_AT_name
))
19758 add_pubtype (type
, type_die
);
19761 /* Generate a DIE for a subroutine _type_. */
19764 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
19766 tree return_type
= TREE_TYPE (type
);
19767 dw_die_ref subr_die
19768 = new_die (DW_TAG_subroutine_type
,
19769 scope_die_for (type
, context_die
), type
);
19771 equate_type_number_to_die (type
, subr_die
);
19772 add_prototyped_attribute (subr_die
, type
);
19773 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, context_die
);
19774 gen_formal_types_die (type
, subr_die
);
19776 if (get_AT (subr_die
, DW_AT_name
))
19777 add_pubtype (type
, subr_die
);
19780 /* Generate a DIE for a type definition. */
19783 gen_typedef_die (tree decl
, dw_die_ref context_die
)
19785 dw_die_ref type_die
;
19788 if (TREE_ASM_WRITTEN (decl
))
19791 TREE_ASM_WRITTEN (decl
) = 1;
19792 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
19793 origin
= decl_ultimate_origin (decl
);
19794 if (origin
!= NULL
)
19795 add_abstract_origin_attribute (type_die
, origin
);
19800 add_name_and_src_coords_attributes (type_die
, decl
);
19801 if (DECL_ORIGINAL_TYPE (decl
))
19803 type
= DECL_ORIGINAL_TYPE (decl
);
19805 gcc_assert (type
!= TREE_TYPE (decl
));
19806 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
19810 type
= TREE_TYPE (decl
);
19812 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19814 /* Here, we are in the case of decl being a typedef naming
19815 an anonymous type, e.g:
19816 typedef struct {...} foo;
19817 In that case TREE_TYPE (decl) is not a typedef variant
19818 type and TYPE_NAME of the anonymous type is set to the
19819 TYPE_DECL of the typedef. This construct is emitted by
19822 TYPE is the anonymous struct named by the typedef
19823 DECL. As we need the DW_AT_type attribute of the
19824 DW_TAG_typedef to point to the DIE of TYPE, let's
19825 generate that DIE right away. add_type_attribute
19826 called below will then pick (via lookup_type_die) that
19827 anonymous struct DIE. */
19828 if (!TREE_ASM_WRITTEN (type
))
19829 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
19831 /* This is a GNU Extension. We are adding a
19832 DW_AT_linkage_name attribute to the DIE of the
19833 anonymous struct TYPE. The value of that attribute
19834 is the name of the typedef decl naming the anonymous
19835 struct. This greatly eases the work of consumers of
19836 this debug info. */
19837 add_linkage_attr (lookup_type_die (type
), decl
);
19841 add_type_attribute (type_die
, type
, decl_quals (decl
), context_die
);
19843 if (is_naming_typedef_decl (decl
))
19844 /* We want that all subsequent calls to lookup_type_die with
19845 TYPE in argument yield the DW_TAG_typedef we have just
19847 equate_type_number_to_die (type
, type_die
);
19849 add_accessibility_attribute (type_die
, decl
);
19852 if (DECL_ABSTRACT_P (decl
))
19853 equate_decl_number_to_die (decl
, type_die
);
19855 if (get_AT (type_die
, DW_AT_name
))
19856 add_pubtype (decl
, type_die
);
19859 /* Generate a DIE for a struct, class, enum or union type. */
19862 gen_tagged_type_die (tree type
,
19863 dw_die_ref context_die
,
19864 enum debug_info_usage usage
)
19868 if (type
== NULL_TREE
19869 || !is_tagged_type (type
))
19872 /* If this is a nested type whose containing class hasn't been written
19873 out yet, writing it out will cover this one, too. This does not apply
19874 to instantiations of member class templates; they need to be added to
19875 the containing class as they are generated. FIXME: This hurts the
19876 idea of combining type decls from multiple TUs, since we can't predict
19877 what set of template instantiations we'll get. */
19878 if (TYPE_CONTEXT (type
)
19879 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19880 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
19882 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
19884 if (TREE_ASM_WRITTEN (type
))
19887 /* If that failed, attach ourselves to the stub. */
19888 push_decl_scope (TYPE_CONTEXT (type
));
19889 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
19892 else if (TYPE_CONTEXT (type
) != NULL_TREE
19893 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
19895 /* If this type is local to a function that hasn't been written
19896 out yet, use a NULL context for now; it will be fixed up in
19897 decls_for_scope. */
19898 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
19899 /* A declaration DIE doesn't count; nested types need to go in the
19901 if (context_die
&& is_declaration_die (context_die
))
19902 context_die
= NULL
;
19907 context_die
= declare_in_namespace (type
, context_die
);
19911 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
19913 /* This might have been written out by the call to
19914 declare_in_namespace. */
19915 if (!TREE_ASM_WRITTEN (type
))
19916 gen_enumeration_type_die (type
, context_die
);
19919 gen_struct_or_union_type_die (type
, context_die
, usage
);
19924 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
19925 it up if it is ever completed. gen_*_type_die will set it for us
19926 when appropriate. */
19929 /* Generate a type description DIE. */
19932 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
19933 enum debug_info_usage usage
)
19935 struct array_descr_info info
;
19937 if (type
== NULL_TREE
|| type
== error_mark_node
)
19940 if (TYPE_NAME (type
) != NULL_TREE
19941 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
19942 && is_redundant_typedef (TYPE_NAME (type
))
19943 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
19944 /* The DECL of this type is a typedef we don't want to emit debug
19945 info for but we want debug info for its underlying typedef.
19946 This can happen for e.g, the injected-class-name of a C++
19948 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
19950 /* If TYPE is a typedef type variant, let's generate debug info
19951 for the parent typedef which TYPE is a type of. */
19952 if (typedef_variant_p (type
))
19954 if (TREE_ASM_WRITTEN (type
))
19957 /* Prevent broken recursion; we can't hand off to the same type. */
19958 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
19960 /* Give typedefs the right scope. */
19961 context_die
= scope_die_for (type
, context_die
);
19963 TREE_ASM_WRITTEN (type
) = 1;
19965 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19969 /* If type is an anonymous tagged type named by a typedef, let's
19970 generate debug info for the typedef. */
19971 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19973 /* Use the DIE of the containing namespace as the parent DIE of
19974 the type description DIE we want to generate. */
19975 if (DECL_CONTEXT (TYPE_NAME (type
))
19976 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
19977 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
19979 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19983 /* If this is an array type with hidden descriptor, handle it first. */
19984 if (!TREE_ASM_WRITTEN (type
)
19985 && lang_hooks
.types
.get_array_descr_info
19986 && lang_hooks
.types
.get_array_descr_info (type
, &info
)
19987 && (dwarf_version
>= 3 || !dwarf_strict
))
19989 gen_descr_array_type_die (type
, &info
, context_die
);
19990 TREE_ASM_WRITTEN (type
) = 1;
19994 /* We are going to output a DIE to represent the unqualified version
19995 of this type (i.e. without any const or volatile qualifiers) so
19996 get the main variant (i.e. the unqualified version) of this type
19997 now. (Vectors are special because the debugging info is in the
19998 cloned type itself). */
19999 if (TREE_CODE (type
) != VECTOR_TYPE
)
20000 type
= type_main_variant (type
);
20002 if (TREE_ASM_WRITTEN (type
))
20005 switch (TREE_CODE (type
))
20011 case REFERENCE_TYPE
:
20012 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
20013 ensures that the gen_type_die recursion will terminate even if the
20014 type is recursive. Recursive types are possible in Ada. */
20015 /* ??? We could perhaps do this for all types before the switch
20017 TREE_ASM_WRITTEN (type
) = 1;
20019 /* For these types, all that is required is that we output a DIE (or a
20020 set of DIEs) to represent the "basis" type. */
20021 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20022 DINFO_USAGE_IND_USE
);
20026 /* This code is used for C++ pointer-to-data-member types.
20027 Output a description of the relevant class type. */
20028 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
20029 DINFO_USAGE_IND_USE
);
20031 /* Output a description of the type of the object pointed to. */
20032 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20033 DINFO_USAGE_IND_USE
);
20035 /* Now output a DIE to represent this pointer-to-data-member type
20037 gen_ptr_to_mbr_type_die (type
, context_die
);
20040 case FUNCTION_TYPE
:
20041 /* Force out return type (in case it wasn't forced out already). */
20042 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20043 DINFO_USAGE_DIR_USE
);
20044 gen_subroutine_type_die (type
, context_die
);
20048 /* Force out return type (in case it wasn't forced out already). */
20049 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
20050 DINFO_USAGE_DIR_USE
);
20051 gen_subroutine_type_die (type
, context_die
);
20055 gen_array_type_die (type
, context_die
);
20059 gen_array_type_die (type
, context_die
);
20062 case ENUMERAL_TYPE
:
20065 case QUAL_UNION_TYPE
:
20066 gen_tagged_type_die (type
, context_die
, usage
);
20072 case FIXED_POINT_TYPE
:
20075 /* No DIEs needed for fundamental types. */
20080 /* Just use DW_TAG_unspecified_type. */
20082 dw_die_ref type_die
= lookup_type_die (type
);
20083 if (type_die
== NULL
)
20085 tree name
= TYPE_IDENTIFIER (type
);
20086 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
20088 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
20089 equate_type_number_to_die (type
, type_die
);
20095 if (is_cxx_auto (type
))
20097 tree name
= TYPE_IDENTIFIER (type
);
20098 dw_die_ref
*die
= (name
== get_identifier ("auto")
20099 ? &auto_die
: &decltype_auto_die
);
20102 *die
= new_die (DW_TAG_unspecified_type
,
20103 comp_unit_die (), NULL_TREE
);
20104 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
20106 equate_type_number_to_die (type
, *die
);
20109 gcc_unreachable ();
20112 TREE_ASM_WRITTEN (type
) = 1;
20116 gen_type_die (tree type
, dw_die_ref context_die
)
20118 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
20121 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
20122 things which are local to the given block. */
20125 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
20127 int must_output_die
= 0;
20130 /* Ignore blocks that are NULL. */
20131 if (stmt
== NULL_TREE
)
20134 inlined_func
= inlined_function_outer_scope_p (stmt
);
20136 /* If the block is one fragment of a non-contiguous block, do not
20137 process the variables, since they will have been done by the
20138 origin block. Do process subblocks. */
20139 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
20143 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
20144 gen_block_die (sub
, context_die
, depth
+ 1);
20149 /* Determine if we need to output any Dwarf DIEs at all to represent this
20152 /* The outer scopes for inlinings *must* always be represented. We
20153 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20154 must_output_die
= 1;
20157 /* Determine if this block directly contains any "significant"
20158 local declarations which we will need to output DIEs for. */
20159 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20160 /* We are not in terse mode so *any* local declaration counts
20161 as being a "significant" one. */
20162 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
20163 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
20164 && (TREE_USED (stmt
)
20165 || TREE_ASM_WRITTEN (stmt
)
20166 || BLOCK_ABSTRACT (stmt
)));
20167 else if ((TREE_USED (stmt
)
20168 || TREE_ASM_WRITTEN (stmt
)
20169 || BLOCK_ABSTRACT (stmt
))
20170 && !dwarf2out_ignore_block (stmt
))
20171 must_output_die
= 1;
20174 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20175 DIE for any block which contains no significant local declarations at
20176 all. Rather, in such cases we just call `decls_for_scope' so that any
20177 needed Dwarf info for any sub-blocks will get properly generated. Note
20178 that in terse mode, our definition of what constitutes a "significant"
20179 local declaration gets restricted to include only inlined function
20180 instances and local (nested) function definitions. */
20181 if (must_output_die
)
20185 /* If STMT block is abstract, that means we have been called
20186 indirectly from dwarf2out_abstract_function.
20187 That function rightfully marks the descendent blocks (of
20188 the abstract function it is dealing with) as being abstract,
20189 precisely to prevent us from emitting any
20190 DW_TAG_inlined_subroutine DIE as a descendent
20191 of an abstract function instance. So in that case, we should
20192 not call gen_inlined_subroutine_die.
20194 Later though, when cgraph asks dwarf2out to emit info
20195 for the concrete instance of the function decl into which
20196 the concrete instance of STMT got inlined, the later will lead
20197 to the generation of a DW_TAG_inlined_subroutine DIE. */
20198 if (! BLOCK_ABSTRACT (stmt
))
20199 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
20202 gen_lexical_block_die (stmt
, context_die
, depth
);
20205 decls_for_scope (stmt
, context_die
, depth
);
20208 /* Process variable DECL (or variable with origin ORIGIN) within
20209 block STMT and add it to CONTEXT_DIE. */
20211 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
20214 tree decl_or_origin
= decl
? decl
: origin
;
20216 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
20217 die
= lookup_decl_die (decl_or_origin
);
20218 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
20219 && TYPE_DECL_IS_STUB (decl_or_origin
))
20220 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
20224 if (die
!= NULL
&& die
->die_parent
== NULL
)
20225 add_child_die (context_die
, die
);
20226 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
20227 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
20228 stmt
, context_die
);
20230 gen_decl_die (decl
, origin
, context_die
);
20233 /* Generate all of the decls declared within a given scope and (recursively)
20234 all of its sub-blocks. */
20237 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
20243 /* Ignore NULL blocks. */
20244 if (stmt
== NULL_TREE
)
20247 /* Output the DIEs to represent all of the data objects and typedefs
20248 declared directly within this block but not within any nested
20249 sub-blocks. Also, nested function and tag DIEs have been
20250 generated with a parent of NULL; fix that up now. We don't
20251 have to do this if we're at -g1. */
20252 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20254 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
20255 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
20256 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
20257 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
20261 /* Even if we're at -g1, we need to process the subblocks in order to get
20262 inlined call information. */
20264 /* Output the DIEs to represent all sub-blocks (and the items declared
20265 therein) of this block. */
20266 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
20268 subblocks
= BLOCK_CHAIN (subblocks
))
20269 gen_block_die (subblocks
, context_die
, depth
+ 1);
20272 /* Is this a typedef we can avoid emitting? */
20275 is_redundant_typedef (const_tree decl
)
20277 if (TYPE_DECL_IS_STUB (decl
))
20280 if (DECL_ARTIFICIAL (decl
)
20281 && DECL_CONTEXT (decl
)
20282 && is_tagged_type (DECL_CONTEXT (decl
))
20283 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
20284 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
20285 /* Also ignore the artificial member typedef for the class name. */
20291 /* Return TRUE if TYPE is a typedef that names a type for linkage
20292 purposes. This kind of typedefs is produced by the C++ FE for
20295 typedef struct {...} foo;
20297 In that case, there is no typedef variant type produced for foo.
20298 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20302 is_naming_typedef_decl (const_tree decl
)
20304 if (decl
== NULL_TREE
20305 || TREE_CODE (decl
) != TYPE_DECL
20306 || !is_tagged_type (TREE_TYPE (decl
))
20307 || DECL_IS_BUILTIN (decl
)
20308 || is_redundant_typedef (decl
)
20309 /* It looks like Ada produces TYPE_DECLs that are very similar
20310 to C++ naming typedefs but that have different
20311 semantics. Let's be specific to c++ for now. */
20315 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
20316 && TYPE_NAME (TREE_TYPE (decl
)) == decl
20317 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
20318 != TYPE_NAME (TREE_TYPE (decl
))));
20321 /* Returns the DIE for a context. */
20323 static inline dw_die_ref
20324 get_context_die (tree context
)
20328 /* Find die that represents this context. */
20329 if (TYPE_P (context
))
20331 context
= TYPE_MAIN_VARIANT (context
);
20332 return strip_naming_typedef (context
, force_type_die (context
));
20335 return force_decl_die (context
);
20337 return comp_unit_die ();
20340 /* Returns the DIE for decl. A DIE will always be returned. */
20343 force_decl_die (tree decl
)
20345 dw_die_ref decl_die
;
20346 unsigned saved_external_flag
;
20347 tree save_fn
= NULL_TREE
;
20348 decl_die
= lookup_decl_die (decl
);
20351 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
20353 decl_die
= lookup_decl_die (decl
);
20357 switch (TREE_CODE (decl
))
20359 case FUNCTION_DECL
:
20360 /* Clear current_function_decl, so that gen_subprogram_die thinks
20361 that this is a declaration. At this point, we just want to force
20362 declaration die. */
20363 save_fn
= current_function_decl
;
20364 current_function_decl
= NULL_TREE
;
20365 gen_subprogram_die (decl
, context_die
);
20366 current_function_decl
= save_fn
;
20370 /* Set external flag to force declaration die. Restore it after
20371 gen_decl_die() call. */
20372 saved_external_flag
= DECL_EXTERNAL (decl
);
20373 DECL_EXTERNAL (decl
) = 1;
20374 gen_decl_die (decl
, NULL
, context_die
);
20375 DECL_EXTERNAL (decl
) = saved_external_flag
;
20378 case NAMESPACE_DECL
:
20379 if (dwarf_version
>= 3 || !dwarf_strict
)
20380 dwarf2out_decl (decl
);
20382 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20383 decl_die
= comp_unit_die ();
20386 case TRANSLATION_UNIT_DECL
:
20387 decl_die
= comp_unit_die ();
20391 gcc_unreachable ();
20394 /* We should be able to find the DIE now. */
20396 decl_die
= lookup_decl_die (decl
);
20397 gcc_assert (decl_die
);
20403 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20404 always returned. */
20407 force_type_die (tree type
)
20409 dw_die_ref type_die
;
20411 type_die
= lookup_type_die (type
);
20414 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
20416 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
20418 gcc_assert (type_die
);
20423 /* Force out any required namespaces to be able to output DECL,
20424 and return the new context_die for it, if it's changed. */
20427 setup_namespace_context (tree thing
, dw_die_ref context_die
)
20429 tree context
= (DECL_P (thing
)
20430 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
20431 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
20432 /* Force out the namespace. */
20433 context_die
= force_decl_die (context
);
20435 return context_die
;
20438 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20439 type) within its namespace, if appropriate.
20441 For compatibility with older debuggers, namespace DIEs only contain
20442 declarations; all definitions are emitted at CU scope. */
20445 declare_in_namespace (tree thing
, dw_die_ref context_die
)
20447 dw_die_ref ns_context
;
20449 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20450 return context_die
;
20452 /* If this decl is from an inlined function, then don't try to emit it in its
20453 namespace, as we will get confused. It would have already been emitted
20454 when the abstract instance of the inline function was emitted anyways. */
20455 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
20456 return context_die
;
20458 ns_context
= setup_namespace_context (thing
, context_die
);
20460 if (ns_context
!= context_die
)
20464 if (DECL_P (thing
))
20465 gen_decl_die (thing
, NULL
, ns_context
);
20467 gen_type_die (thing
, ns_context
);
20469 return context_die
;
20472 /* Generate a DIE for a namespace or namespace alias. */
20475 gen_namespace_die (tree decl
, dw_die_ref context_die
)
20477 dw_die_ref namespace_die
;
20479 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20480 they are an alias of. */
20481 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
20483 /* Output a real namespace or module. */
20484 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20485 namespace_die
= new_die (is_fortran ()
20486 ? DW_TAG_module
: DW_TAG_namespace
,
20487 context_die
, decl
);
20488 /* For Fortran modules defined in different CU don't add src coords. */
20489 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
20491 const char *name
= dwarf2_name (decl
, 0);
20493 add_name_attribute (namespace_die
, name
);
20496 add_name_and_src_coords_attributes (namespace_die
, decl
);
20497 if (DECL_EXTERNAL (decl
))
20498 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
20499 equate_decl_number_to_die (decl
, namespace_die
);
20503 /* Output a namespace alias. */
20505 /* Force out the namespace we are an alias of, if necessary. */
20506 dw_die_ref origin_die
20507 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
20509 if (DECL_FILE_SCOPE_P (decl
)
20510 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
20511 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20512 /* Now create the namespace alias DIE. */
20513 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
20514 add_name_and_src_coords_attributes (namespace_die
, decl
);
20515 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
20516 equate_decl_number_to_die (decl
, namespace_die
);
20518 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
20519 if (want_pubnames ())
20520 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
20523 /* Generate Dwarf debug information for a decl described by DECL.
20524 The return value is currently only meaningful for PARM_DECLs,
20525 for all other decls it returns NULL. */
20528 gen_decl_die (tree decl
, tree origin
, dw_die_ref context_die
)
20530 tree decl_or_origin
= decl
? decl
: origin
;
20531 tree class_origin
= NULL
, ultimate_origin
;
20533 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
20536 switch (TREE_CODE (decl_or_origin
))
20542 if (!is_fortran () && !is_ada ())
20544 /* The individual enumerators of an enum type get output when we output
20545 the Dwarf representation of the relevant enum type itself. */
20549 /* Emit its type. */
20550 gen_type_die (TREE_TYPE (decl
), context_die
);
20552 /* And its containing namespace. */
20553 context_die
= declare_in_namespace (decl
, context_die
);
20555 gen_const_die (decl
, context_die
);
20558 case FUNCTION_DECL
:
20559 /* Don't output any DIEs to represent mere function declarations,
20560 unless they are class members or explicit block externs. */
20561 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
20562 && DECL_FILE_SCOPE_P (decl_or_origin
)
20563 && (current_function_decl
== NULL_TREE
20564 || DECL_ARTIFICIAL (decl_or_origin
)))
20569 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20570 on local redeclarations of global functions. That seems broken. */
20571 if (current_function_decl
!= decl
)
20572 /* This is only a declaration. */;
20575 /* If we're emitting a clone, emit info for the abstract instance. */
20576 if (origin
|| DECL_ORIGIN (decl
) != decl
)
20577 dwarf2out_abstract_function (origin
20578 ? DECL_ORIGIN (origin
)
20579 : DECL_ABSTRACT_ORIGIN (decl
));
20581 /* If we're emitting an out-of-line copy of an inline function,
20582 emit info for the abstract instance and set up to refer to it. */
20583 else if (cgraph_function_possibly_inlined_p (decl
)
20584 && ! DECL_ABSTRACT_P (decl
)
20585 && ! class_or_namespace_scope_p (context_die
)
20586 /* dwarf2out_abstract_function won't emit a die if this is just
20587 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20588 that case, because that works only if we have a die. */
20589 && DECL_INITIAL (decl
) != NULL_TREE
)
20591 dwarf2out_abstract_function (decl
);
20592 set_decl_origin_self (decl
);
20595 /* Otherwise we're emitting the primary DIE for this decl. */
20596 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
20598 /* Before we describe the FUNCTION_DECL itself, make sure that we
20599 have its containing type. */
20601 origin
= decl_class_context (decl
);
20602 if (origin
!= NULL_TREE
)
20603 gen_type_die (origin
, context_die
);
20605 /* And its return type. */
20606 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
20608 /* And its virtual context. */
20609 if (DECL_VINDEX (decl
) != NULL_TREE
)
20610 gen_type_die (DECL_CONTEXT (decl
), context_die
);
20612 /* Make sure we have a member DIE for decl. */
20613 if (origin
!= NULL_TREE
)
20614 gen_type_die_for_member (origin
, decl
, context_die
);
20616 /* And its containing namespace. */
20617 context_die
= declare_in_namespace (decl
, context_die
);
20620 /* Now output a DIE to represent the function itself. */
20622 gen_subprogram_die (decl
, context_die
);
20626 /* If we are in terse mode, don't generate any DIEs to represent any
20627 actual typedefs. */
20628 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20631 /* In the special case of a TYPE_DECL node representing the declaration
20632 of some type tag, if the given TYPE_DECL is marked as having been
20633 instantiated from some other (original) TYPE_DECL node (e.g. one which
20634 was generated within the original definition of an inline function) we
20635 used to generate a special (abbreviated) DW_TAG_structure_type,
20636 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20637 should be actually referencing those DIEs, as variable DIEs with that
20638 type would be emitted already in the abstract origin, so it was always
20639 removed during unused type prunning. Don't add anything in this
20641 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
20644 if (is_redundant_typedef (decl
))
20645 gen_type_die (TREE_TYPE (decl
), context_die
);
20647 /* Output a DIE to represent the typedef itself. */
20648 gen_typedef_die (decl
, context_die
);
20652 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
20653 gen_label_die (decl
, context_die
);
20658 /* If we are in terse mode, don't generate any DIEs to represent any
20659 variable declarations or definitions. */
20660 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20663 /* Output any DIEs that are needed to specify the type of this data
20665 if (decl_by_reference_p (decl_or_origin
))
20666 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20668 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20670 /* And its containing type. */
20671 class_origin
= decl_class_context (decl_or_origin
);
20672 if (class_origin
!= NULL_TREE
)
20673 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
20675 /* And its containing namespace. */
20676 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
20678 /* Now output the DIE to represent the data object itself. This gets
20679 complicated because of the possibility that the VAR_DECL really
20680 represents an inlined instance of a formal parameter for an inline
20682 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
20683 if (ultimate_origin
!= NULL_TREE
20684 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
20685 gen_formal_parameter_die (decl
, origin
,
20686 true /* Emit name attribute. */,
20689 gen_variable_die (decl
, origin
, context_die
);
20693 /* Ignore the nameless fields that are used to skip bits but handle C++
20694 anonymous unions and structs. */
20695 if (DECL_NAME (decl
) != NULL_TREE
20696 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
20697 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
20699 gen_type_die (member_declared_type (decl
), context_die
);
20700 gen_field_die (decl
, context_die
);
20705 if (DECL_BY_REFERENCE (decl_or_origin
))
20706 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20708 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20709 return gen_formal_parameter_die (decl
, origin
,
20710 true /* Emit name attribute. */,
20713 case NAMESPACE_DECL
:
20714 case IMPORTED_DECL
:
20715 if (dwarf_version
>= 3 || !dwarf_strict
)
20716 gen_namespace_die (decl
, context_die
);
20719 case NAMELIST_DECL
:
20720 gen_namelist_decl (DECL_NAME (decl
), context_die
,
20721 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
20725 /* Probably some frontend-internal decl. Assume we don't care. */
20726 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
20733 /* Output debug information for global decl DECL. Called from toplev.c after
20734 compilation proper has finished. */
20737 dwarf2out_global_decl (tree decl
)
20739 /* Output DWARF2 information for file-scope tentative data object
20740 declarations, file-scope (extern) function declarations (which
20741 had no corresponding body) and file-scope tagged type declarations
20742 and definitions which have not yet been forced out. */
20743 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
20744 dwarf2out_decl (decl
);
20747 /* Output debug information for type decl DECL. Called from toplev.c
20748 and from language front ends (to record built-in types). */
20750 dwarf2out_type_decl (tree decl
, int local
)
20753 dwarf2out_decl (decl
);
20756 /* Output debug information for imported module or decl DECL.
20757 NAME is non-NULL name in the lexical block if the decl has been renamed.
20758 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
20759 that DECL belongs to.
20760 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
20762 dwarf2out_imported_module_or_decl_1 (tree decl
,
20764 tree lexical_block
,
20765 dw_die_ref lexical_block_die
)
20767 expanded_location xloc
;
20768 dw_die_ref imported_die
= NULL
;
20769 dw_die_ref at_import_die
;
20771 if (TREE_CODE (decl
) == IMPORTED_DECL
)
20773 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
20774 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
20778 xloc
= expand_location (input_location
);
20780 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
20782 at_import_die
= force_type_die (TREE_TYPE (decl
));
20783 /* For namespace N { typedef void T; } using N::T; base_type_die
20784 returns NULL, but DW_TAG_imported_declaration requires
20785 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
20786 if (!at_import_die
)
20788 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
20789 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
20790 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
20791 gcc_assert (at_import_die
);
20796 at_import_die
= lookup_decl_die (decl
);
20797 if (!at_import_die
)
20799 /* If we're trying to avoid duplicate debug info, we may not have
20800 emitted the member decl for this field. Emit it now. */
20801 if (TREE_CODE (decl
) == FIELD_DECL
)
20803 tree type
= DECL_CONTEXT (decl
);
20805 if (TYPE_CONTEXT (type
)
20806 && TYPE_P (TYPE_CONTEXT (type
))
20807 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
20808 DINFO_USAGE_DIR_USE
))
20810 gen_type_die_for_member (type
, decl
,
20811 get_context_die (TYPE_CONTEXT (type
)));
20813 if (TREE_CODE (decl
) == NAMELIST_DECL
)
20814 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
20815 get_context_die (DECL_CONTEXT (decl
)),
20818 at_import_die
= force_decl_die (decl
);
20822 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
20824 if (dwarf_version
>= 3 || !dwarf_strict
)
20825 imported_die
= new_die (DW_TAG_imported_module
,
20832 imported_die
= new_die (DW_TAG_imported_declaration
,
20836 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
20837 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
20839 add_AT_string (imported_die
, DW_AT_name
,
20840 IDENTIFIER_POINTER (name
));
20841 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
20844 /* Output debug information for imported module or decl DECL.
20845 NAME is non-NULL name in context if the decl has been renamed.
20846 CHILD is true if decl is one of the renamed decls as part of
20847 importing whole module. */
20850 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
20853 /* dw_die_ref at_import_die; */
20854 dw_die_ref scope_die
;
20856 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20861 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
20862 We need decl DIE for reference and scope die. First, get DIE for the decl
20865 /* Get the scope die for decl context. Use comp_unit_die for global module
20866 or decl. If die is not found for non globals, force new die. */
20868 && TYPE_P (context
)
20869 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
20872 if (!(dwarf_version
>= 3 || !dwarf_strict
))
20875 scope_die
= get_context_die (context
);
20879 gcc_assert (scope_die
->die_child
);
20880 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
20881 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
20882 scope_die
= scope_die
->die_child
;
20885 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
20886 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
20890 /* Output debug information for namelists. */
20893 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
20895 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
20899 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20902 gcc_assert (scope_die
!= NULL
);
20903 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
20904 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
20906 /* If there are no item_decls, we have a nondefining namelist, e.g.
20907 with USE association; hence, set DW_AT_declaration. */
20908 if (item_decls
== NULL_TREE
)
20910 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
20914 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
20916 nml_item_ref_die
= lookup_decl_die (value
);
20917 if (!nml_item_ref_die
)
20918 nml_item_ref_die
= force_decl_die (value
);
20920 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
20921 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
20927 /* Write the debugging output for DECL. */
20930 dwarf2out_decl (tree decl
)
20932 dw_die_ref context_die
= comp_unit_die ();
20934 switch (TREE_CODE (decl
))
20939 case FUNCTION_DECL
:
20940 /* What we would really like to do here is to filter out all mere
20941 file-scope declarations of file-scope functions which are never
20942 referenced later within this translation unit (and keep all of ones
20943 that *are* referenced later on) but we aren't clairvoyant, so we have
20944 no idea which functions will be referenced in the future (i.e. later
20945 on within the current translation unit). So here we just ignore all
20946 file-scope function declarations which are not also definitions. If
20947 and when the debugger needs to know something about these functions,
20948 it will have to hunt around and find the DWARF information associated
20949 with the definition of the function.
20951 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
20952 nodes represent definitions and which ones represent mere
20953 declarations. We have to check DECL_INITIAL instead. That's because
20954 the C front-end supports some weird semantics for "extern inline"
20955 function definitions. These can get inlined within the current
20956 translation unit (and thus, we need to generate Dwarf info for their
20957 abstract instances so that the Dwarf info for the concrete inlined
20958 instances can have something to refer to) but the compiler never
20959 generates any out-of-lines instances of such things (despite the fact
20960 that they *are* definitions).
20962 The important point is that the C front-end marks these "extern
20963 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
20964 them anyway. Note that the C++ front-end also plays some similar games
20965 for inline function definitions appearing within include files which
20966 also contain `#pragma interface' pragmas.
20968 If we are called from dwarf2out_abstract_function output a DIE
20969 anyway. We can end up here this way with early inlining and LTO
20970 where the inlined function is output in a different LTRANS unit
20972 if (DECL_INITIAL (decl
) == NULL_TREE
20973 && ! DECL_ABSTRACT_P (decl
))
20976 /* If we're a nested function, initially use a parent of NULL; if we're
20977 a plain function, this will be fixed up in decls_for_scope. If
20978 we're a method, it will be ignored, since we already have a DIE. */
20979 if (decl_function_context (decl
)
20980 /* But if we're in terse mode, we don't care about scope. */
20981 && debug_info_level
> DINFO_LEVEL_TERSE
)
20982 context_die
= NULL
;
20986 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
20987 declaration and if the declaration was never even referenced from
20988 within this entire compilation unit. We suppress these DIEs in
20989 order to save space in the .debug section (by eliminating entries
20990 which are probably useless). Note that we must not suppress
20991 block-local extern declarations (whether used or not) because that
20992 would screw-up the debugger's name lookup mechanism and cause it to
20993 miss things which really ought to be in scope at a given point. */
20994 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
20997 /* For local statics lookup proper context die. */
20998 if (TREE_STATIC (decl
)
20999 && DECL_CONTEXT (decl
)
21000 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
21001 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
21003 /* If we are in terse mode, don't generate any DIEs to represent any
21004 variable declarations or definitions. */
21005 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
21010 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
21012 if (!is_fortran () && !is_ada ())
21014 if (TREE_STATIC (decl
) && decl_function_context (decl
))
21015 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
21018 case NAMESPACE_DECL
:
21019 case IMPORTED_DECL
:
21020 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
21022 if (lookup_decl_die (decl
) != NULL
)
21027 /* Don't emit stubs for types unless they are needed by other DIEs. */
21028 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
21031 /* Don't bother trying to generate any DIEs to represent any of the
21032 normal built-in types for the language we are compiling. */
21033 if (DECL_IS_BUILTIN (decl
))
21036 /* If we are in terse mode, don't generate any DIEs for types. */
21037 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
21040 /* If we're a function-scope tag, initially use a parent of NULL;
21041 this will be fixed up in decls_for_scope. */
21042 if (decl_function_context (decl
))
21043 context_die
= NULL
;
21047 case NAMELIST_DECL
:
21054 gen_decl_die (decl
, NULL
, context_die
);
21057 /* Write the debugging output for DECL. */
21060 dwarf2out_function_decl (tree decl
)
21062 dwarf2out_decl (decl
);
21063 call_arg_locations
= NULL
;
21064 call_arg_loc_last
= NULL
;
21065 call_site_count
= -1;
21066 tail_call_site_count
= -1;
21067 block_map
.release ();
21068 htab_empty (decl_loc_table
);
21069 htab_empty (cached_dw_loc_list_table
);
21072 /* Output a marker (i.e. a label) for the beginning of the generated code for
21073 a lexical block. */
21076 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
21077 unsigned int blocknum
)
21079 switch_to_section (current_function_section ());
21080 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
21083 /* Output a marker (i.e. a label) for the end of the generated code for a
21087 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
21089 switch_to_section (current_function_section ());
21090 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
21093 /* Returns nonzero if it is appropriate not to emit any debugging
21094 information for BLOCK, because it doesn't contain any instructions.
21096 Don't allow this for blocks with nested functions or local classes
21097 as we would end up with orphans, and in the presence of scheduling
21098 we may end up calling them anyway. */
21101 dwarf2out_ignore_block (const_tree block
)
21106 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
21107 if (TREE_CODE (decl
) == FUNCTION_DECL
21108 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
21110 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
21112 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
21113 if (TREE_CODE (decl
) == FUNCTION_DECL
21114 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
21121 /* Hash table routines for file_hash. */
21124 file_table_eq (const void *p1_p
, const void *p2_p
)
21126 const struct dwarf_file_data
*const p1
=
21127 (const struct dwarf_file_data
*) p1_p
;
21128 const char *const p2
= (const char *) p2_p
;
21129 return filename_cmp (p1
->filename
, p2
) == 0;
21133 file_table_hash (const void *p_p
)
21135 const struct dwarf_file_data
*const p
= (const struct dwarf_file_data
*) p_p
;
21136 return htab_hash_string (p
->filename
);
21139 /* Lookup FILE_NAME (in the list of filenames that we know about here in
21140 dwarf2out.c) and return its "index". The index of each (known) filename is
21141 just a unique number which is associated with only that one filename. We
21142 need such numbers for the sake of generating labels (in the .debug_sfnames
21143 section) and references to those files numbers (in the .debug_srcinfo
21144 and.debug_macinfo sections). If the filename given as an argument is not
21145 found in our current list, add it to the list and assign it the next
21146 available unique index number. In order to speed up searches, we remember
21147 the index of the filename was looked up last. This handles the majority of
21150 static struct dwarf_file_data
*
21151 lookup_filename (const char *file_name
)
21154 struct dwarf_file_data
* created
;
21156 /* Check to see if the file name that was searched on the previous
21157 call matches this file name. If so, return the index. */
21158 if (file_table_last_lookup
21159 && (file_name
== file_table_last_lookup
->filename
21160 || filename_cmp (file_table_last_lookup
->filename
, file_name
) == 0))
21161 return file_table_last_lookup
;
21163 /* Didn't match the previous lookup, search the table. */
21164 slot
= htab_find_slot_with_hash (file_table
, file_name
,
21165 htab_hash_string (file_name
), INSERT
);
21167 return (struct dwarf_file_data
*) *slot
;
21169 created
= ggc_alloc
<dwarf_file_data
> ();
21170 created
->filename
= file_name
;
21171 created
->emitted_number
= 0;
21176 /* If the assembler will construct the file table, then translate the compiler
21177 internal file table number into the assembler file table number, and emit
21178 a .file directive if we haven't already emitted one yet. The file table
21179 numbers are different because we prune debug info for unused variables and
21180 types, which may include filenames. */
21183 maybe_emit_file (struct dwarf_file_data
* fd
)
21185 if (! fd
->emitted_number
)
21187 if (last_emitted_file
)
21188 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
21190 fd
->emitted_number
= 1;
21191 last_emitted_file
= fd
;
21193 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21195 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
21196 output_quoted_string (asm_out_file
,
21197 remap_debug_filename (fd
->filename
));
21198 fputc ('\n', asm_out_file
);
21202 return fd
->emitted_number
;
21205 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21206 That generation should happen after function debug info has been
21207 generated. The value of the attribute is the constant value of ARG. */
21210 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
21212 die_arg_entry entry
;
21217 if (!tmpl_value_parm_die_table
)
21218 vec_alloc (tmpl_value_parm_die_table
, 32);
21222 vec_safe_push (tmpl_value_parm_die_table
, entry
);
21225 /* Return TRUE if T is an instance of generic type, FALSE
21229 generic_type_p (tree t
)
21231 if (t
== NULL_TREE
|| !TYPE_P (t
))
21233 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
21236 /* Schedule the generation of the generic parameter dies for the
21237 instance of generic type T. The proper generation itself is later
21238 done by gen_scheduled_generic_parms_dies. */
21241 schedule_generic_params_dies_gen (tree t
)
21243 if (!generic_type_p (t
))
21246 if (!generic_type_instances
)
21247 vec_alloc (generic_type_instances
, 256);
21249 vec_safe_push (generic_type_instances
, t
);
21252 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21253 by append_entry_to_tmpl_value_parm_die_table. This function must
21254 be called after function DIEs have been generated. */
21257 gen_remaining_tmpl_value_param_die_attribute (void)
21259 if (tmpl_value_parm_die_table
)
21264 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
21265 tree_add_const_value_attribute (e
->die
, e
->arg
);
21269 /* Generate generic parameters DIEs for instances of generic types
21270 that have been previously scheduled by
21271 schedule_generic_params_dies_gen. This function must be called
21272 after all the types of the CU have been laid out. */
21275 gen_scheduled_generic_parms_dies (void)
21280 if (!generic_type_instances
)
21283 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
21284 if (COMPLETE_TYPE_P (t
))
21285 gen_generic_params_dies (t
);
21289 /* Replace DW_AT_name for the decl with name. */
21292 dwarf2out_set_name (tree decl
, tree name
)
21298 die
= TYPE_SYMTAB_DIE (decl
);
21302 dname
= dwarf2_name (name
, 0);
21306 attr
= get_AT (die
, DW_AT_name
);
21309 struct indirect_string_node
*node
;
21311 node
= find_AT_string (dname
);
21312 /* replace the string. */
21313 attr
->dw_attr_val
.v
.val_str
= node
;
21317 add_name_attribute (die
, dname
);
21320 /* True if before or during processing of the first function being emitted. */
21321 static bool in_first_function_p
= true;
21322 /* True if loc_note during dwarf2out_var_location call might still be
21323 before first real instruction at address equal to .Ltext0. */
21324 static bool maybe_at_text_label_p
= true;
21325 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
21326 static unsigned int first_loclabel_num_not_at_text_label
;
21328 /* Called by the final INSN scan whenever we see a var location. We
21329 use it to drop labels in the right places, and throw the location in
21330 our lookup table. */
21333 dwarf2out_var_location (rtx_insn
*loc_note
)
21335 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
21336 struct var_loc_node
*newloc
;
21337 rtx_insn
*next_real
, *next_note
;
21338 static const char *last_label
;
21339 static const char *last_postcall_label
;
21340 static bool last_in_cold_section_p
;
21341 static rtx_insn
*expected_next_loc_note
;
21345 if (!NOTE_P (loc_note
))
21347 if (CALL_P (loc_note
))
21350 if (SIBLING_CALL_P (loc_note
))
21351 tail_call_site_count
++;
21356 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
21357 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
21360 /* Optimize processing a large consecutive sequence of location
21361 notes so we don't spend too much time in next_real_insn. If the
21362 next insn is another location note, remember the next_real_insn
21363 calculation for next time. */
21364 next_real
= cached_next_real_insn
;
21367 if (expected_next_loc_note
!= loc_note
)
21371 next_note
= NEXT_INSN (loc_note
);
21373 || next_note
->deleted ()
21374 || ! NOTE_P (next_note
)
21375 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
21376 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
21380 next_real
= next_real_insn (loc_note
);
21384 expected_next_loc_note
= next_note
;
21385 cached_next_real_insn
= next_real
;
21388 cached_next_real_insn
= NULL
;
21390 /* If there are no instructions which would be affected by this note,
21391 don't do anything. */
21393 && next_real
== NULL_RTX
21394 && !NOTE_DURING_CALL_P (loc_note
))
21397 if (next_real
== NULL_RTX
)
21398 next_real
= get_last_insn ();
21400 /* If there were any real insns between note we processed last time
21401 and this note (or if it is the first note), clear
21402 last_{,postcall_}label so that they are not reused this time. */
21403 if (last_var_location_insn
== NULL_RTX
21404 || last_var_location_insn
!= next_real
21405 || last_in_cold_section_p
!= in_cold_section_p
)
21408 last_postcall_label
= NULL
;
21413 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
21414 newloc
= add_var_loc_to_decl (decl
, loc_note
,
21415 NOTE_DURING_CALL_P (loc_note
)
21416 ? last_postcall_label
: last_label
);
21417 if (newloc
== NULL
)
21426 /* If there were no real insns between note we processed last time
21427 and this note, use the label we emitted last time. Otherwise
21428 create a new label and emit it. */
21429 if (last_label
== NULL
)
21431 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
21432 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
21434 last_label
= ggc_strdup (loclabel
);
21435 /* See if loclabel might be equal to .Ltext0. If yes,
21436 bump first_loclabel_num_not_at_text_label. */
21437 if (!have_multiple_function_sections
21438 && in_first_function_p
21439 && maybe_at_text_label_p
)
21441 static rtx_insn
*last_start
;
21443 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
21444 if (insn
== last_start
)
21446 else if (!NONDEBUG_INSN_P (insn
))
21450 rtx body
= PATTERN (insn
);
21451 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
21453 /* Inline asm could occupy zero bytes. */
21454 else if (GET_CODE (body
) == ASM_INPUT
21455 || asm_noperands (body
) >= 0)
21457 #ifdef HAVE_attr_length
21458 else if (get_attr_min_length (insn
) == 0)
21463 /* Assume insn has non-zero length. */
21464 maybe_at_text_label_p
= false;
21468 if (maybe_at_text_label_p
)
21470 last_start
= loc_note
;
21471 first_loclabel_num_not_at_text_label
= loclabel_num
;
21478 struct call_arg_loc_node
*ca_loc
21479 = ggc_cleared_alloc
<call_arg_loc_node
> ();
21480 rtx_insn
*prev
= prev_real_insn (loc_note
);
21482 ca_loc
->call_arg_loc_note
= loc_note
;
21483 ca_loc
->next
= NULL
;
21484 ca_loc
->label
= last_label
;
21487 || (NONJUMP_INSN_P (prev
)
21488 && GET_CODE (PATTERN (prev
)) == SEQUENCE
21489 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
21490 if (!CALL_P (prev
))
21491 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
21492 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
21493 x
= get_call_rtx_from (PATTERN (prev
));
21496 x
= XEXP (XEXP (x
, 0), 0);
21497 if (GET_CODE (x
) == SYMBOL_REF
21498 && SYMBOL_REF_DECL (x
)
21499 && TREE_CODE (SYMBOL_REF_DECL (x
)) == FUNCTION_DECL
)
21500 ca_loc
->symbol_ref
= x
;
21502 ca_loc
->block
= insn_scope (prev
);
21503 if (call_arg_locations
)
21504 call_arg_loc_last
->next
= ca_loc
;
21506 call_arg_locations
= ca_loc
;
21507 call_arg_loc_last
= ca_loc
;
21509 else if (!NOTE_DURING_CALL_P (loc_note
))
21510 newloc
->label
= last_label
;
21513 if (!last_postcall_label
)
21515 sprintf (loclabel
, "%s-1", last_label
);
21516 last_postcall_label
= ggc_strdup (loclabel
);
21518 newloc
->label
= last_postcall_label
;
21521 last_var_location_insn
= next_real
;
21522 last_in_cold_section_p
= in_cold_section_p
;
21525 /* Note in one location list that text section has changed. */
21528 var_location_switch_text_section_1 (void **slot
, void *data ATTRIBUTE_UNUSED
)
21530 var_loc_list
*list
= (var_loc_list
*) *slot
;
21532 list
->last_before_switch
21533 = list
->last
->next
? list
->last
->next
: list
->last
;
21537 /* Note in all location lists that text section has changed. */
21540 var_location_switch_text_section (void)
21542 if (decl_loc_table
== NULL
)
21545 htab_traverse (decl_loc_table
, var_location_switch_text_section_1
, NULL
);
21548 /* Create a new line number table. */
21550 static dw_line_info_table
*
21551 new_line_info_table (void)
21553 dw_line_info_table
*table
;
21555 table
= ggc_cleared_alloc
<dw_line_info_table_struct
> ();
21556 table
->file_num
= 1;
21557 table
->line_num
= 1;
21558 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
21563 /* Lookup the "current" table into which we emit line info, so
21564 that we don't have to do it for every source line. */
21567 set_cur_line_info_table (section
*sec
)
21569 dw_line_info_table
*table
;
21571 if (sec
== text_section
)
21572 table
= text_section_line_info
;
21573 else if (sec
== cold_text_section
)
21575 table
= cold_text_section_line_info
;
21578 cold_text_section_line_info
= table
= new_line_info_table ();
21579 table
->end_label
= cold_end_label
;
21584 const char *end_label
;
21586 if (flag_reorder_blocks_and_partition
)
21588 if (in_cold_section_p
)
21589 end_label
= crtl
->subsections
.cold_section_end_label
;
21591 end_label
= crtl
->subsections
.hot_section_end_label
;
21595 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21596 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
21597 current_function_funcdef_no
);
21598 end_label
= ggc_strdup (label
);
21601 table
= new_line_info_table ();
21602 table
->end_label
= end_label
;
21604 vec_safe_push (separate_line_info
, table
);
21607 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21608 table
->is_stmt
= (cur_line_info_table
21609 ? cur_line_info_table
->is_stmt
21610 : DWARF_LINE_DEFAULT_IS_STMT_START
);
21611 cur_line_info_table
= table
;
21615 /* We need to reset the locations at the beginning of each
21616 function. We can't do this in the end_function hook, because the
21617 declarations that use the locations won't have been output when
21618 that hook is called. Also compute have_multiple_function_sections here. */
21621 dwarf2out_begin_function (tree fun
)
21623 section
*sec
= function_section (fun
);
21625 if (sec
!= text_section
)
21626 have_multiple_function_sections
= true;
21628 if (flag_reorder_blocks_and_partition
&& !cold_text_section
)
21630 gcc_assert (current_function_decl
== fun
);
21631 cold_text_section
= unlikely_text_section ();
21632 switch_to_section (cold_text_section
);
21633 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
21634 switch_to_section (sec
);
21637 dwarf2out_note_section_used ();
21638 call_site_count
= 0;
21639 tail_call_site_count
= 0;
21641 set_cur_line_info_table (sec
);
21644 /* Helper function of dwarf2out_end_function, called only after emitting
21645 the very first function into assembly. Check if some .debug_loc range
21646 might end with a .LVL* label that could be equal to .Ltext0.
21647 In that case we must force using absolute addresses in .debug_loc ranges,
21648 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
21649 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
21651 Set have_multiple_function_sections to true in that case and
21652 terminate htab traversal. */
21655 find_empty_loc_ranges_at_text_label (void **slot
, void *)
21657 var_loc_list
*entry
;
21658 struct var_loc_node
*node
;
21660 entry
= (var_loc_list
*) *slot
;
21661 node
= entry
->first
;
21662 if (node
&& node
->next
&& node
->next
->label
)
21665 const char *label
= node
->next
->label
;
21666 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
21668 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
21670 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
21671 if (strcmp (label
, loclabel
) == 0)
21673 have_multiple_function_sections
= true;
21681 /* Hook called after emitting a function into assembly.
21682 This does something only for the very first function emitted. */
21685 dwarf2out_end_function (unsigned int)
21687 if (in_first_function_p
21688 && !have_multiple_function_sections
21689 && first_loclabel_num_not_at_text_label
21691 htab_traverse (decl_loc_table
, find_empty_loc_ranges_at_text_label
,
21693 in_first_function_p
= false;
21694 maybe_at_text_label_p
= false;
21697 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
21700 push_dw_line_info_entry (dw_line_info_table
*table
,
21701 enum dw_line_info_opcode opcode
, unsigned int val
)
21703 dw_line_info_entry e
;
21706 vec_safe_push (table
->entries
, e
);
21709 /* Output a label to mark the beginning of a source code line entry
21710 and record information relating to this source line, in
21711 'line_info_table' for later output of the .debug_line section. */
21712 /* ??? The discriminator parameter ought to be unsigned. */
21715 dwarf2out_source_line (unsigned int line
, const char *filename
,
21716 int discriminator
, bool is_stmt
)
21718 unsigned int file_num
;
21719 dw_line_info_table
*table
;
21721 if (debug_info_level
< DINFO_LEVEL_TERSE
|| line
== 0)
21724 /* The discriminator column was added in dwarf4. Simplify the below
21725 by simply removing it if we're not supposed to output it. */
21726 if (dwarf_version
< 4 && dwarf_strict
)
21729 table
= cur_line_info_table
;
21730 file_num
= maybe_emit_file (lookup_filename (filename
));
21732 /* ??? TODO: Elide duplicate line number entries. Traditionally,
21733 the debugger has used the second (possibly duplicate) line number
21734 at the beginning of the function to mark the end of the prologue.
21735 We could eliminate any other duplicates within the function. For
21736 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
21737 that second line number entry. */
21738 /* Recall that this end-of-prologue indication is *not* the same thing
21739 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
21740 to which the hook corresponds, follows the last insn that was
21741 emitted by gen_prologue. What we need is to precede the first insn
21742 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
21743 insn that corresponds to something the user wrote. These may be
21744 very different locations once scheduling is enabled. */
21746 if (0 && file_num
== table
->file_num
21747 && line
== table
->line_num
21748 && discriminator
== table
->discrim_num
21749 && is_stmt
== table
->is_stmt
)
21752 switch_to_section (current_function_section ());
21754 /* If requested, emit something human-readable. */
21755 if (flag_debug_asm
)
21756 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
, filename
, line
);
21758 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21760 /* Emit the .loc directive understood by GNU as. */
21761 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
21762 file_num, line, is_stmt, discriminator */
21763 fputs ("\t.loc ", asm_out_file
);
21764 fprint_ul (asm_out_file
, file_num
);
21765 putc (' ', asm_out_file
);
21766 fprint_ul (asm_out_file
, line
);
21767 putc (' ', asm_out_file
);
21768 putc ('0', asm_out_file
);
21770 if (is_stmt
!= table
->is_stmt
)
21772 fputs (" is_stmt ", asm_out_file
);
21773 putc (is_stmt
? '1' : '0', asm_out_file
);
21775 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
21777 gcc_assert (discriminator
> 0);
21778 fputs (" discriminator ", asm_out_file
);
21779 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
21781 putc ('\n', asm_out_file
);
21785 unsigned int label_num
= ++line_info_label_num
;
21787 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
21789 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
21790 if (file_num
!= table
->file_num
)
21791 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
21792 if (discriminator
!= table
->discrim_num
)
21793 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
21794 if (is_stmt
!= table
->is_stmt
)
21795 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
21796 push_dw_line_info_entry (table
, LI_set_line
, line
);
21799 table
->file_num
= file_num
;
21800 table
->line_num
= line
;
21801 table
->discrim_num
= discriminator
;
21802 table
->is_stmt
= is_stmt
;
21803 table
->in_use
= true;
21806 /* Record the beginning of a new source file. */
21809 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
21811 if (flag_eliminate_dwarf2_dups
)
21813 /* Record the beginning of the file for break_out_includes. */
21814 dw_die_ref bincl_die
;
21816 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die (), NULL
);
21817 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
21820 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21823 e
.code
= DW_MACINFO_start_file
;
21825 e
.info
= ggc_strdup (filename
);
21826 vec_safe_push (macinfo_table
, e
);
21830 /* Record the end of a source file. */
21833 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
21835 if (flag_eliminate_dwarf2_dups
)
21836 /* Record the end of the file for break_out_includes. */
21837 new_die (DW_TAG_GNU_EINCL
, comp_unit_die (), NULL
);
21839 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21842 e
.code
= DW_MACINFO_end_file
;
21845 vec_safe_push (macinfo_table
, e
);
21849 /* Called from debug_define in toplev.c. The `buffer' parameter contains
21850 the tail part of the directive line, i.e. the part which is past the
21851 initial whitespace, #, whitespace, directive-name, whitespace part. */
21854 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
21855 const char *buffer ATTRIBUTE_UNUSED
)
21857 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21860 /* Insert a dummy first entry to be able to optimize the whole
21861 predefined macro block using DW_MACRO_GNU_transparent_include. */
21862 if (macinfo_table
->is_empty () && lineno
<= 1)
21867 vec_safe_push (macinfo_table
, e
);
21869 e
.code
= DW_MACINFO_define
;
21871 e
.info
= ggc_strdup (buffer
);
21872 vec_safe_push (macinfo_table
, e
);
21876 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
21877 the tail part of the directive line, i.e. the part which is past the
21878 initial whitespace, #, whitespace, directive-name, whitespace part. */
21881 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
21882 const char *buffer ATTRIBUTE_UNUSED
)
21884 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21887 /* Insert a dummy first entry to be able to optimize the whole
21888 predefined macro block using DW_MACRO_GNU_transparent_include. */
21889 if (macinfo_table
->is_empty () && lineno
<= 1)
21894 vec_safe_push (macinfo_table
, e
);
21896 e
.code
= DW_MACINFO_undef
;
21898 e
.info
= ggc_strdup (buffer
);
21899 vec_safe_push (macinfo_table
, e
);
21903 /* Helpers to manipulate hash table of CUs. */
21905 struct macinfo_entry_hasher
: typed_noop_remove
<macinfo_entry
>
21907 typedef macinfo_entry value_type
;
21908 typedef macinfo_entry compare_type
;
21909 static inline hashval_t
hash (const value_type
*);
21910 static inline bool equal (const value_type
*, const compare_type
*);
21914 macinfo_entry_hasher::hash (const value_type
*entry
)
21916 return htab_hash_string (entry
->info
);
21920 macinfo_entry_hasher::equal (const value_type
*entry1
,
21921 const compare_type
*entry2
)
21923 return !strcmp (entry1
->info
, entry2
->info
);
21926 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
21928 /* Output a single .debug_macinfo entry. */
21931 output_macinfo_op (macinfo_entry
*ref
)
21935 struct indirect_string_node
*node
;
21936 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21937 struct dwarf_file_data
*fd
;
21941 case DW_MACINFO_start_file
:
21942 fd
= lookup_filename (ref
->info
);
21943 file_num
= maybe_emit_file (fd
);
21944 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
21945 dw2_asm_output_data_uleb128 (ref
->lineno
,
21946 "Included from line number %lu",
21947 (unsigned long) ref
->lineno
);
21948 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
21950 case DW_MACINFO_end_file
:
21951 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
21953 case DW_MACINFO_define
:
21954 case DW_MACINFO_undef
:
21955 len
= strlen (ref
->info
) + 1;
21957 && len
> DWARF_OFFSET_SIZE
21958 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
21959 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
21961 ref
->code
= ref
->code
== DW_MACINFO_define
21962 ? DW_MACRO_GNU_define_indirect
21963 : DW_MACRO_GNU_undef_indirect
;
21964 output_macinfo_op (ref
);
21967 dw2_asm_output_data (1, ref
->code
,
21968 ref
->code
== DW_MACINFO_define
21969 ? "Define macro" : "Undefine macro");
21970 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21971 (unsigned long) ref
->lineno
);
21972 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
21974 case DW_MACRO_GNU_define_indirect
:
21975 case DW_MACRO_GNU_undef_indirect
:
21976 node
= find_AT_string (ref
->info
);
21978 && ((node
->form
== DW_FORM_strp
)
21979 || (node
->form
== DW_FORM_GNU_str_index
)));
21980 dw2_asm_output_data (1, ref
->code
,
21981 ref
->code
== DW_MACRO_GNU_define_indirect
21982 ? "Define macro indirect"
21983 : "Undefine macro indirect");
21984 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21985 (unsigned long) ref
->lineno
);
21986 if (node
->form
== DW_FORM_strp
)
21987 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
21988 debug_str_section
, "The macro: \"%s\"",
21991 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
21994 case DW_MACRO_GNU_transparent_include
:
21995 dw2_asm_output_data (1, ref
->code
, "Transparent include");
21996 ASM_GENERATE_INTERNAL_LABEL (label
,
21997 DEBUG_MACRO_SECTION_LABEL
, ref
->lineno
);
21998 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
22001 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
22002 ASM_COMMENT_START
, (unsigned long) ref
->code
);
22007 /* Attempt to make a sequence of define/undef macinfo ops shareable with
22008 other compilation unit .debug_macinfo sections. IDX is the first
22009 index of a define/undef, return the number of ops that should be
22010 emitted in a comdat .debug_macinfo section and emit
22011 a DW_MACRO_GNU_transparent_include entry referencing it.
22012 If the define/undef entry should be emitted normally, return 0. */
22015 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
22016 macinfo_hash_type
**macinfo_htab
)
22018 macinfo_entry
*first
, *second
, *cur
, *inc
;
22019 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
22020 unsigned char checksum
[16];
22021 struct md5_ctx ctx
;
22022 char *grp_name
, *tail
;
22024 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
22025 macinfo_entry
**slot
;
22027 first
= &(*macinfo_table
)[idx
];
22028 second
= &(*macinfo_table
)[idx
+ 1];
22030 /* Optimize only if there are at least two consecutive define/undef ops,
22031 and either all of them are before first DW_MACINFO_start_file
22032 with lineno {0,1} (i.e. predefined macro block), or all of them are
22033 in some included header file. */
22034 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
22036 if (vec_safe_is_empty (files
))
22038 if (first
->lineno
> 1 || second
->lineno
> 1)
22041 else if (first
->lineno
== 0)
22044 /* Find the last define/undef entry that can be grouped together
22045 with first and at the same time compute md5 checksum of their
22046 codes, linenumbers and strings. */
22047 md5_init_ctx (&ctx
);
22048 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
22049 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
22051 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
22055 unsigned char code
= cur
->code
;
22056 md5_process_bytes (&code
, 1, &ctx
);
22057 checksum_uleb128 (cur
->lineno
, &ctx
);
22058 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
22060 md5_finish_ctx (&ctx
, checksum
);
22063 /* From the containing include filename (if any) pick up just
22064 usable characters from its basename. */
22065 if (vec_safe_is_empty (files
))
22068 base
= lbasename (files
->last ().info
);
22069 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
22070 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
22071 encoded_filename_len
++;
22072 /* Count . at the end. */
22073 if (encoded_filename_len
)
22074 encoded_filename_len
++;
22076 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
22077 linebuf_len
= strlen (linebuf
);
22079 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
22080 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
22082 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
22083 tail
= grp_name
+ 4;
22084 if (encoded_filename_len
)
22086 for (i
= 0; base
[i
]; i
++)
22087 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
22091 memcpy (tail
, linebuf
, linebuf_len
);
22092 tail
+= linebuf_len
;
22094 for (i
= 0; i
< 16; i
++)
22095 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
22097 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
22098 in the empty vector entry before the first define/undef. */
22099 inc
= &(*macinfo_table
)[idx
- 1];
22100 inc
->code
= DW_MACRO_GNU_transparent_include
;
22102 inc
->info
= ggc_strdup (grp_name
);
22103 if (!*macinfo_htab
)
22104 *macinfo_htab
= new macinfo_hash_type (10);
22105 /* Avoid emitting duplicates. */
22106 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
22111 /* If such an entry has been used before, just emit
22112 a DW_MACRO_GNU_transparent_include op. */
22114 output_macinfo_op (inc
);
22115 /* And clear all macinfo_entry in the range to avoid emitting them
22116 in the second pass. */
22117 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
22126 inc
->lineno
= (*macinfo_htab
)->elements ();
22127 output_macinfo_op (inc
);
22132 /* Save any strings needed by the macinfo table in the debug str
22133 table. All strings must be collected into the table by the time
22134 index_string is called. */
22137 save_macinfo_strings (void)
22141 macinfo_entry
*ref
;
22143 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
22147 /* Match the logic in output_macinfo_op to decide on
22148 indirect strings. */
22149 case DW_MACINFO_define
:
22150 case DW_MACINFO_undef
:
22151 len
= strlen (ref
->info
) + 1;
22153 && len
> DWARF_OFFSET_SIZE
22154 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22155 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
22156 set_indirect_string (find_AT_string (ref
->info
));
22158 case DW_MACRO_GNU_define_indirect
:
22159 case DW_MACRO_GNU_undef_indirect
:
22160 set_indirect_string (find_AT_string (ref
->info
));
22168 /* Output macinfo section(s). */
22171 output_macinfo (void)
22174 unsigned long length
= vec_safe_length (macinfo_table
);
22175 macinfo_entry
*ref
;
22176 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
22177 macinfo_hash_type
*macinfo_htab
= NULL
;
22182 /* output_macinfo* uses these interchangeably. */
22183 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_GNU_define
22184 && (int) DW_MACINFO_undef
== (int) DW_MACRO_GNU_undef
22185 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_GNU_start_file
22186 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_GNU_end_file
);
22188 /* For .debug_macro emit the section header. */
22191 dw2_asm_output_data (2, 4, "DWARF macro version number");
22192 if (DWARF_OFFSET_SIZE
== 8)
22193 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
22195 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
22196 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
22197 (!dwarf_split_debug_info
? debug_line_section_label
22198 : debug_skeleton_line_section_label
),
22199 debug_line_section
, NULL
);
22202 /* In the first loop, it emits the primary .debug_macinfo section
22203 and after each emitted op the macinfo_entry is cleared.
22204 If a longer range of define/undef ops can be optimized using
22205 DW_MACRO_GNU_transparent_include, the
22206 DW_MACRO_GNU_transparent_include op is emitted and kept in
22207 the vector before the first define/undef in the range and the
22208 whole range of define/undef ops is not emitted and kept. */
22209 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22213 case DW_MACINFO_start_file
:
22214 vec_safe_push (files
, *ref
);
22216 case DW_MACINFO_end_file
:
22217 if (!vec_safe_is_empty (files
))
22220 case DW_MACINFO_define
:
22221 case DW_MACINFO_undef
:
22223 && HAVE_COMDAT_GROUP
22224 && vec_safe_length (files
) != 1
22227 && (*macinfo_table
)[i
- 1].code
== 0)
22229 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
22238 /* A dummy entry may be inserted at the beginning to be able
22239 to optimize the whole block of predefined macros. */
22245 output_macinfo_op (ref
);
22253 delete macinfo_htab
;
22254 macinfo_htab
= NULL
;
22256 /* If any DW_MACRO_GNU_transparent_include were used, on those
22257 DW_MACRO_GNU_transparent_include entries terminate the
22258 current chain and switch to a new comdat .debug_macinfo
22259 section and emit the define/undef entries within it. */
22260 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22265 case DW_MACRO_GNU_transparent_include
:
22267 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
22268 tree comdat_key
= get_identifier (ref
->info
);
22269 /* Terminate the previous .debug_macinfo section. */
22270 dw2_asm_output_data (1, 0, "End compilation unit");
22271 targetm
.asm_out
.named_section (DEBUG_MACRO_SECTION
,
22273 | SECTION_LINKONCE
,
22275 ASM_GENERATE_INTERNAL_LABEL (label
,
22276 DEBUG_MACRO_SECTION_LABEL
,
22278 ASM_OUTPUT_LABEL (asm_out_file
, label
);
22281 dw2_asm_output_data (2, 4, "DWARF macro version number");
22282 if (DWARF_OFFSET_SIZE
== 8)
22283 dw2_asm_output_data (1, 1, "Flags: 64-bit");
22285 dw2_asm_output_data (1, 0, "Flags: 32-bit");
22288 case DW_MACINFO_define
:
22289 case DW_MACINFO_undef
:
22290 output_macinfo_op (ref
);
22295 gcc_unreachable ();
22299 /* Set up for Dwarf output at the start of compilation. */
22302 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
22304 /* Allocate the file_table. */
22305 file_table
= htab_create_ggc (50, file_table_hash
,
22306 file_table_eq
, NULL
);
22308 /* Allocate the decl_die_table. */
22309 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
22310 decl_die_table_eq
, NULL
);
22312 /* Allocate the decl_loc_table. */
22313 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
22314 decl_loc_table_eq
, NULL
);
22316 /* Allocate the cached_dw_loc_list_table. */
22317 cached_dw_loc_list_table
22318 = htab_create_ggc (10, cached_dw_loc_list_table_hash
,
22319 cached_dw_loc_list_table_eq
, NULL
);
22321 /* Allocate the initial hunk of the decl_scope_table. */
22322 vec_alloc (decl_scope_table
, 256);
22324 /* Allocate the initial hunk of the abbrev_die_table. */
22325 abbrev_die_table
= ggc_cleared_vec_alloc
<dw_die_ref
>
22326 (ABBREV_DIE_TABLE_INCREMENT
);
22327 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
22328 /* Zero-th entry is allocated, but unused. */
22329 abbrev_die_table_in_use
= 1;
22331 /* Allocate the pubtypes and pubnames vectors. */
22332 vec_alloc (pubname_table
, 32);
22333 vec_alloc (pubtype_table
, 32);
22335 vec_alloc (incomplete_types
, 64);
22337 vec_alloc (used_rtx_array
, 32);
22339 if (!dwarf_split_debug_info
)
22341 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
22342 SECTION_DEBUG
, NULL
);
22343 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22344 SECTION_DEBUG
, NULL
);
22345 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
22346 SECTION_DEBUG
, NULL
);
22350 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
22351 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22352 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
22353 SECTION_DEBUG
| SECTION_EXCLUDE
,
22355 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
22356 SECTION_DEBUG
, NULL
);
22357 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
22358 SECTION_DEBUG
, NULL
);
22359 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22360 SECTION_DEBUG
, NULL
);
22361 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
22362 DEBUG_SKELETON_ABBREV_SECTION_LABEL
, 0);
22364 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
22365 the main .o, but the skeleton_line goes into the split off dwo. */
22366 debug_skeleton_line_section
22367 = get_section (DEBUG_DWO_LINE_SECTION
,
22368 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22369 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
22370 DEBUG_SKELETON_LINE_SECTION_LABEL
, 0);
22371 debug_str_offsets_section
= get_section (DEBUG_STR_OFFSETS_SECTION
,
22372 SECTION_DEBUG
| SECTION_EXCLUDE
,
22374 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
22375 DEBUG_SKELETON_INFO_SECTION_LABEL
, 0);
22376 debug_loc_section
= get_section (DEBUG_DWO_LOC_SECTION
,
22377 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22378 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
22379 DEBUG_STR_DWO_SECTION_FLAGS
, NULL
);
22381 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
22382 SECTION_DEBUG
, NULL
);
22383 debug_macinfo_section
= get_section (dwarf_strict
22384 ? DEBUG_MACINFO_SECTION
22385 : DEBUG_MACRO_SECTION
,
22386 DEBUG_MACRO_SECTION_FLAGS
, NULL
);
22387 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
22388 SECTION_DEBUG
, NULL
);
22389 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
22390 SECTION_DEBUG
, NULL
);
22391 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
22392 SECTION_DEBUG
, NULL
);
22393 debug_str_section
= get_section (DEBUG_STR_SECTION
,
22394 DEBUG_STR_SECTION_FLAGS
, NULL
);
22395 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
22396 SECTION_DEBUG
, NULL
);
22397 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
22398 SECTION_DEBUG
, NULL
);
22400 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
22401 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
22402 DEBUG_ABBREV_SECTION_LABEL
, 0);
22403 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
22404 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
22405 COLD_TEXT_SECTION_LABEL
, 0);
22406 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
22408 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
22409 DEBUG_INFO_SECTION_LABEL
, 0);
22410 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
22411 DEBUG_LINE_SECTION_LABEL
, 0);
22412 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
22413 DEBUG_RANGES_SECTION_LABEL
, 0);
22414 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
22415 DEBUG_ADDR_SECTION_LABEL
, 0);
22416 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
22418 ? DEBUG_MACINFO_SECTION_LABEL
22419 : DEBUG_MACRO_SECTION_LABEL
, 0);
22420 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
, 0);
22422 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22423 vec_alloc (macinfo_table
, 64);
22425 switch_to_section (text_section
);
22426 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
22428 /* Make sure the line number table for .text always exists. */
22429 text_section_line_info
= new_line_info_table ();
22430 text_section_line_info
->end_label
= text_end_label
;
22433 /* Called before compile () starts outputtting functions, variables
22434 and toplevel asms into assembly. */
22437 dwarf2out_assembly_start (void)
22439 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
22440 && dwarf2out_do_cfi_asm ()
22441 && (!(flag_unwind_tables
|| flag_exceptions
)
22442 || targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
))
22443 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
22446 /* A helper function for dwarf2out_finish called through
22447 htab_traverse. Assign a string its index. All strings must be
22448 collected into the table by the time index_string is called,
22449 because the indexing code relies on htab_traverse to traverse nodes
22450 in the same order for each run. */
22453 index_string (void **h
, void *v
)
22455 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22456 unsigned int *index
= (unsigned int *) v
;
22458 find_string_form (node
);
22459 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22461 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
22462 node
->index
= *index
;
22468 /* A helper function for output_indirect_strings called through
22469 htab_traverse. Output the offset to a string and update the
22473 output_index_string_offset (void **h
, void *v
)
22475 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22476 unsigned int *offset
= (unsigned int *) v
;
22478 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22480 /* Assert that this node has been assigned an index. */
22481 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
22482 && node
->index
!= NOT_INDEXED
);
22483 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
22484 "indexed string 0x%x: %s", node
->index
, node
->str
);
22485 *offset
+= strlen (node
->str
) + 1;
22490 /* A helper function for dwarf2out_finish called through
22491 htab_traverse. Output the indexed string. */
22494 output_index_string (void **h
, void *v
)
22496 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22497 unsigned int *cur_idx
= (unsigned int *) v
;
22499 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22501 /* Assert that the strings are output in the same order as their
22502 indexes were assigned. */
22503 gcc_assert (*cur_idx
== node
->index
);
22504 assemble_string (node
->str
, strlen (node
->str
) + 1);
22510 /* A helper function for dwarf2out_finish called through
22511 htab_traverse. Emit one queued .debug_str string. */
22514 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
22516 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22518 node
->form
= find_string_form (node
);
22519 if (node
->form
== DW_FORM_strp
&& node
->refcount
> 0)
22521 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
22522 assemble_string (node
->str
, strlen (node
->str
) + 1);
22528 /* Output the indexed string table. */
22531 output_indirect_strings (void)
22533 switch_to_section (debug_str_section
);
22534 if (!dwarf_split_debug_info
)
22535 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
22538 unsigned int offset
= 0;
22539 unsigned int cur_idx
= 0;
22541 htab_traverse (skeleton_debug_str_hash
, output_indirect_string
, NULL
);
22543 switch_to_section (debug_str_offsets_section
);
22544 htab_traverse_noresize (debug_str_hash
,
22545 output_index_string_offset
,
22547 switch_to_section (debug_str_dwo_section
);
22548 htab_traverse_noresize (debug_str_hash
,
22549 output_index_string
,
22554 /* Callback for htab_traverse to assign an index to an entry in the
22555 table, and to write that entry to the .debug_addr section. */
22558 output_addr_table_entry (void **slot
, void *data
)
22560 addr_table_entry
*entry
= (addr_table_entry
*) *slot
;
22561 unsigned int *cur_index
= (unsigned int *)data
;
22563 if (entry
->refcount
== 0)
22565 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
22566 || entry
->index
== NOT_INDEXED
);
22570 gcc_assert (entry
->index
== *cur_index
);
22573 switch (entry
->kind
)
22576 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
22577 "0x%x", entry
->index
);
22579 case ate_kind_rtx_dtprel
:
22580 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
22581 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
22584 fputc ('\n', asm_out_file
);
22586 case ate_kind_label
:
22587 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
22588 "0x%x", entry
->index
);
22591 gcc_unreachable ();
22596 /* Produce the .debug_addr section. */
22599 output_addr_table (void)
22601 unsigned int index
= 0;
22602 if (addr_index_table
== NULL
|| htab_size (addr_index_table
) == 0)
22605 switch_to_section (debug_addr_section
);
22606 htab_traverse_noresize (addr_index_table
, output_addr_table_entry
, &index
);
22609 #if ENABLE_ASSERT_CHECKING
22610 /* Verify that all marks are clear. */
22613 verify_marks_clear (dw_die_ref die
)
22617 gcc_assert (! die
->die_mark
);
22618 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
22620 #endif /* ENABLE_ASSERT_CHECKING */
22622 /* Clear the marks for a die and its children.
22623 Be cool if the mark isn't set. */
22626 prune_unmark_dies (dw_die_ref die
)
22632 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
22635 /* Given DIE that we're marking as used, find any other dies
22636 it references as attributes and mark them as used. */
22639 prune_unused_types_walk_attribs (dw_die_ref die
)
22644 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22646 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
22648 /* A reference to another DIE.
22649 Make sure that it will get emitted.
22650 If it was broken out into a comdat group, don't follow it. */
22651 if (! AT_ref (a
)->comdat_type_p
22652 || a
->dw_attr
== DW_AT_specification
)
22653 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
22655 /* Set the string's refcount to 0 so that prune_unused_types_mark
22656 accounts properly for it. */
22657 if (AT_class (a
) == dw_val_class_str
)
22658 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
22662 /* Mark the generic parameters and arguments children DIEs of DIE. */
22665 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
22669 if (die
== NULL
|| die
->die_child
== NULL
)
22671 c
= die
->die_child
;
22674 if (is_template_parameter (c
))
22675 prune_unused_types_mark (c
, 1);
22677 } while (c
&& c
!= die
->die_child
);
22680 /* Mark DIE as being used. If DOKIDS is true, then walk down
22681 to DIE's children. */
22684 prune_unused_types_mark (dw_die_ref die
, int dokids
)
22688 if (die
->die_mark
== 0)
22690 /* We haven't done this node yet. Mark it as used. */
22692 /* If this is the DIE of a generic type instantiation,
22693 mark the children DIEs that describe its generic parms and
22695 prune_unused_types_mark_generic_parms_dies (die
);
22697 /* We also have to mark its parents as used.
22698 (But we don't want to mark our parent's kids due to this,
22699 unless it is a class.) */
22700 if (die
->die_parent
)
22701 prune_unused_types_mark (die
->die_parent
,
22702 class_scope_p (die
->die_parent
));
22704 /* Mark any referenced nodes. */
22705 prune_unused_types_walk_attribs (die
);
22707 /* If this node is a specification,
22708 also mark the definition, if it exists. */
22709 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
22710 prune_unused_types_mark (die
->die_definition
, 1);
22713 if (dokids
&& die
->die_mark
!= 2)
22715 /* We need to walk the children, but haven't done so yet.
22716 Remember that we've walked the kids. */
22719 /* If this is an array type, we need to make sure our
22720 kids get marked, even if they're types. If we're
22721 breaking out types into comdat sections, do this
22722 for all type definitions. */
22723 if (die
->die_tag
== DW_TAG_array_type
22724 || (use_debug_types
22725 && is_type_die (die
) && ! is_declaration_die (die
)))
22726 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
22728 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22732 /* For local classes, look if any static member functions were emitted
22733 and if so, mark them. */
22736 prune_unused_types_walk_local_classes (dw_die_ref die
)
22740 if (die
->die_mark
== 2)
22743 switch (die
->die_tag
)
22745 case DW_TAG_structure_type
:
22746 case DW_TAG_union_type
:
22747 case DW_TAG_class_type
:
22750 case DW_TAG_subprogram
:
22751 if (!get_AT_flag (die
, DW_AT_declaration
)
22752 || die
->die_definition
!= NULL
)
22753 prune_unused_types_mark (die
, 1);
22760 /* Mark children. */
22761 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
22764 /* Walk the tree DIE and mark types that we actually use. */
22767 prune_unused_types_walk (dw_die_ref die
)
22771 /* Don't do anything if this node is already marked and
22772 children have been marked as well. */
22773 if (die
->die_mark
== 2)
22776 switch (die
->die_tag
)
22778 case DW_TAG_structure_type
:
22779 case DW_TAG_union_type
:
22780 case DW_TAG_class_type
:
22781 if (die
->die_perennial_p
)
22784 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
22785 if (c
->die_tag
== DW_TAG_subprogram
)
22788 /* Finding used static member functions inside of classes
22789 is needed just for local classes, because for other classes
22790 static member function DIEs with DW_AT_specification
22791 are emitted outside of the DW_TAG_*_type. If we ever change
22792 it, we'd need to call this even for non-local classes. */
22794 prune_unused_types_walk_local_classes (die
);
22796 /* It's a type node --- don't mark it. */
22799 case DW_TAG_const_type
:
22800 case DW_TAG_packed_type
:
22801 case DW_TAG_pointer_type
:
22802 case DW_TAG_reference_type
:
22803 case DW_TAG_rvalue_reference_type
:
22804 case DW_TAG_volatile_type
:
22805 case DW_TAG_typedef
:
22806 case DW_TAG_array_type
:
22807 case DW_TAG_interface_type
:
22808 case DW_TAG_friend
:
22809 case DW_TAG_variant_part
:
22810 case DW_TAG_enumeration_type
:
22811 case DW_TAG_subroutine_type
:
22812 case DW_TAG_string_type
:
22813 case DW_TAG_set_type
:
22814 case DW_TAG_subrange_type
:
22815 case DW_TAG_ptr_to_member_type
:
22816 case DW_TAG_file_type
:
22817 if (die
->die_perennial_p
)
22820 /* It's a type node --- don't mark it. */
22824 /* Mark everything else. */
22828 if (die
->die_mark
== 0)
22832 /* Now, mark any dies referenced from here. */
22833 prune_unused_types_walk_attribs (die
);
22838 /* Mark children. */
22839 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22842 /* Increment the string counts on strings referred to from DIE's
22846 prune_unused_types_update_strings (dw_die_ref die
)
22851 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22852 if (AT_class (a
) == dw_val_class_str
)
22854 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
22856 /* Avoid unnecessarily putting strings that are used less than
22857 twice in the hash table. */
22859 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
22862 slot
= htab_find_slot_with_hash (debug_str_hash
, s
->str
,
22863 htab_hash_string (s
->str
),
22865 gcc_assert (*slot
== NULL
);
22871 /* Remove from the tree DIE any dies that aren't marked. */
22874 prune_unused_types_prune (dw_die_ref die
)
22878 gcc_assert (die
->die_mark
);
22879 prune_unused_types_update_strings (die
);
22881 if (! die
->die_child
)
22884 c
= die
->die_child
;
22886 dw_die_ref prev
= c
;
22887 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
22888 if (c
== die
->die_child
)
22890 /* No marked children between 'prev' and the end of the list. */
22892 /* No marked children at all. */
22893 die
->die_child
= NULL
;
22896 prev
->die_sib
= c
->die_sib
;
22897 die
->die_child
= prev
;
22902 if (c
!= prev
->die_sib
)
22904 prune_unused_types_prune (c
);
22905 } while (c
!= die
->die_child
);
22908 /* Remove dies representing declarations that we never use. */
22911 prune_unused_types (void)
22914 limbo_die_node
*node
;
22915 comdat_type_node
*ctnode
;
22917 dw_die_ref base_type
;
22919 #if ENABLE_ASSERT_CHECKING
22920 /* All the marks should already be clear. */
22921 verify_marks_clear (comp_unit_die ());
22922 for (node
= limbo_die_list
; node
; node
= node
->next
)
22923 verify_marks_clear (node
->die
);
22924 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22925 verify_marks_clear (ctnode
->root_die
);
22926 #endif /* ENABLE_ASSERT_CHECKING */
22928 /* Mark types that are used in global variables. */
22929 premark_types_used_by_global_vars ();
22931 /* Set the mark on nodes that are actually used. */
22932 prune_unused_types_walk (comp_unit_die ());
22933 for (node
= limbo_die_list
; node
; node
= node
->next
)
22934 prune_unused_types_walk (node
->die
);
22935 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22937 prune_unused_types_walk (ctnode
->root_die
);
22938 prune_unused_types_mark (ctnode
->type_die
, 1);
22941 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
22942 are unusual in that they are pubnames that are the children of pubtypes.
22943 They should only be marked via their parent DW_TAG_enumeration_type die,
22944 not as roots in themselves. */
22945 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
22946 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
22947 prune_unused_types_mark (pub
->die
, 1);
22948 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
22949 prune_unused_types_mark (base_type
, 1);
22951 if (debug_str_hash
)
22952 htab_empty (debug_str_hash
);
22953 if (skeleton_debug_str_hash
)
22954 htab_empty (skeleton_debug_str_hash
);
22955 prune_unused_types_prune (comp_unit_die ());
22956 for (node
= limbo_die_list
; node
; node
= node
->next
)
22957 prune_unused_types_prune (node
->die
);
22958 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22959 prune_unused_types_prune (ctnode
->root_die
);
22961 /* Leave the marks clear. */
22962 prune_unmark_dies (comp_unit_die ());
22963 for (node
= limbo_die_list
; node
; node
= node
->next
)
22964 prune_unmark_dies (node
->die
);
22965 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22966 prune_unmark_dies (ctnode
->root_die
);
22969 /* Set the parameter to true if there are any relative pathnames in
22972 file_table_relative_p (void ** slot
, void *param
)
22974 bool *p
= (bool *) param
;
22975 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
22976 if (!IS_ABSOLUTE_PATH (d
->filename
))
22984 /* Helpers to manipulate hash table of comdat type units. */
22986 struct comdat_type_hasher
: typed_noop_remove
<comdat_type_node
>
22988 typedef comdat_type_node value_type
;
22989 typedef comdat_type_node compare_type
;
22990 static inline hashval_t
hash (const value_type
*);
22991 static inline bool equal (const value_type
*, const compare_type
*);
22995 comdat_type_hasher::hash (const value_type
*type_node
)
22998 memcpy (&h
, type_node
->signature
, sizeof (h
));
23003 comdat_type_hasher::equal (const value_type
*type_node_1
,
23004 const compare_type
*type_node_2
)
23006 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
23007 DWARF_TYPE_SIGNATURE_SIZE
));
23010 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
23011 to the location it would have been added, should we know its
23012 DECL_ASSEMBLER_NAME when we added other attributes. This will
23013 probably improve compactness of debug info, removing equivalent
23014 abbrevs, and hide any differences caused by deferring the
23015 computation of the assembler name, triggered by e.g. PCH. */
23018 move_linkage_attr (dw_die_ref die
)
23020 unsigned ix
= vec_safe_length (die
->die_attr
);
23021 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
23023 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
23024 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
23028 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
23030 if (prev
->dw_attr
== DW_AT_decl_line
|| prev
->dw_attr
== DW_AT_name
)
23034 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
23036 die
->die_attr
->pop ();
23037 die
->die_attr
->quick_insert (ix
, linkage
);
23041 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
23042 referenced from typed stack ops and count how often they are used. */
23045 mark_base_types (dw_loc_descr_ref loc
)
23047 dw_die_ref base_type
= NULL
;
23049 for (; loc
; loc
= loc
->dw_loc_next
)
23051 switch (loc
->dw_loc_opc
)
23053 case DW_OP_GNU_regval_type
:
23054 case DW_OP_GNU_deref_type
:
23055 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
23057 case DW_OP_GNU_convert
:
23058 case DW_OP_GNU_reinterpret
:
23059 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
23062 case DW_OP_GNU_const_type
:
23063 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23065 case DW_OP_GNU_entry_value
:
23066 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
23071 gcc_assert (base_type
->die_parent
== comp_unit_die ());
23072 if (base_type
->die_mark
)
23073 base_type
->die_mark
++;
23076 base_types
.safe_push (base_type
);
23077 base_type
->die_mark
= 1;
23082 /* Comparison function for sorting marked base types. */
23085 base_type_cmp (const void *x
, const void *y
)
23087 dw_die_ref dx
= *(const dw_die_ref
*) x
;
23088 dw_die_ref dy
= *(const dw_die_ref
*) y
;
23089 unsigned int byte_size1
, byte_size2
;
23090 unsigned int encoding1
, encoding2
;
23091 if (dx
->die_mark
> dy
->die_mark
)
23093 if (dx
->die_mark
< dy
->die_mark
)
23095 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
23096 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
23097 if (byte_size1
< byte_size2
)
23099 if (byte_size1
> byte_size2
)
23101 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
23102 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
23103 if (encoding1
< encoding2
)
23105 if (encoding1
> encoding2
)
23110 /* Move base types marked by mark_base_types as early as possible
23111 in the CU, sorted by decreasing usage count both to make the
23112 uleb128 references as small as possible and to make sure they
23113 will have die_offset already computed by calc_die_sizes when
23114 sizes of typed stack loc ops is computed. */
23117 move_marked_base_types (void)
23120 dw_die_ref base_type
, die
, c
;
23122 if (base_types
.is_empty ())
23125 /* Sort by decreasing usage count, they will be added again in that
23127 base_types
.qsort (base_type_cmp
);
23128 die
= comp_unit_die ();
23129 c
= die
->die_child
;
23132 dw_die_ref prev
= c
;
23134 while (c
->die_mark
)
23136 remove_child_with_prev (c
, prev
);
23137 /* As base types got marked, there must be at least
23138 one node other than DW_TAG_base_type. */
23139 gcc_assert (c
!= c
->die_sib
);
23143 while (c
!= die
->die_child
);
23144 gcc_assert (die
->die_child
);
23145 c
= die
->die_child
;
23146 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
23148 base_type
->die_mark
= 0;
23149 base_type
->die_sib
= c
->die_sib
;
23150 c
->die_sib
= base_type
;
23155 /* Helper function for resolve_addr, attempt to resolve
23156 one CONST_STRING, return true if successful. Similarly verify that
23157 SYMBOL_REFs refer to variables emitted in the current CU. */
23160 resolve_one_addr (rtx
*addr
)
23164 if (GET_CODE (rtl
) == CONST_STRING
)
23166 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
23167 tree t
= build_string (len
, XSTR (rtl
, 0));
23168 tree tlen
= size_int (len
- 1);
23170 = build_array_type (char_type_node
, build_index_type (tlen
));
23171 rtl
= lookup_constant_def (t
);
23172 if (!rtl
|| !MEM_P (rtl
))
23174 rtl
= XEXP (rtl
, 0);
23175 if (GET_CODE (rtl
) == SYMBOL_REF
23176 && SYMBOL_REF_DECL (rtl
)
23177 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
23179 vec_safe_push (used_rtx_array
, rtl
);
23184 if (GET_CODE (rtl
) == SYMBOL_REF
23185 && SYMBOL_REF_DECL (rtl
))
23187 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
23189 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
23192 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
23196 if (GET_CODE (rtl
) == CONST
)
23198 subrtx_ptr_iterator::array_type array
;
23199 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
23200 if (!resolve_one_addr (*iter
))
23207 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
23208 if possible, and create DW_TAG_dwarf_procedure that can be referenced
23209 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
23212 string_cst_pool_decl (tree t
)
23214 rtx rtl
= output_constant_def (t
, 1);
23215 unsigned char *array
;
23216 dw_loc_descr_ref l
;
23221 if (!rtl
|| !MEM_P (rtl
))
23223 rtl
= XEXP (rtl
, 0);
23224 if (GET_CODE (rtl
) != SYMBOL_REF
23225 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
23228 decl
= SYMBOL_REF_DECL (rtl
);
23229 if (!lookup_decl_die (decl
))
23231 len
= TREE_STRING_LENGTH (t
);
23232 vec_safe_push (used_rtx_array
, rtl
);
23233 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
23234 array
= ggc_vec_alloc
<unsigned char> (len
);
23235 memcpy (array
, TREE_STRING_POINTER (t
), len
);
23236 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
23237 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
23238 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
23239 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
23240 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
23241 add_AT_loc (ref
, DW_AT_location
, l
);
23242 equate_decl_number_to_die (decl
, ref
);
23247 /* Helper function of resolve_addr_in_expr. LOC is
23248 a DW_OP_addr followed by DW_OP_stack_value, either at the start
23249 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
23250 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
23251 with DW_OP_GNU_implicit_pointer if possible
23252 and return true, if unsuccessful, return false. */
23255 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
23257 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
23258 HOST_WIDE_INT offset
= 0;
23259 dw_die_ref ref
= NULL
;
23262 if (GET_CODE (rtl
) == CONST
23263 && GET_CODE (XEXP (rtl
, 0)) == PLUS
23264 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
23266 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
23267 rtl
= XEXP (XEXP (rtl
, 0), 0);
23269 if (GET_CODE (rtl
) == CONST_STRING
)
23271 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
23272 tree t
= build_string (len
, XSTR (rtl
, 0));
23273 tree tlen
= size_int (len
- 1);
23276 = build_array_type (char_type_node
, build_index_type (tlen
));
23277 rtl
= string_cst_pool_decl (t
);
23281 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
23283 decl
= SYMBOL_REF_DECL (rtl
);
23284 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
23286 ref
= lookup_decl_die (decl
);
23287 if (ref
&& (get_AT (ref
, DW_AT_location
)
23288 || get_AT (ref
, DW_AT_const_value
)))
23290 loc
->dw_loc_opc
= DW_OP_GNU_implicit_pointer
;
23291 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23292 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
23293 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23294 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23295 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23296 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
23304 /* Helper function for resolve_addr, handle one location
23305 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23306 the location list couldn't be resolved. */
23309 resolve_addr_in_expr (dw_loc_descr_ref loc
)
23311 dw_loc_descr_ref keep
= NULL
;
23312 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
23313 switch (loc
->dw_loc_opc
)
23316 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
23319 || prev
->dw_loc_opc
== DW_OP_piece
23320 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
23321 && loc
->dw_loc_next
23322 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
23324 && optimize_one_addr_into_implicit_ptr (loc
))
23329 case DW_OP_GNU_addr_index
:
23330 case DW_OP_GNU_const_index
:
23331 if (loc
->dw_loc_opc
== DW_OP_GNU_addr_index
23332 || (loc
->dw_loc_opc
== DW_OP_GNU_const_index
&& loc
->dtprel
))
23334 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
23335 if (!resolve_one_addr (&rtl
))
23337 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
23338 loc
->dw_loc_oprnd1
.val_entry
=
23339 add_addr_table_entry (rtl
, ate_kind_rtx
);
23342 case DW_OP_const4u
:
23343 case DW_OP_const8u
:
23345 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
23348 case DW_OP_plus_uconst
:
23349 if (size_of_loc_descr (loc
)
23350 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
23352 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
23354 dw_loc_descr_ref repl
23355 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
23356 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
23357 add_loc_descr (&repl
, loc
->dw_loc_next
);
23361 case DW_OP_implicit_value
:
23362 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
23363 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
23366 case DW_OP_GNU_implicit_pointer
:
23367 case DW_OP_GNU_parameter_ref
:
23368 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
23371 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
23374 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23375 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23376 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23379 case DW_OP_GNU_const_type
:
23380 case DW_OP_GNU_regval_type
:
23381 case DW_OP_GNU_deref_type
:
23382 case DW_OP_GNU_convert
:
23383 case DW_OP_GNU_reinterpret
:
23384 while (loc
->dw_loc_next
23385 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
)
23387 dw_die_ref base1
, base2
;
23388 unsigned enc1
, enc2
, size1
, size2
;
23389 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23390 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23391 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
23392 else if (loc
->dw_loc_oprnd1
.val_class
23393 == dw_val_class_unsigned_const
)
23396 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23397 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
23398 == dw_val_class_unsigned_const
)
23400 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23401 gcc_assert (base1
->die_tag
== DW_TAG_base_type
23402 && base2
->die_tag
== DW_TAG_base_type
);
23403 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
23404 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
23405 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
23406 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
23408 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
23409 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
23413 /* Optimize away next DW_OP_GNU_convert after
23414 adjusting LOC's base type die reference. */
23415 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23416 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23417 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
23419 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
23420 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23423 /* Don't change integer DW_OP_GNU_convert after e.g. floating
23424 point typed stack entry. */
23425 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
23426 keep
= loc
->dw_loc_next
;
23436 /* Helper function of resolve_addr. DIE had DW_AT_location of
23437 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
23438 and DW_OP_addr couldn't be resolved. resolve_addr has already
23439 removed the DW_AT_location attribute. This function attempts to
23440 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
23441 to it or DW_AT_const_value attribute, if possible. */
23444 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
23446 if (TREE_CODE (decl
) != VAR_DECL
23447 || lookup_decl_die (decl
) != die
23448 || DECL_EXTERNAL (decl
)
23449 || !TREE_STATIC (decl
)
23450 || DECL_INITIAL (decl
) == NULL_TREE
23451 || DECL_P (DECL_INITIAL (decl
))
23452 || get_AT (die
, DW_AT_const_value
))
23455 tree init
= DECL_INITIAL (decl
);
23456 HOST_WIDE_INT offset
= 0;
23457 /* For variables that have been optimized away and thus
23458 don't have a memory location, see if we can emit
23459 DW_AT_const_value instead. */
23460 if (tree_add_const_value_attribute (die
, init
))
23464 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
23465 and ADDR_EXPR refers to a decl that has DW_AT_location or
23466 DW_AT_const_value (but isn't addressable, otherwise
23467 resolving the original DW_OP_addr wouldn't fail), see if
23468 we can add DW_OP_GNU_implicit_pointer. */
23470 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
23471 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
23473 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
23474 init
= TREE_OPERAND (init
, 0);
23477 if (TREE_CODE (init
) != ADDR_EXPR
)
23479 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
23480 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
23481 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
23482 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
23483 && TREE_OPERAND (init
, 0) != decl
))
23486 dw_loc_descr_ref l
;
23488 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
23490 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
23493 decl
= SYMBOL_REF_DECL (rtl
);
23496 decl
= TREE_OPERAND (init
, 0);
23497 ref
= lookup_decl_die (decl
);
23499 || (!get_AT (ref
, DW_AT_location
)
23500 && !get_AT (ref
, DW_AT_const_value
)))
23502 l
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
23503 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23504 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23505 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23506 add_AT_loc (die
, DW_AT_location
, l
);
23510 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23511 an address in .rodata section if the string literal is emitted there,
23512 or remove the containing location list or replace DW_AT_const_value
23513 with DW_AT_location and empty location expression, if it isn't found
23514 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23515 to something that has been emitted in the current CU. */
23518 resolve_addr (dw_die_ref die
)
23522 dw_loc_list_ref
*curr
, *start
, loc
;
23525 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23526 switch (AT_class (a
))
23528 case dw_val_class_loc_list
:
23529 start
= curr
= AT_loc_list_ptr (a
);
23532 /* The same list can be referenced more than once. See if we have
23533 already recorded the result from a previous pass. */
23535 *curr
= loc
->dw_loc_next
;
23536 else if (!loc
->resolved_addr
)
23538 /* As things stand, we do not expect or allow one die to
23539 reference a suffix of another die's location list chain.
23540 References must be identical or completely separate.
23541 There is therefore no need to cache the result of this
23542 pass on any list other than the first; doing so
23543 would lead to unnecessary writes. */
23546 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
23547 if (!resolve_addr_in_expr ((*curr
)->expr
))
23549 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
23550 dw_loc_descr_ref l
= (*curr
)->expr
;
23552 if (next
&& (*curr
)->ll_symbol
)
23554 gcc_assert (!next
->ll_symbol
);
23555 next
->ll_symbol
= (*curr
)->ll_symbol
;
23557 if (dwarf_split_debug_info
)
23558 remove_loc_list_addr_table_entries (l
);
23563 mark_base_types ((*curr
)->expr
);
23564 curr
= &(*curr
)->dw_loc_next
;
23568 loc
->resolved_addr
= 1;
23572 loc
->dw_loc_next
= *start
;
23577 remove_AT (die
, a
->dw_attr
);
23581 case dw_val_class_loc
:
23583 dw_loc_descr_ref l
= AT_loc (a
);
23584 /* For -gdwarf-2 don't attempt to optimize
23585 DW_AT_data_member_location containing
23586 DW_OP_plus_uconst - older consumers might
23587 rely on it being that op instead of a more complex,
23588 but shorter, location description. */
23589 if ((dwarf_version
> 2
23590 || a
->dw_attr
!= DW_AT_data_member_location
23592 || l
->dw_loc_opc
!= DW_OP_plus_uconst
23593 || l
->dw_loc_next
!= NULL
)
23594 && !resolve_addr_in_expr (l
))
23596 if (dwarf_split_debug_info
)
23597 remove_loc_list_addr_table_entries (l
);
23599 && l
->dw_loc_next
== NULL
23600 && l
->dw_loc_opc
== DW_OP_addr
23601 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
23602 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
23603 && a
->dw_attr
== DW_AT_location
)
23605 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
23606 remove_AT (die
, a
->dw_attr
);
23608 optimize_location_into_implicit_ptr (die
, decl
);
23611 remove_AT (die
, a
->dw_attr
);
23615 mark_base_types (l
);
23618 case dw_val_class_addr
:
23619 if (a
->dw_attr
== DW_AT_const_value
23620 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
23622 if (AT_index (a
) != NOT_INDEXED
)
23623 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23624 remove_AT (die
, a
->dw_attr
);
23627 if (die
->die_tag
== DW_TAG_GNU_call_site
23628 && a
->dw_attr
== DW_AT_abstract_origin
)
23630 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
23631 dw_die_ref tdie
= lookup_decl_die (tdecl
);
23633 && DECL_EXTERNAL (tdecl
)
23634 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
)
23636 force_decl_die (tdecl
);
23637 tdie
= lookup_decl_die (tdecl
);
23641 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
23642 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
23643 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
23647 if (AT_index (a
) != NOT_INDEXED
)
23648 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23649 remove_AT (die
, a
->dw_attr
);
23658 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
23661 /* Helper routines for optimize_location_lists.
23662 This pass tries to share identical local lists in .debug_loc
23665 /* Iteratively hash operands of LOC opcode into HSTATE. */
23668 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
23670 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
23671 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
23673 switch (loc
->dw_loc_opc
)
23675 case DW_OP_const4u
:
23676 case DW_OP_const8u
:
23680 case DW_OP_const1u
:
23681 case DW_OP_const1s
:
23682 case DW_OP_const2u
:
23683 case DW_OP_const2s
:
23684 case DW_OP_const4s
:
23685 case DW_OP_const8s
:
23689 case DW_OP_plus_uconst
:
23725 case DW_OP_deref_size
:
23726 case DW_OP_xderef_size
:
23727 hstate
.add_object (val1
->v
.val_int
);
23734 gcc_assert (val1
->val_class
== dw_val_class_loc
);
23735 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
23736 hstate
.add_object (offset
);
23739 case DW_OP_implicit_value
:
23740 hstate
.add_object (val1
->v
.val_unsigned
);
23741 switch (val2
->val_class
)
23743 case dw_val_class_const
:
23744 hstate
.add_object (val2
->v
.val_int
);
23746 case dw_val_class_vec
:
23748 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23749 unsigned int len
= val2
->v
.val_vec
.length
;
23751 hstate
.add_int (elt_size
);
23752 hstate
.add_int (len
);
23753 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
23756 case dw_val_class_const_double
:
23757 hstate
.add_object (val2
->v
.val_double
.low
);
23758 hstate
.add_object (val2
->v
.val_double
.high
);
23760 case dw_val_class_wide_int
:
23761 hstate
.add_object (*val2
->v
.val_wide
);
23763 case dw_val_class_addr
:
23764 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
23767 gcc_unreachable ();
23771 case DW_OP_bit_piece
:
23772 hstate
.add_object (val1
->v
.val_int
);
23773 hstate
.add_object (val2
->v
.val_int
);
23779 unsigned char dtprel
= 0xd1;
23780 hstate
.add_object (dtprel
);
23782 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
23784 case DW_OP_GNU_addr_index
:
23785 case DW_OP_GNU_const_index
:
23789 unsigned char dtprel
= 0xd1;
23790 hstate
.add_object (dtprel
);
23792 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
23795 case DW_OP_GNU_implicit_pointer
:
23796 hstate
.add_int (val2
->v
.val_int
);
23798 case DW_OP_GNU_entry_value
:
23799 hstate
.add_object (val1
->v
.val_loc
);
23801 case DW_OP_GNU_regval_type
:
23802 case DW_OP_GNU_deref_type
:
23804 unsigned int byte_size
23805 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23806 unsigned int encoding
23807 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
23808 hstate
.add_object (val1
->v
.val_int
);
23809 hstate
.add_object (byte_size
);
23810 hstate
.add_object (encoding
);
23813 case DW_OP_GNU_convert
:
23814 case DW_OP_GNU_reinterpret
:
23815 if (val1
->val_class
== dw_val_class_unsigned_const
)
23817 hstate
.add_object (val1
->v
.val_unsigned
);
23821 case DW_OP_GNU_const_type
:
23823 unsigned int byte_size
23824 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23825 unsigned int encoding
23826 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
23827 hstate
.add_object (byte_size
);
23828 hstate
.add_object (encoding
);
23829 if (loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
23831 hstate
.add_object (val2
->val_class
);
23832 switch (val2
->val_class
)
23834 case dw_val_class_const
:
23835 hstate
.add_object (val2
->v
.val_int
);
23837 case dw_val_class_vec
:
23839 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23840 unsigned int len
= val2
->v
.val_vec
.length
;
23842 hstate
.add_object (elt_size
);
23843 hstate
.add_object (len
);
23844 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
23847 case dw_val_class_const_double
:
23848 hstate
.add_object (val2
->v
.val_double
.low
);
23849 hstate
.add_object (val2
->v
.val_double
.high
);
23851 case dw_val_class_wide_int
:
23852 hstate
.add_object (*val2
->v
.val_wide
);
23855 gcc_unreachable ();
23861 /* Other codes have no operands. */
23866 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
23869 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
23871 dw_loc_descr_ref l
;
23872 bool sizes_computed
= false;
23873 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
23874 size_of_locs (loc
);
23876 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
23878 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
23879 hstate
.add_object (opc
);
23880 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
23882 size_of_locs (loc
);
23883 sizes_computed
= true;
23885 hash_loc_operands (l
, hstate
);
23889 /* Compute hash of the whole location list LIST_HEAD. */
23892 hash_loc_list (dw_loc_list_ref list_head
)
23894 dw_loc_list_ref curr
= list_head
;
23895 inchash::hash hstate
;
23897 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
23899 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
23900 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
23902 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
23903 hash_locs (curr
->expr
, hstate
);
23905 list_head
->hash
= hstate
.end ();
23908 /* Return true if X and Y opcodes have the same operands. */
23911 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
23913 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
23914 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
23915 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
23916 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
23918 switch (x
->dw_loc_opc
)
23920 case DW_OP_const4u
:
23921 case DW_OP_const8u
:
23925 case DW_OP_const1u
:
23926 case DW_OP_const1s
:
23927 case DW_OP_const2u
:
23928 case DW_OP_const2s
:
23929 case DW_OP_const4s
:
23930 case DW_OP_const8s
:
23934 case DW_OP_plus_uconst
:
23970 case DW_OP_deref_size
:
23971 case DW_OP_xderef_size
:
23972 return valx1
->v
.val_int
== valy1
->v
.val_int
;
23975 /* If splitting debug info, the use of DW_OP_GNU_addr_index
23976 can cause irrelevant differences in dw_loc_addr. */
23977 gcc_assert (valx1
->val_class
== dw_val_class_loc
23978 && valy1
->val_class
== dw_val_class_loc
23979 && (dwarf_split_debug_info
23980 || x
->dw_loc_addr
== y
->dw_loc_addr
));
23981 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
23982 case DW_OP_implicit_value
:
23983 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
23984 || valx2
->val_class
!= valy2
->val_class
)
23986 switch (valx2
->val_class
)
23988 case dw_val_class_const
:
23989 return valx2
->v
.val_int
== valy2
->v
.val_int
;
23990 case dw_val_class_vec
:
23991 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
23992 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
23993 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
23994 valx2
->v
.val_vec
.elt_size
23995 * valx2
->v
.val_vec
.length
) == 0;
23996 case dw_val_class_const_double
:
23997 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
23998 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
23999 case dw_val_class_wide_int
:
24000 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
24001 case dw_val_class_addr
:
24002 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
24004 gcc_unreachable ();
24007 case DW_OP_bit_piece
:
24008 return valx1
->v
.val_int
== valy1
->v
.val_int
24009 && valx2
->v
.val_int
== valy2
->v
.val_int
;
24012 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
24013 case DW_OP_GNU_addr_index
:
24014 case DW_OP_GNU_const_index
:
24016 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
24017 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
24018 return rtx_equal_p (ax1
, ay1
);
24020 case DW_OP_GNU_implicit_pointer
:
24021 return valx1
->val_class
== dw_val_class_die_ref
24022 && valx1
->val_class
== valy1
->val_class
24023 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
24024 && valx2
->v
.val_int
== valy2
->v
.val_int
;
24025 case DW_OP_GNU_entry_value
:
24026 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
24027 case DW_OP_GNU_const_type
:
24028 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
24029 || valx2
->val_class
!= valy2
->val_class
)
24031 switch (valx2
->val_class
)
24033 case dw_val_class_const
:
24034 return valx2
->v
.val_int
== valy2
->v
.val_int
;
24035 case dw_val_class_vec
:
24036 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
24037 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
24038 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
24039 valx2
->v
.val_vec
.elt_size
24040 * valx2
->v
.val_vec
.length
) == 0;
24041 case dw_val_class_const_double
:
24042 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
24043 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
24044 case dw_val_class_wide_int
:
24045 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
24047 gcc_unreachable ();
24049 case DW_OP_GNU_regval_type
:
24050 case DW_OP_GNU_deref_type
:
24051 return valx1
->v
.val_int
== valy1
->v
.val_int
24052 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
24053 case DW_OP_GNU_convert
:
24054 case DW_OP_GNU_reinterpret
:
24055 if (valx1
->val_class
!= valy1
->val_class
)
24057 if (valx1
->val_class
== dw_val_class_unsigned_const
)
24058 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
24059 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
24060 case DW_OP_GNU_parameter_ref
:
24061 return valx1
->val_class
== dw_val_class_die_ref
24062 && valx1
->val_class
== valy1
->val_class
24063 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
24065 /* Other codes have no operands. */
24070 /* Return true if DWARF location expressions X and Y are the same. */
24073 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
24075 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
24076 if (x
->dw_loc_opc
!= y
->dw_loc_opc
24077 || x
->dtprel
!= y
->dtprel
24078 || !compare_loc_operands (x
, y
))
24080 return x
== NULL
&& y
== NULL
;
24083 /* Hashtable helpers. */
24085 struct loc_list_hasher
: typed_noop_remove
<dw_loc_list_struct
>
24087 typedef dw_loc_list_struct value_type
;
24088 typedef dw_loc_list_struct compare_type
;
24089 static inline hashval_t
hash (const value_type
*);
24090 static inline bool equal (const value_type
*, const compare_type
*);
24093 /* Return precomputed hash of location list X. */
24096 loc_list_hasher::hash (const value_type
*x
)
24101 /* Return true if location lists A and B are the same. */
24104 loc_list_hasher::equal (const value_type
*a
, const compare_type
*b
)
24108 if (a
->hash
!= b
->hash
)
24110 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
24111 if (strcmp (a
->begin
, b
->begin
) != 0
24112 || strcmp (a
->end
, b
->end
) != 0
24113 || (a
->section
== NULL
) != (b
->section
== NULL
)
24114 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
24115 || !compare_locs (a
->expr
, b
->expr
))
24117 return a
== NULL
&& b
== NULL
;
24120 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
24123 /* Recursively optimize location lists referenced from DIE
24124 children and share them whenever possible. */
24127 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
24132 dw_loc_list_struct
**slot
;
24134 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
24135 if (AT_class (a
) == dw_val_class_loc_list
)
24137 dw_loc_list_ref list
= AT_loc_list (a
);
24138 /* TODO: perform some optimizations here, before hashing
24139 it and storing into the hash table. */
24140 hash_loc_list (list
);
24141 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
24145 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
24148 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
24152 /* Recursively assign each location list a unique index into the debug_addr
24156 index_location_lists (dw_die_ref die
)
24162 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
24163 if (AT_class (a
) == dw_val_class_loc_list
)
24165 dw_loc_list_ref list
= AT_loc_list (a
);
24166 dw_loc_list_ref curr
;
24167 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
24169 /* Don't index an entry that has already been indexed
24170 or won't be output. */
24171 if (curr
->begin_entry
!= NULL
24172 || (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
))
24176 = add_addr_table_entry (xstrdup (curr
->begin
),
24181 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
24184 /* Optimize location lists referenced from DIE
24185 children and share them whenever possible. */
24188 optimize_location_lists (dw_die_ref die
)
24190 loc_list_hash_type
htab (500);
24191 optimize_location_lists_1 (die
, &htab
);
24194 /* Output stuff that dwarf requires at the end of every file,
24195 and generate the DWARF-2 debugging info. */
24198 dwarf2out_finish (const char *filename
)
24200 limbo_die_node
*node
, *next_node
;
24201 comdat_type_node
*ctnode
;
24203 dw_die_ref main_comp_unit_die
;
24205 /* PCH might result in DW_AT_producer string being restored from the
24206 header compilation, so always fill it with empty string initially
24207 and overwrite only here. */
24208 dw_attr_ref producer
= get_AT (comp_unit_die (), DW_AT_producer
);
24209 producer_string
= gen_producer_string ();
24210 producer
->dw_attr_val
.v
.val_str
->refcount
--;
24211 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
24213 gen_scheduled_generic_parms_dies ();
24214 gen_remaining_tmpl_value_param_die_attribute ();
24216 /* Add the name for the main input file now. We delayed this from
24217 dwarf2out_init to avoid complications with PCH. */
24218 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
24219 if (!IS_ABSOLUTE_PATH (filename
) || targetm
.force_at_comp_dir
)
24220 add_comp_dir_attribute (comp_unit_die ());
24221 else if (get_AT (comp_unit_die (), DW_AT_comp_dir
) == NULL
)
24224 htab_traverse (file_table
, file_table_relative_p
, &p
);
24226 add_comp_dir_attribute (comp_unit_die ());
24229 if (deferred_locations_list
)
24230 for (i
= 0; i
< deferred_locations_list
->length (); i
++)
24232 add_location_or_const_value_attribute (
24233 (*deferred_locations_list
)[i
].die
,
24234 (*deferred_locations_list
)[i
].variable
,
24239 /* Traverse the limbo die list, and add parent/child links. The only
24240 dies without parents that should be here are concrete instances of
24241 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
24242 For concrete instances, we can get the parent die from the abstract
24244 for (node
= limbo_die_list
; node
; node
= next_node
)
24246 dw_die_ref die
= node
->die
;
24247 next_node
= node
->next
;
24249 if (die
->die_parent
== NULL
)
24251 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
24253 if (origin
&& origin
->die_parent
)
24254 add_child_die (origin
->die_parent
, die
);
24255 else if (is_cu_die (die
))
24257 else if (seen_error ())
24258 /* It's OK to be confused by errors in the input. */
24259 add_child_die (comp_unit_die (), die
);
24262 /* In certain situations, the lexical block containing a
24263 nested function can be optimized away, which results
24264 in the nested function die being orphaned. Likewise
24265 with the return type of that nested function. Force
24266 this to be a child of the containing function.
24268 It may happen that even the containing function got fully
24269 inlined and optimized out. In that case we are lost and
24270 assign the empty child. This should not be big issue as
24271 the function is likely unreachable too. */
24272 gcc_assert (node
->created_for
);
24274 if (DECL_P (node
->created_for
))
24275 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
24276 else if (TYPE_P (node
->created_for
))
24277 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
24279 origin
= comp_unit_die ();
24281 add_child_die (origin
, die
);
24286 limbo_die_list
= NULL
;
24288 #if ENABLE_ASSERT_CHECKING
24290 dw_die_ref die
= comp_unit_die (), c
;
24291 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
24294 resolve_addr (comp_unit_die ());
24295 move_marked_base_types ();
24297 for (node
= deferred_asm_name
; node
; node
= node
->next
)
24299 tree decl
= node
->created_for
;
24300 /* When generating LTO bytecode we can not generate new assembler
24301 names at this point and all important decls got theirs via
24303 if ((!flag_generate_lto
|| DECL_ASSEMBLER_NAME_SET_P (decl
))
24304 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
24306 add_linkage_attr (node
->die
, decl
);
24307 move_linkage_attr (node
->die
);
24311 deferred_asm_name
= NULL
;
24313 /* Walk through the list of incomplete types again, trying once more to
24314 emit full debugging info for them. */
24315 retry_incomplete_types ();
24317 if (flag_eliminate_unused_debug_types
)
24318 prune_unused_types ();
24320 /* Generate separate COMDAT sections for type DIEs. */
24321 if (use_debug_types
)
24323 break_out_comdat_types (comp_unit_die ());
24325 /* Each new type_unit DIE was added to the limbo die list when created.
24326 Since these have all been added to comdat_type_list, clear the
24328 limbo_die_list
= NULL
;
24330 /* For each new comdat type unit, copy declarations for incomplete
24331 types to make the new unit self-contained (i.e., no direct
24332 references to the main compile unit). */
24333 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24334 copy_decls_for_unworthy_types (ctnode
->root_die
);
24335 copy_decls_for_unworthy_types (comp_unit_die ());
24337 /* In the process of copying declarations from one unit to another,
24338 we may have left some declarations behind that are no longer
24339 referenced. Prune them. */
24340 prune_unused_types ();
24343 /* Generate separate CUs for each of the include files we've seen.
24344 They will go into limbo_die_list. */
24345 if (flag_eliminate_dwarf2_dups
)
24346 break_out_includes (comp_unit_die ());
24348 /* Traverse the DIE's and add add sibling attributes to those DIE's
24349 that have children. */
24350 add_sibling_attributes (comp_unit_die ());
24351 for (node
= limbo_die_list
; node
; node
= node
->next
)
24352 add_sibling_attributes (node
->die
);
24353 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24354 add_sibling_attributes (ctnode
->root_die
);
24356 /* When splitting DWARF info, we put some attributes in the
24357 skeleton compile_unit DIE that remains in the .o, while
24358 most attributes go in the DWO compile_unit_die. */
24359 if (dwarf_split_debug_info
)
24360 main_comp_unit_die
= gen_compile_unit_die (NULL
);
24362 main_comp_unit_die
= comp_unit_die ();
24364 /* Output a terminator label for the .text section. */
24365 switch_to_section (text_section
);
24366 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
24367 if (cold_text_section
)
24369 switch_to_section (cold_text_section
);
24370 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
24373 /* We can only use the low/high_pc attributes if all of the code was
24375 if (!have_multiple_function_sections
24376 || (dwarf_version
< 3 && dwarf_strict
))
24378 /* Don't add if the CU has no associated code. */
24379 if (text_section_used
)
24380 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
24381 text_end_label
, true);
24387 bool range_list_added
= false;
24389 if (text_section_used
)
24390 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
24391 text_end_label
, &range_list_added
, true);
24392 if (cold_text_section_used
)
24393 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
24394 cold_end_label
, &range_list_added
, true);
24396 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
24398 if (DECL_IGNORED_P (fde
->decl
))
24400 if (!fde
->in_std_section
)
24401 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
24402 fde
->dw_fde_end
, &range_list_added
,
24404 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
24405 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
24406 fde
->dw_fde_second_end
, &range_list_added
,
24410 if (range_list_added
)
24412 /* We need to give .debug_loc and .debug_ranges an appropriate
24413 "base address". Use zero so that these addresses become
24414 absolute. Historically, we've emitted the unexpected
24415 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24416 Emit both to give time for other tools to adapt. */
24417 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
24418 if (! dwarf_strict
&& dwarf_version
< 4)
24419 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
24425 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24426 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
24427 debug_line_section_label
);
24430 add_AT_macptr (comp_unit_die (),
24431 dwarf_strict
? DW_AT_macro_info
: DW_AT_GNU_macros
,
24432 macinfo_section_label
);
24434 if (dwarf_split_debug_info
)
24436 /* optimize_location_lists calculates the size of the lists,
24437 so index them first, and assign indices to the entries.
24438 Although optimize_location_lists will remove entries from
24439 the table, it only does so for duplicates, and therefore
24440 only reduces ref_counts to 1. */
24441 index_location_lists (comp_unit_die ());
24443 if (addr_index_table
!= NULL
)
24445 unsigned int index
= 0;
24446 htab_traverse_noresize (addr_index_table
,
24447 index_addr_table_entry
, &index
);
24451 if (have_location_lists
)
24452 optimize_location_lists (comp_unit_die ());
24454 save_macinfo_strings ();
24456 if (dwarf_split_debug_info
)
24458 unsigned int index
= 0;
24460 /* Add attributes common to skeleton compile_units and
24461 type_units. Because these attributes include strings, it
24462 must be done before freezing the string table. Top-level
24463 skeleton die attrs are added when the skeleton type unit is
24464 created, so ensure it is created by this point. */
24465 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
24466 htab_traverse_noresize (debug_str_hash
, index_string
, &index
);
24469 /* Output all of the compilation units. We put the main one last so that
24470 the offsets are available to output_pubnames. */
24471 for (node
= limbo_die_list
; node
; node
= node
->next
)
24472 output_comp_unit (node
->die
, 0);
24474 hash_table
<comdat_type_hasher
> comdat_type_table (100);
24475 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24477 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
24479 /* Don't output duplicate types. */
24480 if (*slot
!= HTAB_EMPTY_ENTRY
)
24483 /* Add a pointer to the line table for the main compilation unit
24484 so that the debugger can make sense of DW_AT_decl_file
24486 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24487 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
24488 (!dwarf_split_debug_info
24489 ? debug_line_section_label
24490 : debug_skeleton_line_section_label
));
24492 output_comdat_type_unit (ctnode
);
24496 /* The AT_pubnames attribute needs to go in all skeleton dies, including
24497 both the main_cu and all skeleton TUs. Making this call unconditional
24498 would end up either adding a second copy of the AT_pubnames attribute, or
24499 requiring a special case in add_top_level_skeleton_die_attrs. */
24500 if (!dwarf_split_debug_info
)
24501 add_AT_pubnames (comp_unit_die ());
24503 if (dwarf_split_debug_info
)
24506 unsigned char checksum
[16];
24507 struct md5_ctx ctx
;
24509 /* Compute a checksum of the comp_unit to use as the dwo_id. */
24510 md5_init_ctx (&ctx
);
24512 die_checksum (comp_unit_die (), &ctx
, &mark
);
24513 unmark_all_dies (comp_unit_die ());
24514 md5_finish_ctx (&ctx
, checksum
);
24516 /* Use the first 8 bytes of the checksum as the dwo_id,
24517 and add it to both comp-unit DIEs. */
24518 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
24519 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
24521 /* Add the base offset of the ranges table to the skeleton
24523 if (ranges_table_in_use
)
24524 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
24525 ranges_section_label
);
24527 switch_to_section (debug_addr_section
);
24528 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
24529 output_addr_table ();
24532 /* Output the main compilation unit if non-empty or if .debug_macinfo
24533 or .debug_macro will be emitted. */
24534 output_comp_unit (comp_unit_die (), have_macinfo
);
24536 if (dwarf_split_debug_info
&& info_section_emitted
)
24537 output_skeleton_debug_sections (main_comp_unit_die
);
24539 /* Output the abbreviation table. */
24540 if (abbrev_die_table_in_use
!= 1)
24542 switch_to_section (debug_abbrev_section
);
24543 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
24544 output_abbrev_section ();
24547 /* Output location list section if necessary. */
24548 if (have_location_lists
)
24550 /* Output the location lists info. */
24551 switch_to_section (debug_loc_section
);
24552 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
24553 output_location_lists (comp_unit_die ());
24556 output_pubtables ();
24558 /* Output the address range information if a CU (.debug_info section)
24559 was emitted. We output an empty table even if we had no functions
24560 to put in it. This because the consumer has no way to tell the
24561 difference between an empty table that we omitted and failure to
24562 generate a table that would have contained data. */
24563 if (info_section_emitted
)
24565 unsigned long aranges_length
= size_of_aranges ();
24567 switch_to_section (debug_aranges_section
);
24568 output_aranges (aranges_length
);
24571 /* Output ranges section if necessary. */
24572 if (ranges_table_in_use
)
24574 switch_to_section (debug_ranges_section
);
24575 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
24579 /* Have to end the macro section. */
24582 switch_to_section (debug_macinfo_section
);
24583 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
24585 dw2_asm_output_data (1, 0, "End compilation unit");
24588 /* Output the source line correspondence table. We must do this
24589 even if there is no line information. Otherwise, on an empty
24590 translation unit, we will generate a present, but empty,
24591 .debug_info section. IRIX 6.5 `nm' will then complain when
24592 examining the file. This is done late so that any filenames
24593 used by the debug_info section are marked as 'used'. */
24594 switch_to_section (debug_line_section
);
24595 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
24596 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
24597 output_line_info (false);
24599 if (dwarf_split_debug_info
&& info_section_emitted
)
24601 switch_to_section (debug_skeleton_line_section
);
24602 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
24603 output_line_info (true);
24606 /* If we emitted any indirect strings, output the string table too. */
24607 if (debug_str_hash
|| skeleton_debug_str_hash
)
24608 output_indirect_strings ();
24611 #include "gt-dwarf2out.h"