1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2014 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* TODO: Emit .debug_line header even when there are no functions, since
24 the file numbers are used by .debug_info. Alternately, leave
25 out locations for types and decls.
26 Avoid talking about ctors and op= for PODs.
27 Factor out common prologue sequences into multiple CIEs. */
29 /* The first part of this file deals with the DWARF 2 frame unwind
30 information, which is also used by the GCC efficient exception handling
31 mechanism. The second part, controlled only by an #ifdef
32 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
35 /* DWARF2 Abbreviation Glossary:
37 CFA = Canonical Frame Address
38 a fixed address on the stack which identifies a call frame.
39 We define it to be the value of SP just before the call insn.
40 The CFA register and offset, which may change during the course
41 of the function, are used to calculate its value at runtime.
43 CFI = Call Frame Instruction
44 an instruction for the DWARF2 abstract machine
46 CIE = Common Information Entry
47 information describing information common to one or more FDEs
49 DIE = Debugging Information Entry
51 FDE = Frame Description Entry
52 information describing the stack call frame, in particular,
53 how to restore registers
55 DW_CFA_... = DWARF2 CFA call frame instruction
56 DW_TAG_... = DWARF2 DIE tag */
60 #include "coretypes.h"
64 #include "stringpool.h"
65 #include "stor-layout.h"
69 #include "hash-table.h"
72 #include "hard-reg-set.h"
74 #include "insn-config.h"
81 #include "dwarf2out.h"
82 #include "dwarf2asm.h"
86 #include "diagnostic.h"
87 #include "tree-pretty-print.h"
90 #include "common/common-target.h"
91 #include "langhooks.h"
99 #include "gdb/gdb-index.h"
101 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
102 static rtx last_var_location_insn
;
103 static rtx cached_next_real_insn
;
105 #ifdef VMS_DEBUGGING_INFO
106 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
108 /* Define this macro to be a nonzero value if the directory specifications
109 which are output in the debug info should end with a separator. */
110 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
111 /* Define this macro to evaluate to a nonzero value if GCC should refrain
112 from generating indirect strings in DWARF2 debug information, for instance
113 if your target is stuck with an old version of GDB that is unable to
114 process them properly or uses VMS Debug. */
115 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
117 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
118 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
121 /* ??? Poison these here until it can be done generically. They've been
122 totally replaced in this file; make sure it stays that way. */
123 #undef DWARF2_UNWIND_INFO
124 #undef DWARF2_FRAME_INFO
125 #if (GCC_VERSION >= 3000)
126 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
129 /* The size of the target's pointer type. */
131 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
134 /* Array of RTXes referenced by the debugging information, which therefore
135 must be kept around forever. */
136 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
138 /* A pointer to the base of a list of incomplete types which might be
139 completed at some later time. incomplete_types_list needs to be a
140 vec<tree, va_gc> *because we want to tell the garbage collector about
142 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
144 /* A pointer to the base of a table of references to declaration
145 scopes. This table is a display which tracks the nesting
146 of declaration scopes at the current scope and containing
147 scopes. This table is used to find the proper place to
148 define type declaration DIE's. */
149 static GTY(()) vec
<tree
, va_gc
> *decl_scope_table
;
151 /* Pointers to various DWARF2 sections. */
152 static GTY(()) section
*debug_info_section
;
153 static GTY(()) section
*debug_skeleton_info_section
;
154 static GTY(()) section
*debug_abbrev_section
;
155 static GTY(()) section
*debug_skeleton_abbrev_section
;
156 static GTY(()) section
*debug_aranges_section
;
157 static GTY(()) section
*debug_addr_section
;
158 static GTY(()) section
*debug_macinfo_section
;
159 static GTY(()) section
*debug_line_section
;
160 static GTY(()) section
*debug_skeleton_line_section
;
161 static GTY(()) section
*debug_loc_section
;
162 static GTY(()) section
*debug_pubnames_section
;
163 static GTY(()) section
*debug_pubtypes_section
;
164 static GTY(()) section
*debug_str_section
;
165 static GTY(()) section
*debug_str_dwo_section
;
166 static GTY(()) section
*debug_str_offsets_section
;
167 static GTY(()) section
*debug_ranges_section
;
168 static GTY(()) section
*debug_frame_section
;
170 /* Maximum size (in bytes) of an artificially generated label. */
171 #define MAX_ARTIFICIAL_LABEL_BYTES 30
173 /* According to the (draft) DWARF 3 specification, the initial length
174 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
175 bytes are 0xffffffff, followed by the length stored in the next 8
178 However, the SGI/MIPS ABI uses an initial length which is equal to
179 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
181 #ifndef DWARF_INITIAL_LENGTH_SIZE
182 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
185 /* Round SIZE up to the nearest BOUNDARY. */
186 #define DWARF_ROUND(SIZE,BOUNDARY) \
187 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
189 /* CIE identifier. */
190 #if HOST_BITS_PER_WIDE_INT >= 64
191 #define DWARF_CIE_ID \
192 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
194 #define DWARF_CIE_ID DW_CIE_ID
198 /* A vector for a table that contains frame description
199 information for each routine. */
200 #define NOT_INDEXED (-1U)
201 #define NO_INDEX_ASSIGNED (-2U)
203 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
205 struct GTY(()) indirect_string_node
{
207 unsigned int refcount
;
208 enum dwarf_form form
;
213 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
215 /* With split_debug_info, both the comp_dir and dwo_name go in the
216 main object file, rather than the dwo, similar to the force_direct
217 parameter elsewhere but with additional complications:
219 1) The string is needed in both the main object file and the dwo.
220 That is, the comp_dir and dwo_name will appear in both places.
222 2) Strings can use three forms: DW_FORM_string, DW_FORM_strp or
223 DW_FORM_GNU_str_index.
225 3) GCC chooses the form to use late, depending on the size and
228 Rather than forcing the all debug string handling functions and
229 callers to deal with these complications, simply use a separate,
230 special-cased string table for any attribute that should go in the
231 main object file. This limits the complexity to just the places
234 static GTY ((param_is (struct indirect_string_node
)))
235 htab_t skeleton_debug_str_hash
;
237 static GTY(()) int dw2_string_counter
;
239 /* True if the compilation unit places functions in more than one section. */
240 static GTY(()) bool have_multiple_function_sections
= false;
242 /* Whether the default text and cold text sections have been used at all. */
244 static GTY(()) bool text_section_used
= false;
245 static GTY(()) bool cold_text_section_used
= false;
247 /* The default cold text section. */
248 static GTY(()) section
*cold_text_section
;
250 /* The DIE for C++1y 'auto' in a function return type. */
251 static GTY(()) dw_die_ref auto_die
;
253 /* The DIE for C++1y 'decltype(auto)' in a function return type. */
254 static GTY(()) dw_die_ref decltype_auto_die
;
256 /* Forward declarations for functions defined in this file. */
258 static char *stripattributes (const char *);
259 static void output_call_frame_info (int);
260 static void dwarf2out_note_section_used (void);
262 /* Personality decl of current unit. Used only when assembler does not support
264 static GTY(()) rtx current_unit_personality
;
266 /* Data and reference forms for relocatable data. */
267 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
268 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
270 #ifndef DEBUG_FRAME_SECTION
271 #define DEBUG_FRAME_SECTION ".debug_frame"
274 #ifndef FUNC_BEGIN_LABEL
275 #define FUNC_BEGIN_LABEL "LFB"
278 #ifndef FUNC_END_LABEL
279 #define FUNC_END_LABEL "LFE"
282 #ifndef PROLOGUE_END_LABEL
283 #define PROLOGUE_END_LABEL "LPE"
286 #ifndef EPILOGUE_BEGIN_LABEL
287 #define EPILOGUE_BEGIN_LABEL "LEB"
290 #ifndef FRAME_BEGIN_LABEL
291 #define FRAME_BEGIN_LABEL "Lframe"
293 #define CIE_AFTER_SIZE_LABEL "LSCIE"
294 #define CIE_END_LABEL "LECIE"
295 #define FDE_LABEL "LSFDE"
296 #define FDE_AFTER_SIZE_LABEL "LASFDE"
297 #define FDE_END_LABEL "LEFDE"
298 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
299 #define LINE_NUMBER_END_LABEL "LELT"
300 #define LN_PROLOG_AS_LABEL "LASLTP"
301 #define LN_PROLOG_END_LABEL "LELTP"
302 #define DIE_LABEL_PREFIX "DW"
304 /* Match the base name of a file to the base name of a compilation unit. */
307 matches_main_base (const char *path
)
309 /* Cache the last query. */
310 static const char *last_path
= NULL
;
311 static int last_match
= 0;
312 if (path
!= last_path
)
315 int length
= base_of_path (path
, &base
);
317 last_match
= (length
== main_input_baselength
318 && memcmp (base
, main_input_basename
, length
) == 0);
323 #ifdef DEBUG_DEBUG_STRUCT
326 dump_struct_debug (tree type
, enum debug_info_usage usage
,
327 enum debug_struct_file criterion
, int generic
,
328 int matches
, int result
)
330 /* Find the type name. */
331 tree type_decl
= TYPE_STUB_DECL (type
);
333 const char *name
= 0;
334 if (TREE_CODE (t
) == TYPE_DECL
)
337 name
= IDENTIFIER_POINTER (t
);
339 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
341 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
342 matches
? "bas" : "hdr",
343 generic
? "gen" : "ord",
344 usage
== DINFO_USAGE_DFN
? ";" :
345 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
347 (void*) type_decl
, name
);
350 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
351 dump_struct_debug (type, usage, criterion, generic, matches, result)
355 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
361 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
363 enum debug_struct_file criterion
;
365 bool generic
= lang_hooks
.types
.generic_p (type
);
368 criterion
= debug_struct_generic
[usage
];
370 criterion
= debug_struct_ordinary
[usage
];
372 if (criterion
== DINFO_STRUCT_FILE_NONE
)
373 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
374 if (criterion
== DINFO_STRUCT_FILE_ANY
)
375 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
377 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
379 if (type_decl
!= NULL
)
381 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
382 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
384 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
385 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
388 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
391 /* Return a pointer to a copy of the section string name S with all
392 attributes stripped off, and an asterisk prepended (for assemble_name). */
395 stripattributes (const char *s
)
397 char *stripped
= XNEWVEC (char, strlen (s
) + 2);
402 while (*s
&& *s
!= ',')
409 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
410 switch to the data section instead, and write out a synthetic start label
411 for collect2 the first time around. */
414 switch_to_eh_frame_section (bool back
)
418 #ifdef EH_FRAME_SECTION_NAME
419 if (eh_frame_section
== 0)
423 if (EH_TABLES_CAN_BE_READ_ONLY
)
429 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
431 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
433 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
436 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
437 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
438 && (per_encoding
& 0x70) != DW_EH_PE_absptr
439 && (per_encoding
& 0x70) != DW_EH_PE_aligned
440 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
441 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
442 ? 0 : SECTION_WRITE
);
445 flags
= SECTION_WRITE
;
446 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
448 #endif /* EH_FRAME_SECTION_NAME */
450 if (eh_frame_section
)
451 switch_to_section (eh_frame_section
);
454 /* We have no special eh_frame section. Put the information in
455 the data section and emit special labels to guide collect2. */
456 switch_to_section (data_section
);
460 label
= get_file_function_name ("F");
461 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
462 targetm
.asm_out
.globalize_label (asm_out_file
,
463 IDENTIFIER_POINTER (label
));
464 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
469 /* Switch [BACK] to the eh or debug frame table section, depending on
473 switch_to_frame_table_section (int for_eh
, bool back
)
476 switch_to_eh_frame_section (back
);
479 if (!debug_frame_section
)
480 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
481 SECTION_DEBUG
, NULL
);
482 switch_to_section (debug_frame_section
);
486 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
488 enum dw_cfi_oprnd_type
489 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
494 case DW_CFA_GNU_window_save
:
495 case DW_CFA_remember_state
:
496 case DW_CFA_restore_state
:
497 return dw_cfi_oprnd_unused
;
500 case DW_CFA_advance_loc1
:
501 case DW_CFA_advance_loc2
:
502 case DW_CFA_advance_loc4
:
503 case DW_CFA_MIPS_advance_loc8
:
504 return dw_cfi_oprnd_addr
;
507 case DW_CFA_offset_extended
:
509 case DW_CFA_offset_extended_sf
:
510 case DW_CFA_def_cfa_sf
:
512 case DW_CFA_restore_extended
:
513 case DW_CFA_undefined
:
514 case DW_CFA_same_value
:
515 case DW_CFA_def_cfa_register
:
516 case DW_CFA_register
:
517 case DW_CFA_expression
:
518 return dw_cfi_oprnd_reg_num
;
520 case DW_CFA_def_cfa_offset
:
521 case DW_CFA_GNU_args_size
:
522 case DW_CFA_def_cfa_offset_sf
:
523 return dw_cfi_oprnd_offset
;
525 case DW_CFA_def_cfa_expression
:
526 return dw_cfi_oprnd_loc
;
533 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
535 enum dw_cfi_oprnd_type
536 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
541 case DW_CFA_def_cfa_sf
:
543 case DW_CFA_offset_extended_sf
:
544 case DW_CFA_offset_extended
:
545 return dw_cfi_oprnd_offset
;
547 case DW_CFA_register
:
548 return dw_cfi_oprnd_reg_num
;
550 case DW_CFA_expression
:
551 return dw_cfi_oprnd_loc
;
554 return dw_cfi_oprnd_unused
;
558 /* Output one FDE. */
561 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
562 char *section_start_label
, int fde_encoding
, char *augmentation
,
563 bool any_lsda_needed
, int lsda_encoding
)
565 const char *begin
, *end
;
566 static unsigned int j
;
569 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
571 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
573 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
574 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
575 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
576 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
577 " indicating 64-bit DWARF extension");
578 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
580 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
583 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
585 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
586 debug_frame_section
, "FDE CIE offset");
588 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
589 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
593 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
594 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
595 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
596 "FDE initial location");
597 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
598 end
, begin
, "FDE address range");
602 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
603 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
610 int size
= size_of_encoded_value (lsda_encoding
);
612 if (lsda_encoding
== DW_EH_PE_aligned
)
614 int offset
= ( 4 /* Length */
616 + 2 * size_of_encoded_value (fde_encoding
)
617 + 1 /* Augmentation size */ );
618 int pad
= -offset
& (PTR_SIZE
- 1);
621 gcc_assert (size_of_uleb128 (size
) == 1);
624 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
626 if (fde
->uses_eh_lsda
)
628 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
629 fde
->funcdef_number
);
630 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
631 gen_rtx_SYMBOL_REF (Pmode
, l1
),
633 "Language Specific Data Area");
637 if (lsda_encoding
== DW_EH_PE_aligned
)
638 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
639 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
640 "Language Specific Data Area (none)");
644 dw2_asm_output_data_uleb128 (0, "Augmentation size");
647 /* Loop through the Call Frame Instructions associated with this FDE. */
648 fde
->dw_fde_current_label
= begin
;
650 size_t from
, until
, i
;
653 until
= vec_safe_length (fde
->dw_fde_cfi
);
655 if (fde
->dw_fde_second_begin
== NULL
)
658 until
= fde
->dw_fde_switch_cfi_index
;
660 from
= fde
->dw_fde_switch_cfi_index
;
662 for (i
= from
; i
< until
; i
++)
663 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
666 /* If we are to emit a ref/link from function bodies to their frame tables,
667 do it now. This is typically performed to make sure that tables
668 associated with functions are dragged with them and not discarded in
669 garbage collecting links. We need to do this on a per function basis to
670 cope with -ffunction-sections. */
672 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
673 /* Switch to the function section, emit the ref to the tables, and
674 switch *back* into the table section. */
675 switch_to_section (function_section (fde
->decl
));
676 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
677 switch_to_frame_table_section (for_eh
, true);
680 /* Pad the FDE out to an address sized boundary. */
681 ASM_OUTPUT_ALIGN (asm_out_file
,
682 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
683 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
688 /* Return true if frame description entry FDE is needed for EH. */
691 fde_needed_for_eh_p (dw_fde_ref fde
)
693 if (flag_asynchronous_unwind_tables
)
696 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
699 if (fde
->uses_eh_lsda
)
702 /* If exceptions are enabled, we have collected nothrow info. */
703 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
709 /* Output the call frame information used to record information
710 that relates to calculating the frame pointer, and records the
711 location of saved registers. */
714 output_call_frame_info (int for_eh
)
719 char l1
[20], l2
[20], section_start_label
[20];
720 bool any_lsda_needed
= false;
721 char augmentation
[6];
722 int augmentation_size
;
723 int fde_encoding
= DW_EH_PE_absptr
;
724 int per_encoding
= DW_EH_PE_absptr
;
725 int lsda_encoding
= DW_EH_PE_absptr
;
727 rtx personality
= NULL
;
730 /* Don't emit a CIE if there won't be any FDEs. */
734 /* Nothing to do if the assembler's doing it all. */
735 if (dwarf2out_do_cfi_asm ())
738 /* If we don't have any functions we'll want to unwind out of, don't emit
739 any EH unwind information. If we make FDEs linkonce, we may have to
740 emit an empty label for an FDE that wouldn't otherwise be emitted. We
741 want to avoid having an FDE kept around when the function it refers to
742 is discarded. Example where this matters: a primary function template
743 in C++ requires EH information, an explicit specialization doesn't. */
746 bool any_eh_needed
= false;
748 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
750 if (fde
->uses_eh_lsda
)
751 any_eh_needed
= any_lsda_needed
= true;
752 else if (fde_needed_for_eh_p (fde
))
753 any_eh_needed
= true;
754 else if (TARGET_USES_WEAK_UNWIND_INFO
)
755 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
762 /* We're going to be generating comments, so turn on app. */
766 /* Switch to the proper frame section, first time. */
767 switch_to_frame_table_section (for_eh
, false);
769 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
770 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
772 /* Output the CIE. */
773 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
774 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
775 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
776 dw2_asm_output_data (4, 0xffffffff,
777 "Initial length escape value indicating 64-bit DWARF extension");
778 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
779 "Length of Common Information Entry");
780 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
782 /* Now that the CIE pointer is PC-relative for EH,
783 use 0 to identify the CIE. */
784 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
785 (for_eh
? 0 : DWARF_CIE_ID
),
786 "CIE Identifier Tag");
788 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
789 use CIE version 1, unless that would produce incorrect results
790 due to overflowing the return register column. */
791 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
793 if (return_reg
>= 256 || dwarf_version
> 2)
795 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
798 augmentation_size
= 0;
800 personality
= current_unit_personality
;
806 z Indicates that a uleb128 is present to size the
807 augmentation section.
808 L Indicates the encoding (and thus presence) of
809 an LSDA pointer in the FDE augmentation.
810 R Indicates a non-default pointer encoding for
812 P Indicates the presence of an encoding + language
813 personality routine in the CIE augmentation. */
815 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
816 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
817 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
819 p
= augmentation
+ 1;
823 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
824 assemble_external_libcall (personality
);
829 augmentation_size
+= 1;
831 if (fde_encoding
!= DW_EH_PE_absptr
)
834 augmentation_size
+= 1;
836 if (p
> augmentation
+ 1)
838 augmentation
[0] = 'z';
842 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
843 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
845 int offset
= ( 4 /* Length */
847 + 1 /* CIE version */
848 + strlen (augmentation
) + 1 /* Augmentation */
849 + size_of_uleb128 (1) /* Code alignment */
850 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
852 + 1 /* Augmentation size */
853 + 1 /* Personality encoding */ );
854 int pad
= -offset
& (PTR_SIZE
- 1);
856 augmentation_size
+= pad
;
858 /* Augmentations should be small, so there's scarce need to
859 iterate for a solution. Die if we exceed one uleb128 byte. */
860 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
864 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
865 if (dw_cie_version
>= 4)
867 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
868 dw2_asm_output_data (1, 0, "CIE Segment Size");
870 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
871 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
872 "CIE Data Alignment Factor");
874 if (dw_cie_version
== 1)
875 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
877 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
881 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
884 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
885 eh_data_format_name (per_encoding
));
886 dw2_asm_output_encoded_addr_rtx (per_encoding
,
892 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
893 eh_data_format_name (lsda_encoding
));
895 if (fde_encoding
!= DW_EH_PE_absptr
)
896 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
897 eh_data_format_name (fde_encoding
));
900 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
901 output_cfi (cfi
, NULL
, for_eh
);
903 /* Pad the CIE out to an address sized boundary. */
904 ASM_OUTPUT_ALIGN (asm_out_file
,
905 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
906 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
908 /* Loop through all of the FDE's. */
909 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
913 /* Don't emit EH unwind info for leaf functions that don't need it. */
914 if (for_eh
&& !fde_needed_for_eh_p (fde
))
917 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
918 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
919 augmentation
, any_lsda_needed
, lsda_encoding
);
922 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
923 dw2_asm_output_data (4, 0, "End of Table");
925 /* Turn off app to make assembly quicker. */
930 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
933 dwarf2out_do_cfi_startproc (bool second
)
937 rtx personality
= get_personality_function (current_function_decl
);
939 fprintf (asm_out_file
, "\t.cfi_startproc\n");
943 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
946 /* ??? The GAS support isn't entirely consistent. We have to
947 handle indirect support ourselves, but PC-relative is done
948 in the assembler. Further, the assembler can't handle any
949 of the weirder relocation types. */
950 if (enc
& DW_EH_PE_indirect
)
951 ref
= dw2_force_const_mem (ref
, true);
953 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
954 output_addr_const (asm_out_file
, ref
);
955 fputc ('\n', asm_out_file
);
958 if (crtl
->uses_eh_lsda
)
962 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
963 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
964 current_function_funcdef_no
);
965 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
966 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
968 if (enc
& DW_EH_PE_indirect
)
969 ref
= dw2_force_const_mem (ref
, true);
971 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
972 output_addr_const (asm_out_file
, ref
);
973 fputc ('\n', asm_out_file
);
977 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
978 this allocation may be done before pass_final. */
981 dwarf2out_alloc_current_fde (void)
985 fde
= ggc_alloc_cleared_dw_fde_node ();
986 fde
->decl
= current_function_decl
;
987 fde
->funcdef_number
= current_function_funcdef_no
;
988 fde
->fde_index
= vec_safe_length (fde_vec
);
989 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
990 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
991 fde
->nothrow
= crtl
->nothrow
;
992 fde
->drap_reg
= INVALID_REGNUM
;
993 fde
->vdrap_reg
= INVALID_REGNUM
;
995 /* Record the FDE associated with this function. */
997 vec_safe_push (fde_vec
, fde
);
1002 /* Output a marker (i.e. a label) for the beginning of a function, before
1006 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1007 const char *file ATTRIBUTE_UNUSED
)
1009 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1015 current_function_func_begin_label
= NULL
;
1017 do_frame
= dwarf2out_do_frame ();
1019 /* ??? current_function_func_begin_label is also used by except.c for
1020 call-site information. We must emit this label if it might be used. */
1022 && (!flag_exceptions
1023 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1026 fnsec
= function_section (current_function_decl
);
1027 switch_to_section (fnsec
);
1028 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1029 current_function_funcdef_no
);
1030 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1031 current_function_funcdef_no
);
1032 dup_label
= xstrdup (label
);
1033 current_function_func_begin_label
= dup_label
;
1035 /* We can elide the fde allocation if we're not emitting debug info. */
1039 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1040 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1041 would include pass_dwarf2_frame. If we've not created the FDE yet,
1045 fde
= dwarf2out_alloc_current_fde ();
1047 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1048 fde
->dw_fde_begin
= dup_label
;
1049 fde
->dw_fde_current_label
= dup_label
;
1050 fde
->in_std_section
= (fnsec
== text_section
1051 || (cold_text_section
&& fnsec
== cold_text_section
));
1053 /* We only want to output line number information for the genuine dwarf2
1054 prologue case, not the eh frame case. */
1055 #ifdef DWARF2_DEBUGGING_INFO
1057 dwarf2out_source_line (line
, file
, 0, true);
1060 if (dwarf2out_do_cfi_asm ())
1061 dwarf2out_do_cfi_startproc (false);
1064 rtx personality
= get_personality_function (current_function_decl
);
1065 if (!current_unit_personality
)
1066 current_unit_personality
= personality
;
1068 /* We cannot keep a current personality per function as without CFI
1069 asm, at the point where we emit the CFI data, there is no current
1070 function anymore. */
1071 if (personality
&& current_unit_personality
!= personality
)
1072 sorry ("multiple EH personalities are supported only with assemblers "
1073 "supporting .cfi_personality directive");
1077 /* Output a marker (i.e. a label) for the end of the generated code
1078 for a function prologue. This gets called *after* the prologue code has
1082 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1083 const char *file ATTRIBUTE_UNUSED
)
1085 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1087 /* Output a label to mark the endpoint of the code generated for this
1089 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1090 current_function_funcdef_no
);
1091 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1092 current_function_funcdef_no
);
1093 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1096 /* Output a marker (i.e. a label) for the beginning of the generated code
1097 for a function epilogue. This gets called *before* the prologue code has
1101 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1102 const char *file ATTRIBUTE_UNUSED
)
1104 dw_fde_ref fde
= cfun
->fde
;
1105 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1107 if (fde
->dw_fde_vms_begin_epilogue
)
1110 /* Output a label to mark the endpoint of the code generated for this
1112 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1113 current_function_funcdef_no
);
1114 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1115 current_function_funcdef_no
);
1116 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1119 /* Output a marker (i.e. a label) for the absolute end of the generated code
1120 for a function definition. This gets called *after* the epilogue code has
1124 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1125 const char *file ATTRIBUTE_UNUSED
)
1128 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1130 last_var_location_insn
= NULL_RTX
;
1131 cached_next_real_insn
= NULL_RTX
;
1133 if (dwarf2out_do_cfi_asm ())
1134 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1136 /* Output a label to mark the endpoint of the code generated for this
1138 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1139 current_function_funcdef_no
);
1140 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1142 gcc_assert (fde
!= NULL
);
1143 if (fde
->dw_fde_second_begin
== NULL
)
1144 fde
->dw_fde_end
= xstrdup (label
);
1148 dwarf2out_frame_finish (void)
1150 /* Output call frame information. */
1151 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1152 output_call_frame_info (0);
1154 /* Output another copy for the unwinder. */
1155 if ((flag_unwind_tables
|| flag_exceptions
)
1156 && targetm_common
.except_unwind_info (&global_options
) == UI_DWARF2
)
1157 output_call_frame_info (1);
1160 /* Note that the current function section is being used for code. */
1163 dwarf2out_note_section_used (void)
1165 section
*sec
= current_function_section ();
1166 if (sec
== text_section
)
1167 text_section_used
= true;
1168 else if (sec
== cold_text_section
)
1169 cold_text_section_used
= true;
1172 static void var_location_switch_text_section (void);
1173 static void set_cur_line_info_table (section
*);
1176 dwarf2out_switch_text_section (void)
1179 dw_fde_ref fde
= cfun
->fde
;
1181 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1183 if (!in_cold_section_p
)
1185 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1186 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1187 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1191 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1192 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1193 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1195 have_multiple_function_sections
= true;
1197 /* There is no need to mark used sections when not debugging. */
1198 if (cold_text_section
!= NULL
)
1199 dwarf2out_note_section_used ();
1201 if (dwarf2out_do_cfi_asm ())
1202 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1204 /* Now do the real section switch. */
1205 sect
= current_function_section ();
1206 switch_to_section (sect
);
1208 fde
->second_in_std_section
1209 = (sect
== text_section
1210 || (cold_text_section
&& sect
== cold_text_section
));
1212 if (dwarf2out_do_cfi_asm ())
1213 dwarf2out_do_cfi_startproc (true);
1215 var_location_switch_text_section ();
1217 if (cold_text_section
!= NULL
)
1218 set_cur_line_info_table (sect
);
1221 /* And now, the subset of the debugging information support code necessary
1222 for emitting location expressions. */
1224 /* Data about a single source file. */
1225 struct GTY(()) dwarf_file_data
{
1226 const char * filename
;
1230 typedef struct GTY(()) deferred_locations_struct
1234 } deferred_locations
;
1237 static GTY(()) vec
<deferred_locations
, va_gc
> *deferred_locations_list
;
1240 /* Describe an entry into the .debug_addr section. */
1244 ate_kind_rtx_dtprel
,
1248 typedef struct GTY(()) addr_table_entry_struct
{
1250 unsigned int refcount
;
1252 union addr_table_entry_struct_union
1254 rtx
GTY ((tag ("0"))) rtl
;
1255 char * GTY ((tag ("1"))) label
;
1257 GTY ((desc ("%1.kind"))) addr
;
1261 /* Location lists are ranges + location descriptions for that range,
1262 so you can track variables that are in different places over
1263 their entire life. */
1264 typedef struct GTY(()) dw_loc_list_struct
{
1265 dw_loc_list_ref dw_loc_next
;
1266 const char *begin
; /* Label and addr_entry for start of range */
1267 addr_table_entry
*begin_entry
;
1268 const char *end
; /* Label for end of range */
1269 char *ll_symbol
; /* Label for beginning of location list.
1270 Only on head of list */
1271 const char *section
; /* Section this loclist is relative to */
1272 dw_loc_descr_ref expr
;
1274 /* True if all addresses in this and subsequent lists are known to be
1277 /* True if this list has been replaced by dw_loc_next. */
1280 /* True if the range should be emitted even if begin and end
1285 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
1287 /* Convert a DWARF stack opcode into its string name. */
1290 dwarf_stack_op_name (unsigned int op
)
1292 const char *name
= get_DW_OP_name (op
);
1297 return "OP_<unknown>";
1300 /* Return a pointer to a newly allocated location description. Location
1301 descriptions are simple expression terms that can be strung
1302 together to form more complicated location (address) descriptions. */
1304 static inline dw_loc_descr_ref
1305 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1306 unsigned HOST_WIDE_INT oprnd2
)
1308 dw_loc_descr_ref descr
= ggc_alloc_cleared_dw_loc_descr_node ();
1310 descr
->dw_loc_opc
= op
;
1311 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1312 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1313 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1314 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1315 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1316 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1321 /* Return a pointer to a newly allocated location description for
1324 static inline dw_loc_descr_ref
1325 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
1328 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1331 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
1334 /* Add a location description term to a location description expression. */
1337 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1339 dw_loc_descr_ref
*d
;
1341 /* Find the end of the chain. */
1342 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1348 /* Compare two location operands for exact equality. */
1351 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1353 if (a
->val_class
!= b
->val_class
)
1355 switch (a
->val_class
)
1357 case dw_val_class_none
:
1359 case dw_val_class_addr
:
1360 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1362 case dw_val_class_offset
:
1363 case dw_val_class_unsigned_const
:
1364 case dw_val_class_const
:
1365 case dw_val_class_range_list
:
1366 case dw_val_class_lineptr
:
1367 case dw_val_class_macptr
:
1368 /* These are all HOST_WIDE_INT, signed or unsigned. */
1369 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1371 case dw_val_class_loc
:
1372 return a
->v
.val_loc
== b
->v
.val_loc
;
1373 case dw_val_class_loc_list
:
1374 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1375 case dw_val_class_die_ref
:
1376 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1377 case dw_val_class_fde_ref
:
1378 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1379 case dw_val_class_lbl_id
:
1380 case dw_val_class_high_pc
:
1381 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1382 case dw_val_class_str
:
1383 return a
->v
.val_str
== b
->v
.val_str
;
1384 case dw_val_class_flag
:
1385 return a
->v
.val_flag
== b
->v
.val_flag
;
1386 case dw_val_class_file
:
1387 return a
->v
.val_file
== b
->v
.val_file
;
1388 case dw_val_class_decl_ref
:
1389 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1391 case dw_val_class_const_double
:
1392 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1393 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1395 case dw_val_class_vec
:
1397 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1398 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1400 return (a_len
== b_len
1401 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1404 case dw_val_class_data8
:
1405 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1407 case dw_val_class_vms_delta
:
1408 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1409 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1414 /* Compare two location atoms for exact equality. */
1417 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1419 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1422 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1423 address size, but since we always allocate cleared storage it
1424 should be zero for other types of locations. */
1425 if (a
->dtprel
!= b
->dtprel
)
1428 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1429 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1432 /* Compare two complete location expressions for exact equality. */
1435 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1441 if (a
== NULL
|| b
== NULL
)
1443 if (!loc_descr_equal_p_1 (a
, b
))
1452 /* Add a constant OFFSET to a location expression. */
1455 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
1457 dw_loc_descr_ref loc
;
1460 gcc_assert (*list_head
!= NULL
);
1465 /* Find the end of the chain. */
1466 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1470 if (loc
->dw_loc_opc
== DW_OP_fbreg
1471 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1472 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1473 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1474 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1476 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1477 offset. Don't optimize if an signed integer overflow would happen. */
1479 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1480 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1483 else if (offset
> 0)
1484 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1488 loc
->dw_loc_next
= int_loc_descriptor (-offset
);
1489 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1493 /* Add a constant OFFSET to a location list. */
1496 loc_list_plus_const (dw_loc_list_ref list_head
, HOST_WIDE_INT offset
)
1499 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1500 loc_descr_plus_const (&d
->expr
, offset
);
1503 #define DWARF_REF_SIZE \
1504 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1506 static unsigned long int get_base_type_offset (dw_die_ref
);
1508 /* Return the size of a location descriptor. */
1510 static unsigned long
1511 size_of_loc_descr (dw_loc_descr_ref loc
)
1513 unsigned long size
= 1;
1515 switch (loc
->dw_loc_opc
)
1518 size
+= DWARF2_ADDR_SIZE
;
1520 case DW_OP_GNU_addr_index
:
1521 case DW_OP_GNU_const_index
:
1522 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1523 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1542 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1545 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1550 case DW_OP_plus_uconst
:
1551 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1589 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1592 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1595 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1598 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1599 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1602 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1604 case DW_OP_bit_piece
:
1605 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1606 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1608 case DW_OP_deref_size
:
1609 case DW_OP_xderef_size
:
1618 case DW_OP_call_ref
:
1619 size
+= DWARF_REF_SIZE
;
1621 case DW_OP_implicit_value
:
1622 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1623 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1625 case DW_OP_GNU_implicit_pointer
:
1626 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1628 case DW_OP_GNU_entry_value
:
1630 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1631 size
+= size_of_uleb128 (op_size
) + op_size
;
1634 case DW_OP_GNU_const_type
:
1637 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1638 size
+= size_of_uleb128 (o
) + 1;
1639 switch (loc
->dw_loc_oprnd2
.val_class
)
1641 case dw_val_class_vec
:
1642 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1643 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1645 case dw_val_class_const
:
1646 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1648 case dw_val_class_const_double
:
1649 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1656 case DW_OP_GNU_regval_type
:
1659 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1660 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1661 + size_of_uleb128 (o
);
1664 case DW_OP_GNU_deref_type
:
1667 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1668 size
+= 1 + size_of_uleb128 (o
);
1671 case DW_OP_GNU_convert
:
1672 case DW_OP_GNU_reinterpret
:
1673 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1674 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1678 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1679 size
+= size_of_uleb128 (o
);
1682 case DW_OP_GNU_parameter_ref
:
1692 /* Return the size of a series of location descriptors. */
1695 size_of_locs (dw_loc_descr_ref loc
)
1700 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1701 field, to avoid writing to a PCH file. */
1702 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1704 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1706 size
+= size_of_loc_descr (l
);
1711 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1713 l
->dw_loc_addr
= size
;
1714 size
+= size_of_loc_descr (l
);
1720 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
1721 static void get_ref_die_offset_label (char *, dw_die_ref
);
1722 static unsigned long int get_ref_die_offset (dw_die_ref
);
1724 /* Output location description stack opcode's operands (if any).
1725 The for_eh_or_skip parameter controls whether register numbers are
1726 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1727 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1728 info). This should be suppressed for the cases that have not been converted
1729 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1732 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
1734 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
1735 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
1737 switch (loc
->dw_loc_opc
)
1739 #ifdef DWARF2_DEBUGGING_INFO
1742 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
1747 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1748 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
1750 fputc ('\n', asm_out_file
);
1755 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
1760 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1761 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
1763 fputc ('\n', asm_out_file
);
1768 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
1769 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
1776 gcc_assert (val1
->val_class
== dw_val_class_loc
);
1777 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
1779 dw2_asm_output_data (2, offset
, NULL
);
1782 case DW_OP_implicit_value
:
1783 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1784 switch (val2
->val_class
)
1786 case dw_val_class_const
:
1787 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
1789 case dw_val_class_vec
:
1791 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
1792 unsigned int len
= val2
->v
.val_vec
.length
;
1796 if (elt_size
> sizeof (HOST_WIDE_INT
))
1801 for (i
= 0, p
= val2
->v
.val_vec
.array
;
1804 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
1805 "fp or vector constant word %u", i
);
1808 case dw_val_class_const_double
:
1810 unsigned HOST_WIDE_INT first
, second
;
1812 if (WORDS_BIG_ENDIAN
)
1814 first
= val2
->v
.val_double
.high
;
1815 second
= val2
->v
.val_double
.low
;
1819 first
= val2
->v
.val_double
.low
;
1820 second
= val2
->v
.val_double
.high
;
1822 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1824 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1828 case dw_val_class_addr
:
1829 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
1830 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
1845 case DW_OP_implicit_value
:
1846 /* We currently don't make any attempt to make sure these are
1847 aligned properly like we do for the main unwind info, so
1848 don't support emitting things larger than a byte if we're
1849 only doing unwinding. */
1854 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1857 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1860 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1863 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1865 case DW_OP_plus_uconst
:
1866 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1900 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1904 unsigned r
= val1
->v
.val_unsigned
;
1905 if (for_eh_or_skip
>= 0)
1906 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1907 gcc_assert (size_of_uleb128 (r
)
1908 == size_of_uleb128 (val1
->v
.val_unsigned
));
1909 dw2_asm_output_data_uleb128 (r
, NULL
);
1913 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1917 unsigned r
= val1
->v
.val_unsigned
;
1918 if (for_eh_or_skip
>= 0)
1919 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1920 gcc_assert (size_of_uleb128 (r
)
1921 == size_of_uleb128 (val1
->v
.val_unsigned
));
1922 dw2_asm_output_data_uleb128 (r
, NULL
);
1923 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
1927 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1929 case DW_OP_bit_piece
:
1930 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1931 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
1933 case DW_OP_deref_size
:
1934 case DW_OP_xderef_size
:
1935 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1941 if (targetm
.asm_out
.output_dwarf_dtprel
)
1943 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
1946 fputc ('\n', asm_out_file
);
1953 #ifdef DWARF2_DEBUGGING_INFO
1954 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
1961 case DW_OP_GNU_addr_index
:
1962 case DW_OP_GNU_const_index
:
1963 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1964 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
1965 "(index into .debug_addr)");
1968 case DW_OP_GNU_implicit_pointer
:
1970 char label
[MAX_ARTIFICIAL_LABEL_BYTES
1971 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
1972 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
1973 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
1974 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
1975 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
1979 case DW_OP_GNU_entry_value
:
1980 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
1981 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
1984 case DW_OP_GNU_const_type
:
1986 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
1988 dw2_asm_output_data_uleb128 (o
, NULL
);
1989 switch (val2
->val_class
)
1991 case dw_val_class_const
:
1992 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
1993 dw2_asm_output_data (1, l
, NULL
);
1994 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
1996 case dw_val_class_vec
:
1998 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
1999 unsigned int len
= val2
->v
.val_vec
.length
;
2004 dw2_asm_output_data (1, l
, NULL
);
2005 if (elt_size
> sizeof (HOST_WIDE_INT
))
2010 for (i
= 0, p
= val2
->v
.val_vec
.array
;
2013 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2014 "fp or vector constant word %u", i
);
2017 case dw_val_class_const_double
:
2019 unsigned HOST_WIDE_INT first
, second
;
2020 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2022 dw2_asm_output_data (1, 2 * l
, NULL
);
2023 if (WORDS_BIG_ENDIAN
)
2025 first
= val2
->v
.val_double
.high
;
2026 second
= val2
->v
.val_double
.low
;
2030 first
= val2
->v
.val_double
.low
;
2031 second
= val2
->v
.val_double
.high
;
2033 dw2_asm_output_data (l
, first
, NULL
);
2034 dw2_asm_output_data (l
, second
, NULL
);
2042 case DW_OP_GNU_regval_type
:
2044 unsigned r
= val1
->v
.val_unsigned
;
2045 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2047 if (for_eh_or_skip
>= 0)
2049 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2050 gcc_assert (size_of_uleb128 (r
)
2051 == size_of_uleb128 (val1
->v
.val_unsigned
));
2053 dw2_asm_output_data_uleb128 (r
, NULL
);
2054 dw2_asm_output_data_uleb128 (o
, NULL
);
2057 case DW_OP_GNU_deref_type
:
2059 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2061 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2062 dw2_asm_output_data_uleb128 (o
, NULL
);
2065 case DW_OP_GNU_convert
:
2066 case DW_OP_GNU_reinterpret
:
2067 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2068 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2071 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2073 dw2_asm_output_data_uleb128 (o
, NULL
);
2077 case DW_OP_GNU_parameter_ref
:
2080 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2081 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2082 dw2_asm_output_data (4, o
, NULL
);
2087 /* Other codes have no operands. */
2092 /* Output a sequence of location operations.
2093 The for_eh_or_skip parameter controls whether register numbers are
2094 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2095 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2096 info). This should be suppressed for the cases that have not been converted
2097 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2100 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2102 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2104 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2105 /* Output the opcode. */
2106 if (for_eh_or_skip
>= 0
2107 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2109 unsigned r
= (opc
- DW_OP_breg0
);
2110 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2111 gcc_assert (r
<= 31);
2112 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2114 else if (for_eh_or_skip
>= 0
2115 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2117 unsigned r
= (opc
- DW_OP_reg0
);
2118 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2119 gcc_assert (r
<= 31);
2120 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2123 dw2_asm_output_data (1, opc
,
2124 "%s", dwarf_stack_op_name (opc
));
2126 /* Output the operand(s) (if any). */
2127 output_loc_operands (loc
, for_eh_or_skip
);
2131 /* Output location description stack opcode's operands (if any).
2132 The output is single bytes on a line, suitable for .cfi_escape. */
2135 output_loc_operands_raw (dw_loc_descr_ref loc
)
2137 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2138 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2140 switch (loc
->dw_loc_opc
)
2143 case DW_OP_GNU_addr_index
:
2144 case DW_OP_GNU_const_index
:
2145 case DW_OP_implicit_value
:
2146 /* We cannot output addresses in .cfi_escape, only bytes. */
2152 case DW_OP_deref_size
:
2153 case DW_OP_xderef_size
:
2154 fputc (',', asm_out_file
);
2155 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2160 fputc (',', asm_out_file
);
2161 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2166 fputc (',', asm_out_file
);
2167 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2172 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2173 fputc (',', asm_out_file
);
2174 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2182 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2183 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2185 fputc (',', asm_out_file
);
2186 dw2_asm_output_data_raw (2, offset
);
2192 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2193 gcc_assert (size_of_uleb128 (r
)
2194 == size_of_uleb128 (val1
->v
.val_unsigned
));
2195 fputc (',', asm_out_file
);
2196 dw2_asm_output_data_uleb128_raw (r
);
2201 case DW_OP_plus_uconst
:
2203 fputc (',', asm_out_file
);
2204 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2207 case DW_OP_bit_piece
:
2208 fputc (',', asm_out_file
);
2209 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2210 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2247 fputc (',', asm_out_file
);
2248 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2253 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2254 gcc_assert (size_of_uleb128 (r
)
2255 == size_of_uleb128 (val1
->v
.val_unsigned
));
2256 fputc (',', asm_out_file
);
2257 dw2_asm_output_data_uleb128_raw (r
);
2258 fputc (',', asm_out_file
);
2259 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2263 case DW_OP_GNU_implicit_pointer
:
2264 case DW_OP_GNU_entry_value
:
2265 case DW_OP_GNU_const_type
:
2266 case DW_OP_GNU_regval_type
:
2267 case DW_OP_GNU_deref_type
:
2268 case DW_OP_GNU_convert
:
2269 case DW_OP_GNU_reinterpret
:
2270 case DW_OP_GNU_parameter_ref
:
2275 /* Other codes have no operands. */
2281 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2285 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2286 /* Output the opcode. */
2287 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2289 unsigned r
= (opc
- DW_OP_breg0
);
2290 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2291 gcc_assert (r
<= 31);
2292 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2294 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2296 unsigned r
= (opc
- DW_OP_reg0
);
2297 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2298 gcc_assert (r
<= 31);
2299 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2301 /* Output the opcode. */
2302 fprintf (asm_out_file
, "%#x", opc
);
2303 output_loc_operands_raw (loc
);
2305 if (!loc
->dw_loc_next
)
2307 loc
= loc
->dw_loc_next
;
2309 fputc (',', asm_out_file
);
2313 /* This function builds a dwarf location descriptor sequence from a
2314 dw_cfa_location, adding the given OFFSET to the result of the
2317 struct dw_loc_descr_node
*
2318 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
2320 struct dw_loc_descr_node
*head
, *tmp
;
2322 offset
+= cfa
->offset
;
2326 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2327 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2328 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2329 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2330 add_loc_descr (&head
, tmp
);
2333 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
2334 add_loc_descr (&head
, tmp
);
2338 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2343 /* This function builds a dwarf location descriptor sequence for
2344 the address at OFFSET from the CFA when stack is aligned to
2347 struct dw_loc_descr_node
*
2348 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2349 HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
2351 struct dw_loc_descr_node
*head
;
2352 unsigned int dwarf_fp
2353 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2355 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2356 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2358 head
= new_reg_loc_descr (dwarf_fp
, 0);
2359 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2360 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2361 loc_descr_plus_const (&head
, offset
);
2364 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2368 /* And now, the support for symbolic debugging information. */
2370 /* .debug_str support. */
2371 static int output_indirect_string (void **, void *);
2373 static void dwarf2out_init (const char *);
2374 static void dwarf2out_finish (const char *);
2375 static void dwarf2out_assembly_start (void);
2376 static void dwarf2out_define (unsigned int, const char *);
2377 static void dwarf2out_undef (unsigned int, const char *);
2378 static void dwarf2out_start_source_file (unsigned, const char *);
2379 static void dwarf2out_end_source_file (unsigned);
2380 static void dwarf2out_function_decl (tree
);
2381 static void dwarf2out_begin_block (unsigned, unsigned);
2382 static void dwarf2out_end_block (unsigned, unsigned);
2383 static bool dwarf2out_ignore_block (const_tree
);
2384 static void dwarf2out_global_decl (tree
);
2385 static void dwarf2out_type_decl (tree
, int);
2386 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool);
2387 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2389 static void dwarf2out_abstract_function (tree
);
2390 static void dwarf2out_var_location (rtx
);
2391 static void dwarf2out_begin_function (tree
);
2392 static void dwarf2out_end_function (unsigned int);
2393 static void dwarf2out_set_name (tree
, tree
);
2395 /* The debug hooks structure. */
2397 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2401 dwarf2out_assembly_start
,
2404 dwarf2out_start_source_file
,
2405 dwarf2out_end_source_file
,
2406 dwarf2out_begin_block
,
2407 dwarf2out_end_block
,
2408 dwarf2out_ignore_block
,
2409 dwarf2out_source_line
,
2410 dwarf2out_begin_prologue
,
2411 #if VMS_DEBUGGING_INFO
2412 dwarf2out_vms_end_prologue
,
2413 dwarf2out_vms_begin_epilogue
,
2415 debug_nothing_int_charstar
,
2416 debug_nothing_int_charstar
,
2418 dwarf2out_end_epilogue
,
2419 dwarf2out_begin_function
,
2420 dwarf2out_end_function
, /* end_function */
2421 dwarf2out_function_decl
, /* function_decl */
2422 dwarf2out_global_decl
,
2423 dwarf2out_type_decl
, /* type_decl */
2424 dwarf2out_imported_module_or_decl
,
2425 debug_nothing_tree
, /* deferred_inline_function */
2426 /* The DWARF 2 backend tries to reduce debugging bloat by not
2427 emitting the abstract description of inline functions until
2428 something tries to reference them. */
2429 dwarf2out_abstract_function
, /* outlining_inline_function */
2430 debug_nothing_rtx
, /* label */
2431 debug_nothing_int
, /* handle_pch */
2432 dwarf2out_var_location
,
2433 dwarf2out_switch_text_section
,
2435 1, /* start_end_main_source_file */
2436 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2439 /* NOTE: In the comments in this file, many references are made to
2440 "Debugging Information Entries". This term is abbreviated as `DIE'
2441 throughout the remainder of this file. */
2443 /* An internal representation of the DWARF output is built, and then
2444 walked to generate the DWARF debugging info. The walk of the internal
2445 representation is done after the entire program has been compiled.
2446 The types below are used to describe the internal representation. */
2448 /* Whether to put type DIEs into their own section .debug_types instead
2449 of making them part of the .debug_info section. Only supported for
2450 Dwarf V4 or higher and the user didn't disable them through
2451 -fno-debug-types-section. It is more efficient to put them in a
2452 separate comdat sections since the linker will then be able to
2453 remove duplicates. But not all tools support .debug_types sections
2456 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2458 /* Various DIE's use offsets relative to the beginning of the
2459 .debug_info section to refer to each other. */
2461 typedef long int dw_offset
;
2463 /* Define typedefs here to avoid circular dependencies. */
2465 typedef struct dw_attr_struct
*dw_attr_ref
;
2466 typedef struct dw_line_info_struct
*dw_line_info_ref
;
2467 typedef struct pubname_struct
*pubname_ref
;
2468 typedef struct dw_ranges_struct
*dw_ranges_ref
;
2469 typedef struct dw_ranges_by_label_struct
*dw_ranges_by_label_ref
;
2470 typedef struct comdat_type_struct
*comdat_type_node_ref
;
2472 /* The entries in the line_info table more-or-less mirror the opcodes
2473 that are used in the real dwarf line table. Arrays of these entries
2474 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2477 enum dw_line_info_opcode
{
2478 /* Emit DW_LNE_set_address; the operand is the label index. */
2481 /* Emit a row to the matrix with the given line. This may be done
2482 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2486 /* Emit a DW_LNS_set_file. */
2489 /* Emit a DW_LNS_set_column. */
2492 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2495 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2496 LI_set_prologue_end
,
2497 LI_set_epilogue_begin
,
2499 /* Emit a DW_LNE_set_discriminator. */
2500 LI_set_discriminator
2503 typedef struct GTY(()) dw_line_info_struct
{
2504 enum dw_line_info_opcode opcode
;
2506 } dw_line_info_entry
;
2509 typedef struct GTY(()) dw_line_info_table_struct
{
2510 /* The label that marks the end of this section. */
2511 const char *end_label
;
2513 /* The values for the last row of the matrix, as collected in the table.
2514 These are used to minimize the changes to the next row. */
2515 unsigned int file_num
;
2516 unsigned int line_num
;
2517 unsigned int column_num
;
2522 vec
<dw_line_info_entry
, va_gc
> *entries
;
2523 } dw_line_info_table
;
2525 typedef dw_line_info_table
*dw_line_info_table_p
;
2528 /* Each DIE attribute has a field specifying the attribute kind,
2529 a link to the next attribute in the chain, and an attribute value.
2530 Attributes are typically linked below the DIE they modify. */
2532 typedef struct GTY(()) dw_attr_struct
{
2533 enum dwarf_attribute dw_attr
;
2534 dw_val_node dw_attr_val
;
2539 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2540 The children of each node form a circular list linked by
2541 die_sib. die_child points to the node *before* the "first" child node. */
2543 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct
{
2544 union die_symbol_or_type_node
2546 const char * GTY ((tag ("0"))) die_symbol
;
2547 comdat_type_node_ref
GTY ((tag ("1"))) die_type_node
;
2549 GTY ((desc ("%0.comdat_type_p"))) die_id
;
2550 vec
<dw_attr_node
, va_gc
> *die_attr
;
2551 dw_die_ref die_parent
;
2552 dw_die_ref die_child
;
2554 dw_die_ref die_definition
; /* ref from a specification to its definition */
2555 dw_offset die_offset
;
2556 unsigned long die_abbrev
;
2558 unsigned int decl_id
;
2559 enum dwarf_tag die_tag
;
2560 /* Die is used and must not be pruned as unused. */
2561 BOOL_BITFIELD die_perennial_p
: 1;
2562 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
2563 /* Lots of spare bits. */
2567 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2568 #define FOR_EACH_CHILD(die, c, expr) do { \
2569 c = die->die_child; \
2573 } while (c != die->die_child); \
2576 /* The pubname structure */
2578 typedef struct GTY(()) pubname_struct
{
2585 struct GTY(()) dw_ranges_struct
{
2586 /* If this is positive, it's a block number, otherwise it's a
2587 bitwise-negated index into dw_ranges_by_label. */
2591 /* A structure to hold a macinfo entry. */
2593 typedef struct GTY(()) macinfo_struct
{
2595 unsigned HOST_WIDE_INT lineno
;
2601 struct GTY(()) dw_ranges_by_label_struct
{
2606 /* The comdat type node structure. */
2607 typedef struct GTY(()) comdat_type_struct
2609 dw_die_ref root_die
;
2610 dw_die_ref type_die
;
2611 dw_die_ref skeleton_die
;
2612 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
2613 struct comdat_type_struct
*next
;
2617 /* The limbo die list structure. */
2618 typedef struct GTY(()) limbo_die_struct
{
2621 struct limbo_die_struct
*next
;
2625 typedef struct skeleton_chain_struct
2629 struct skeleton_chain_struct
*parent
;
2631 skeleton_chain_node
;
2633 /* Define a macro which returns nonzero for a TYPE_DECL which was
2634 implicitly generated for a type.
2636 Note that, unlike the C front-end (which generates a NULL named
2637 TYPE_DECL node for each complete tagged type, each array type,
2638 and each function type node created) the C++ front-end generates
2639 a _named_ TYPE_DECL node for each tagged type node created.
2640 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2641 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2642 front-end, but for each type, tagged or not. */
2644 #define TYPE_DECL_IS_STUB(decl) \
2645 (DECL_NAME (decl) == NULL_TREE \
2646 || (DECL_ARTIFICIAL (decl) \
2647 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2648 /* This is necessary for stub decls that \
2649 appear in nested inline functions. */ \
2650 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2651 && (decl_ultimate_origin (decl) \
2652 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2654 /* Information concerning the compilation unit's programming
2655 language, and compiler version. */
2657 /* Fixed size portion of the DWARF compilation unit header. */
2658 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2659 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2661 /* Fixed size portion of the DWARF comdat type unit header. */
2662 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2663 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2664 + DWARF_OFFSET_SIZE)
2666 /* Fixed size portion of public names info. */
2667 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2669 /* Fixed size portion of the address range info. */
2670 #define DWARF_ARANGES_HEADER_SIZE \
2671 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2672 DWARF2_ADDR_SIZE * 2) \
2673 - DWARF_INITIAL_LENGTH_SIZE)
2675 /* Size of padding portion in the address range info. It must be
2676 aligned to twice the pointer size. */
2677 #define DWARF_ARANGES_PAD_SIZE \
2678 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2679 DWARF2_ADDR_SIZE * 2) \
2680 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2682 /* Use assembler line directives if available. */
2683 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2684 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2685 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2687 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2691 /* Minimum line offset in a special line info. opcode.
2692 This value was chosen to give a reasonable range of values. */
2693 #define DWARF_LINE_BASE -10
2695 /* First special line opcode - leave room for the standard opcodes. */
2696 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2698 /* Range of line offsets in a special line info. opcode. */
2699 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2701 /* Flag that indicates the initial value of the is_stmt_start flag.
2702 In the present implementation, we do not mark any lines as
2703 the beginning of a source statement, because that information
2704 is not made available by the GCC front-end. */
2705 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2707 /* Maximum number of operations per instruction bundle. */
2708 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2709 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2712 /* This location is used by calc_die_sizes() to keep track
2713 the offset of each DIE within the .debug_info section. */
2714 static unsigned long next_die_offset
;
2716 /* Record the root of the DIE's built for the current compilation unit. */
2717 static GTY(()) dw_die_ref single_comp_unit_die
;
2719 /* A list of type DIEs that have been separated into comdat sections. */
2720 static GTY(()) comdat_type_node
*comdat_type_list
;
2722 /* A list of DIEs with a NULL parent waiting to be relocated. */
2723 static GTY(()) limbo_die_node
*limbo_die_list
;
2725 /* A list of DIEs for which we may have to generate
2726 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2727 static GTY(()) limbo_die_node
*deferred_asm_name
;
2729 /* Filenames referenced by this compilation unit. */
2730 static GTY((param_is (struct dwarf_file_data
))) htab_t file_table
;
2732 /* A hash table of references to DIE's that describe declarations.
2733 The key is a DECL_UID() which is a unique number identifying each decl. */
2734 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
2736 /* A hash table of references to DIE's that describe COMMON blocks.
2737 The key is DECL_UID() ^ die_parent. */
2738 static GTY ((param_is (struct die_struct
))) htab_t common_block_die_table
;
2740 typedef struct GTY(()) die_arg_entry_struct
{
2746 /* Node of the variable location list. */
2747 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
2748 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2749 EXPR_LIST chain. For small bitsizes, bitsize is encoded
2750 in mode of the EXPR_LIST node and first EXPR_LIST operand
2751 is either NOTE_INSN_VAR_LOCATION for a piece with a known
2752 location or NULL for padding. For larger bitsizes,
2753 mode is 0 and first operand is a CONCAT with bitsize
2754 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2755 NULL as second operand. */
2757 const char * GTY (()) label
;
2758 struct var_loc_node
* GTY (()) next
;
2761 /* Variable location list. */
2762 struct GTY (()) var_loc_list_def
{
2763 struct var_loc_node
* GTY (()) first
;
2765 /* Pointer to the last but one or last element of the
2766 chained list. If the list is empty, both first and
2767 last are NULL, if the list contains just one node
2768 or the last node certainly is not redundant, it points
2769 to the last node, otherwise points to the last but one.
2770 Do not mark it for GC because it is marked through the chain. */
2771 struct var_loc_node
* GTY ((skip ("%h"))) last
;
2773 /* Pointer to the last element before section switch,
2774 if NULL, either sections weren't switched or first
2775 is after section switch. */
2776 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
2778 /* DECL_UID of the variable decl. */
2779 unsigned int decl_id
;
2781 typedef struct var_loc_list_def var_loc_list
;
2783 /* Call argument location list. */
2784 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
2785 rtx
GTY (()) call_arg_loc_note
;
2786 const char * GTY (()) label
;
2787 tree
GTY (()) block
;
2789 rtx
GTY (()) symbol_ref
;
2790 struct call_arg_loc_node
* GTY (()) next
;
2794 /* Table of decl location linked lists. */
2795 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
2797 /* Head and tail of call_arg_loc chain. */
2798 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
2799 static struct call_arg_loc_node
*call_arg_loc_last
;
2801 /* Number of call sites in the current function. */
2802 static int call_site_count
= -1;
2803 /* Number of tail call sites in the current function. */
2804 static int tail_call_site_count
= -1;
2806 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
2808 static vec
<dw_die_ref
> block_map
;
2810 /* A cached location list. */
2811 struct GTY (()) cached_dw_loc_list_def
{
2812 /* The DECL_UID of the decl that this entry describes. */
2813 unsigned int decl_id
;
2815 /* The cached location list. */
2816 dw_loc_list_ref loc_list
;
2818 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
2820 /* Table of cached location lists. */
2821 static GTY ((param_is (cached_dw_loc_list
))) htab_t cached_dw_loc_list_table
;
2823 /* A pointer to the base of a list of references to DIE's that
2824 are uniquely identified by their tag, presence/absence of
2825 children DIE's, and list of attribute/value pairs. */
2826 static GTY((length ("abbrev_die_table_allocated")))
2827 dw_die_ref
*abbrev_die_table
;
2829 /* Number of elements currently allocated for abbrev_die_table. */
2830 static GTY(()) unsigned abbrev_die_table_allocated
;
2832 /* Number of elements in type_die_table currently in use. */
2833 static GTY(()) unsigned abbrev_die_table_in_use
;
2835 /* Size (in elements) of increments by which we may expand the
2836 abbrev_die_table. */
2837 #define ABBREV_DIE_TABLE_INCREMENT 256
2839 /* A global counter for generating labels for line number data. */
2840 static unsigned int line_info_label_num
;
2842 /* The current table to which we should emit line number information
2843 for the current function. This will be set up at the beginning of
2844 assembly for the function. */
2845 static dw_line_info_table
*cur_line_info_table
;
2847 /* The two default tables of line number info. */
2848 static GTY(()) dw_line_info_table
*text_section_line_info
;
2849 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
2851 /* The set of all non-default tables of line number info. */
2852 static GTY(()) vec
<dw_line_info_table_p
, va_gc
> *separate_line_info
;
2854 /* A flag to tell pubnames/types export if there is an info section to
2856 static bool info_section_emitted
;
2858 /* A pointer to the base of a table that contains a list of publicly
2859 accessible names. */
2860 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
2862 /* A pointer to the base of a table that contains a list of publicly
2863 accessible types. */
2864 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
2866 /* A pointer to the base of a table that contains a list of macro
2867 defines/undefines (and file start/end markers). */
2868 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
2870 /* True if .debug_macinfo or .debug_macros section is going to be
2872 #define have_macinfo \
2873 (debug_info_level >= DINFO_LEVEL_VERBOSE \
2874 && !macinfo_table->is_empty ())
2876 /* Array of dies for which we should generate .debug_ranges info. */
2877 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
2879 /* Number of elements currently allocated for ranges_table. */
2880 static GTY(()) unsigned ranges_table_allocated
;
2882 /* Number of elements in ranges_table currently in use. */
2883 static GTY(()) unsigned ranges_table_in_use
;
2885 /* Array of pairs of labels referenced in ranges_table. */
2886 static GTY ((length ("ranges_by_label_allocated")))
2887 dw_ranges_by_label_ref ranges_by_label
;
2889 /* Number of elements currently allocated for ranges_by_label. */
2890 static GTY(()) unsigned ranges_by_label_allocated
;
2892 /* Number of elements in ranges_by_label currently in use. */
2893 static GTY(()) unsigned ranges_by_label_in_use
;
2895 /* Size (in elements) of increments by which we may expand the
2897 #define RANGES_TABLE_INCREMENT 64
2899 /* Whether we have location lists that need outputting */
2900 static GTY(()) bool have_location_lists
;
2902 /* Unique label counter. */
2903 static GTY(()) unsigned int loclabel_num
;
2905 /* Unique label counter for point-of-call tables. */
2906 static GTY(()) unsigned int poc_label_num
;
2908 /* Record whether the function being analyzed contains inlined functions. */
2909 static int current_function_has_inlines
;
2911 /* The last file entry emitted by maybe_emit_file(). */
2912 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
2914 /* Number of internal labels generated by gen_internal_sym(). */
2915 static GTY(()) int label_num
;
2917 /* Cached result of previous call to lookup_filename. */
2918 static GTY(()) struct dwarf_file_data
* file_table_last_lookup
;
2920 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
2922 /* Instances of generic types for which we need to generate debug
2923 info that describe their generic parameters and arguments. That
2924 generation needs to happen once all types are properly laid out so
2925 we do it at the end of compilation. */
2926 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
2928 /* Offset from the "steady-state frame pointer" to the frame base,
2929 within the current function. */
2930 static HOST_WIDE_INT frame_pointer_fb_offset
;
2931 static bool frame_pointer_fb_offset_valid
;
2933 static vec
<dw_die_ref
> base_types
;
2935 /* Forward declarations for functions defined in this file. */
2937 static int is_pseudo_reg (const_rtx
);
2938 static tree
type_main_variant (tree
);
2939 static int is_tagged_type (const_tree
);
2940 static const char *dwarf_tag_name (unsigned);
2941 static const char *dwarf_attr_name (unsigned);
2942 static const char *dwarf_form_name (unsigned);
2943 static tree
decl_ultimate_origin (const_tree
);
2944 static tree
decl_class_context (tree
);
2945 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
2946 static inline enum dw_val_class
AT_class (dw_attr_ref
);
2947 static inline unsigned int AT_index (dw_attr_ref
);
2948 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
2949 static inline unsigned AT_flag (dw_attr_ref
);
2950 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
2951 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
2952 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
2953 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
2954 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
2955 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
2956 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
2957 unsigned int, unsigned char *);
2958 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
2959 static hashval_t
debug_str_do_hash (const void *);
2960 static int debug_str_eq (const void *, const void *);
2961 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
2962 static inline const char *AT_string (dw_attr_ref
);
2963 static enum dwarf_form
AT_string_form (dw_attr_ref
);
2964 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
2965 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
2966 static inline dw_die_ref
AT_ref (dw_attr_ref
);
2967 static inline int AT_ref_external (dw_attr_ref
);
2968 static inline void set_AT_ref_external (dw_attr_ref
, int);
2969 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
2970 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
2971 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
2972 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
2974 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
2975 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
2976 static void remove_addr_table_entry (addr_table_entry
*);
2977 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
2978 static inline rtx
AT_addr (dw_attr_ref
);
2979 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
2980 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
2981 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
2982 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
2983 unsigned HOST_WIDE_INT
);
2984 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
2985 unsigned long, bool);
2986 static inline const char *AT_lbl (dw_attr_ref
);
2987 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
2988 static const char *get_AT_low_pc (dw_die_ref
);
2989 static const char *get_AT_hi_pc (dw_die_ref
);
2990 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
2991 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
2992 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
2993 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
2994 static bool is_cxx (void);
2995 static bool is_fortran (void);
2996 static bool is_ada (void);
2997 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
2998 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
2999 static void add_child_die (dw_die_ref
, dw_die_ref
);
3000 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3001 static dw_die_ref
lookup_type_die (tree
);
3002 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3003 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3004 static void equate_type_number_to_die (tree
, dw_die_ref
);
3005 static hashval_t
decl_die_table_hash (const void *);
3006 static int decl_die_table_eq (const void *, const void *);
3007 static dw_die_ref
lookup_decl_die (tree
);
3008 static hashval_t
common_block_die_table_hash (const void *);
3009 static int common_block_die_table_eq (const void *, const void *);
3010 static hashval_t
decl_loc_table_hash (const void *);
3011 static int decl_loc_table_eq (const void *, const void *);
3012 static var_loc_list
*lookup_decl_loc (const_tree
);
3013 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3014 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *);
3015 static void print_spaces (FILE *);
3016 static void print_die (dw_die_ref
, FILE *);
3017 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
3018 static dw_die_ref
pop_compile_unit (dw_die_ref
);
3019 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3020 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
3021 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3022 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3023 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3024 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3025 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_ref
,
3026 struct md5_ctx
*, int *);
3027 struct checksum_attributes
;
3028 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3029 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3030 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3031 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3032 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3033 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3034 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
3035 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3036 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
3037 static void compute_section_prefix (dw_die_ref
);
3038 static int is_type_die (dw_die_ref
);
3039 static int is_comdat_die (dw_die_ref
);
3040 static int is_symbol_die (dw_die_ref
);
3041 static inline bool is_template_instantiation (dw_die_ref
);
3042 static void assign_symbol_names (dw_die_ref
);
3043 static void break_out_includes (dw_die_ref
);
3044 static int is_declaration_die (dw_die_ref
);
3045 static int should_move_die_to_comdat (dw_die_ref
);
3046 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3047 static dw_die_ref
clone_die (dw_die_ref
);
3048 static dw_die_ref
clone_tree (dw_die_ref
);
3049 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3050 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3051 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3052 static dw_die_ref
generate_skeleton (dw_die_ref
);
3053 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3056 static void break_out_comdat_types (dw_die_ref
);
3057 static void copy_decls_for_unworthy_types (dw_die_ref
);
3059 static void add_sibling_attributes (dw_die_ref
);
3060 static void output_location_lists (dw_die_ref
);
3061 static int constant_size (unsigned HOST_WIDE_INT
);
3062 static unsigned long size_of_die (dw_die_ref
);
3063 static void calc_die_sizes (dw_die_ref
);
3064 static void calc_base_type_die_sizes (void);
3065 static void mark_dies (dw_die_ref
);
3066 static void unmark_dies (dw_die_ref
);
3067 static void unmark_all_dies (dw_die_ref
);
3068 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3069 static unsigned long size_of_aranges (void);
3070 static enum dwarf_form
value_format (dw_attr_ref
);
3071 static void output_value_format (dw_attr_ref
);
3072 static void output_abbrev_section (void);
3073 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3074 static void output_die_symbol (dw_die_ref
);
3075 static void output_die (dw_die_ref
);
3076 static void output_compilation_unit_header (void);
3077 static void output_comp_unit (dw_die_ref
, int);
3078 static void output_comdat_type_unit (comdat_type_node
*);
3079 static const char *dwarf2_name (tree
, int);
3080 static void add_pubname (tree
, dw_die_ref
);
3081 static void add_enumerator_pubname (const char *, dw_die_ref
);
3082 static void add_pubname_string (const char *, dw_die_ref
);
3083 static void add_pubtype (tree
, dw_die_ref
);
3084 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3085 static void output_aranges (unsigned long);
3086 static unsigned int add_ranges_num (int);
3087 static unsigned int add_ranges (const_tree
);
3088 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3090 static void output_ranges (void);
3091 static dw_line_info_table
*new_line_info_table (void);
3092 static void output_line_info (bool);
3093 static void output_file_names (void);
3094 static dw_die_ref
base_type_die (tree
);
3095 static int is_base_type (tree
);
3096 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, dw_die_ref
);
3097 static dw_die_ref
modified_type_die (tree
, int, int, dw_die_ref
);
3098 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3099 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3100 static int type_is_enum (const_tree
);
3101 static unsigned int dbx_reg_number (const_rtx
);
3102 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3103 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3104 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3105 enum var_init_status
);
3106 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3107 enum var_init_status
);
3108 static dw_loc_descr_ref
based_loc_descr (rtx
, HOST_WIDE_INT
,
3109 enum var_init_status
);
3110 static int is_based_loc (const_rtx
);
3111 static int resolve_one_addr (rtx
*, void *);
3112 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3113 enum var_init_status
);
3114 static dw_loc_descr_ref
loc_descriptor (rtx
, enum machine_mode mode
,
3115 enum var_init_status
);
3116 static dw_loc_list_ref
loc_list_from_tree (tree
, int);
3117 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int);
3118 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3119 static tree
field_type (const_tree
);
3120 static unsigned int simple_type_align_in_bits (const_tree
);
3121 static unsigned int simple_decl_align_in_bits (const_tree
);
3122 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3123 static HOST_WIDE_INT
field_byte_offset (const_tree
);
3124 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3126 static void add_data_member_location_attribute (dw_die_ref
, tree
);
3127 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3128 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3129 static void insert_double (double_int
, unsigned char *);
3130 static void insert_float (const_rtx
, unsigned char *);
3131 static rtx
rtl_for_decl_location (tree
);
3132 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool,
3133 enum dwarf_attribute
);
3134 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3135 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3136 static void add_name_attribute (dw_die_ref
, const char *);
3137 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3138 static void add_comp_dir_attribute (dw_die_ref
);
3139 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
3140 static void add_subscript_info (dw_die_ref
, tree
, bool);
3141 static void add_byte_size_attribute (dw_die_ref
, tree
);
3142 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3143 static void add_bit_size_attribute (dw_die_ref
, tree
);
3144 static void add_prototyped_attribute (dw_die_ref
, tree
);
3145 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3146 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3147 static void add_src_coords_attributes (dw_die_ref
, tree
);
3148 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
3149 static void push_decl_scope (tree
);
3150 static void pop_decl_scope (void);
3151 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3152 static inline int local_scope_p (dw_die_ref
);
3153 static inline int class_scope_p (dw_die_ref
);
3154 static inline int class_or_namespace_scope_p (dw_die_ref
);
3155 static void add_type_attribute (dw_die_ref
, tree
, int, int, dw_die_ref
);
3156 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3157 static const char *type_tag (const_tree
);
3158 static tree
member_declared_type (const_tree
);
3160 static const char *decl_start_label (tree
);
3162 static void gen_array_type_die (tree
, dw_die_ref
);
3163 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3165 static void gen_entry_point_die (tree
, dw_die_ref
);
3167 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3168 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3169 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3170 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3171 static void gen_formal_types_die (tree
, dw_die_ref
);
3172 static void gen_subprogram_die (tree
, dw_die_ref
);
3173 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3174 static void gen_const_die (tree
, dw_die_ref
);
3175 static void gen_label_die (tree
, dw_die_ref
);
3176 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
3177 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
3178 static void gen_field_die (tree
, dw_die_ref
);
3179 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3180 static dw_die_ref
gen_compile_unit_die (const char *);
3181 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
3182 static void gen_member_die (tree
, dw_die_ref
);
3183 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3184 enum debug_info_usage
);
3185 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3186 static void gen_typedef_die (tree
, dw_die_ref
);
3187 static void gen_type_die (tree
, dw_die_ref
);
3188 static void gen_block_die (tree
, dw_die_ref
, int);
3189 static void decls_for_scope (tree
, dw_die_ref
, int);
3190 static inline int is_redundant_typedef (const_tree
);
3191 static bool is_naming_typedef_decl (const_tree
);
3192 static inline dw_die_ref
get_context_die (tree
);
3193 static void gen_namespace_die (tree
, dw_die_ref
);
3194 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3195 static dw_die_ref
gen_decl_die (tree
, tree
, dw_die_ref
);
3196 static dw_die_ref
force_decl_die (tree
);
3197 static dw_die_ref
force_type_die (tree
);
3198 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3199 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3200 static struct dwarf_file_data
* lookup_filename (const char *);
3201 static void retry_incomplete_types (void);
3202 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3203 static void gen_generic_params_dies (tree
);
3204 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3205 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3206 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3207 static int file_info_cmp (const void *, const void *);
3208 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3209 const char *, const char *);
3210 static void output_loc_list (dw_loc_list_ref
);
3211 static char *gen_internal_sym (const char *);
3212 static bool want_pubnames (void);
3214 static void prune_unmark_dies (dw_die_ref
);
3215 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3216 static void prune_unused_types_mark (dw_die_ref
, int);
3217 static void prune_unused_types_walk (dw_die_ref
);
3218 static void prune_unused_types_walk_attribs (dw_die_ref
);
3219 static void prune_unused_types_prune (dw_die_ref
);
3220 static void prune_unused_types (void);
3221 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3222 static inline const char *AT_vms_delta1 (dw_attr_ref
);
3223 static inline const char *AT_vms_delta2 (dw_attr_ref
);
3224 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3225 const char *, const char *);
3226 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3227 static void gen_remaining_tmpl_value_param_die_attribute (void);
3228 static bool generic_type_p (tree
);
3229 static void schedule_generic_params_dies_gen (tree t
);
3230 static void gen_scheduled_generic_parms_dies (void);
3232 static const char *comp_dir_string (void);
3234 static hashval_t
hash_loc_operands (dw_loc_descr_ref
, hashval_t
);
3236 /* enum for tracking thread-local variables whose address is really an offset
3237 relative to the TLS pointer, which will need link-time relocation, but will
3238 not need relocation by the DWARF consumer. */
3246 /* Return the operator to use for an address of a variable. For dtprel_true, we
3247 use DW_OP_const*. For regular variables, which need both link-time
3248 relocation and consumer-level relocation (e.g., to account for shared objects
3249 loaded at a random address), we use DW_OP_addr*. */
3251 static inline enum dwarf_location_atom
3252 dw_addr_op (enum dtprel_bool dtprel
)
3254 if (dtprel
== dtprel_true
)
3255 return (dwarf_split_debug_info
? DW_OP_GNU_const_index
3256 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3258 return dwarf_split_debug_info
? DW_OP_GNU_addr_index
: DW_OP_addr
;
3261 /* Return a pointer to a newly allocated address location description. If
3262 dwarf_split_debug_info is true, then record the address with the appropriate
3264 static inline dw_loc_descr_ref
3265 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3267 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3269 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3270 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3271 ref
->dtprel
= dtprel
;
3272 if (dwarf_split_debug_info
)
3273 ref
->dw_loc_oprnd1
.val_entry
3274 = add_addr_table_entry (addr
,
3275 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3277 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3282 /* Section names used to hold DWARF debugging information. */
3284 #ifndef DEBUG_INFO_SECTION
3285 #define DEBUG_INFO_SECTION ".debug_info"
3287 #ifndef DEBUG_DWO_INFO_SECTION
3288 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3290 #ifndef DEBUG_ABBREV_SECTION
3291 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3293 #ifndef DEBUG_DWO_ABBREV_SECTION
3294 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3296 #ifndef DEBUG_ARANGES_SECTION
3297 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3299 #ifndef DEBUG_ADDR_SECTION
3300 #define DEBUG_ADDR_SECTION ".debug_addr"
3302 #ifndef DEBUG_NORM_MACINFO_SECTION
3303 #define DEBUG_NORM_MACINFO_SECTION ".debug_macinfo"
3305 #ifndef DEBUG_DWO_MACINFO_SECTION
3306 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3308 #ifndef DEBUG_MACINFO_SECTION
3309 #define DEBUG_MACINFO_SECTION \
3310 (!dwarf_split_debug_info \
3311 ? (DEBUG_NORM_MACINFO_SECTION) : (DEBUG_DWO_MACINFO_SECTION))
3313 #ifndef DEBUG_NORM_MACRO_SECTION
3314 #define DEBUG_NORM_MACRO_SECTION ".debug_macro"
3316 #ifndef DEBUG_DWO_MACRO_SECTION
3317 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3319 #ifndef DEBUG_MACRO_SECTION
3320 #define DEBUG_MACRO_SECTION \
3321 (!dwarf_split_debug_info \
3322 ? (DEBUG_NORM_MACRO_SECTION) : (DEBUG_DWO_MACRO_SECTION))
3324 #ifndef DEBUG_LINE_SECTION
3325 #define DEBUG_LINE_SECTION ".debug_line"
3327 #ifndef DEBUG_DWO_LINE_SECTION
3328 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3330 #ifndef DEBUG_LOC_SECTION
3331 #define DEBUG_LOC_SECTION ".debug_loc"
3333 #ifndef DEBUG_DWO_LOC_SECTION
3334 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3336 #ifndef DEBUG_PUBNAMES_SECTION
3337 #define DEBUG_PUBNAMES_SECTION \
3338 ((debug_generate_pub_sections == 2) \
3339 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3341 #ifndef DEBUG_PUBTYPES_SECTION
3342 #define DEBUG_PUBTYPES_SECTION \
3343 ((debug_generate_pub_sections == 2) \
3344 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3346 #define DEBUG_NORM_STR_OFFSETS_SECTION ".debug_str_offsets"
3347 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3348 #ifndef DEBUG_STR_OFFSETS_SECTION
3349 #define DEBUG_STR_OFFSETS_SECTION \
3350 (!dwarf_split_debug_info \
3351 ? (DEBUG_NORM_STR_OFFSETS_SECTION) : (DEBUG_DWO_STR_OFFSETS_SECTION))
3353 #ifndef DEBUG_STR_DWO_SECTION
3354 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3356 #ifndef DEBUG_STR_SECTION
3357 #define DEBUG_STR_SECTION ".debug_str"
3359 #ifndef DEBUG_RANGES_SECTION
3360 #define DEBUG_RANGES_SECTION ".debug_ranges"
3363 /* Standard ELF section names for compiled code and data. */
3364 #ifndef TEXT_SECTION_NAME
3365 #define TEXT_SECTION_NAME ".text"
3368 /* Section flags for .debug_macinfo/.debug_macro section. */
3369 #define DEBUG_MACRO_SECTION_FLAGS \
3370 (dwarf_split_debug_info ? SECTION_DEBUG | SECTION_EXCLUDE : SECTION_DEBUG)
3372 /* Section flags for .debug_str section. */
3373 #define DEBUG_STR_SECTION_FLAGS \
3374 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3375 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3378 /* Section flags for .debug_str.dwo section. */
3379 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3381 /* Labels we insert at beginning sections we can reference instead of
3382 the section names themselves. */
3384 #ifndef TEXT_SECTION_LABEL
3385 #define TEXT_SECTION_LABEL "Ltext"
3387 #ifndef COLD_TEXT_SECTION_LABEL
3388 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3390 #ifndef DEBUG_LINE_SECTION_LABEL
3391 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3393 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3394 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3396 #ifndef DEBUG_INFO_SECTION_LABEL
3397 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3399 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3400 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3402 #ifndef DEBUG_ABBREV_SECTION_LABEL
3403 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3405 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3406 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3408 #ifndef DEBUG_ADDR_SECTION_LABEL
3409 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3411 #ifndef DEBUG_LOC_SECTION_LABEL
3412 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3414 #ifndef DEBUG_RANGES_SECTION_LABEL
3415 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3417 #ifndef DEBUG_MACINFO_SECTION_LABEL
3418 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3420 #ifndef DEBUG_MACRO_SECTION_LABEL
3421 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3423 #define SKELETON_COMP_DIE_ABBREV 1
3424 #define SKELETON_TYPE_DIE_ABBREV 2
3426 /* Definitions of defaults for formats and names of various special
3427 (artificial) labels which may be generated within this file (when the -g
3428 options is used and DWARF2_DEBUGGING_INFO is in effect.
3429 If necessary, these may be overridden from within the tm.h file, but
3430 typically, overriding these defaults is unnecessary. */
3432 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3433 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3434 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3435 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3436 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3437 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3438 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3439 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3440 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3441 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3442 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3443 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3444 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3445 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3447 #ifndef TEXT_END_LABEL
3448 #define TEXT_END_LABEL "Letext"
3450 #ifndef COLD_END_LABEL
3451 #define COLD_END_LABEL "Letext_cold"
3453 #ifndef BLOCK_BEGIN_LABEL
3454 #define BLOCK_BEGIN_LABEL "LBB"
3456 #ifndef BLOCK_END_LABEL
3457 #define BLOCK_END_LABEL "LBE"
3459 #ifndef LINE_CODE_LABEL
3460 #define LINE_CODE_LABEL "LM"
3464 /* Return the root of the DIE's built for the current compilation unit. */
3466 comp_unit_die (void)
3468 if (!single_comp_unit_die
)
3469 single_comp_unit_die
= gen_compile_unit_die (NULL
);
3470 return single_comp_unit_die
;
3473 /* We allow a language front-end to designate a function that is to be
3474 called to "demangle" any name before it is put into a DIE. */
3476 static const char *(*demangle_name_func
) (const char *);
3479 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3481 demangle_name_func
= func
;
3484 /* Test if rtl node points to a pseudo register. */
3487 is_pseudo_reg (const_rtx rtl
)
3489 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3490 || (GET_CODE (rtl
) == SUBREG
3491 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3494 /* Return a reference to a type, with its const and volatile qualifiers
3498 type_main_variant (tree type
)
3500 type
= TYPE_MAIN_VARIANT (type
);
3502 /* ??? There really should be only one main variant among any group of
3503 variants of a given type (and all of the MAIN_VARIANT values for all
3504 members of the group should point to that one type) but sometimes the C
3505 front-end messes this up for array types, so we work around that bug
3507 if (TREE_CODE (type
) == ARRAY_TYPE
)
3508 while (type
!= TYPE_MAIN_VARIANT (type
))
3509 type
= TYPE_MAIN_VARIANT (type
);
3514 /* Return nonzero if the given type node represents a tagged type. */
3517 is_tagged_type (const_tree type
)
3519 enum tree_code code
= TREE_CODE (type
);
3521 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
3522 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
3525 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3528 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
3530 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
3533 /* Return die_offset of a DIE reference to a base type. */
3535 static unsigned long int
3536 get_base_type_offset (dw_die_ref ref
)
3538 if (ref
->die_offset
)
3539 return ref
->die_offset
;
3540 if (comp_unit_die ()->die_abbrev
)
3542 calc_base_type_die_sizes ();
3543 gcc_assert (ref
->die_offset
);
3545 return ref
->die_offset
;
3548 /* Return die_offset of a DIE reference other than base type. */
3550 static unsigned long int
3551 get_ref_die_offset (dw_die_ref ref
)
3553 gcc_assert (ref
->die_offset
);
3554 return ref
->die_offset
;
3557 /* Convert a DIE tag into its string name. */
3560 dwarf_tag_name (unsigned int tag
)
3562 const char *name
= get_DW_TAG_name (tag
);
3567 return "DW_TAG_<unknown>";
3570 /* Convert a DWARF attribute code into its string name. */
3573 dwarf_attr_name (unsigned int attr
)
3579 #if VMS_DEBUGGING_INFO
3580 case DW_AT_HP_prologue
:
3581 return "DW_AT_HP_prologue";
3583 case DW_AT_MIPS_loop_unroll_factor
:
3584 return "DW_AT_MIPS_loop_unroll_factor";
3587 #if VMS_DEBUGGING_INFO
3588 case DW_AT_HP_epilogue
:
3589 return "DW_AT_HP_epilogue";
3591 case DW_AT_MIPS_stride
:
3592 return "DW_AT_MIPS_stride";
3596 name
= get_DW_AT_name (attr
);
3601 return "DW_AT_<unknown>";
3604 /* Convert a DWARF value form code into its string name. */
3607 dwarf_form_name (unsigned int form
)
3609 const char *name
= get_DW_FORM_name (form
);
3614 return "DW_FORM_<unknown>";
3617 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3618 instance of an inlined instance of a decl which is local to an inline
3619 function, so we have to trace all of the way back through the origin chain
3620 to find out what sort of node actually served as the original seed for the
3624 decl_ultimate_origin (const_tree decl
)
3626 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
3629 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
3630 nodes in the function to point to themselves; ignore that if
3631 we're trying to output the abstract instance of this function. */
3632 if (DECL_ABSTRACT (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
3635 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3636 most distant ancestor, this should never happen. */
3637 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
3639 return DECL_ABSTRACT_ORIGIN (decl
);
3642 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3643 of a virtual function may refer to a base class, so we check the 'this'
3647 decl_class_context (tree decl
)
3649 tree context
= NULL_TREE
;
3651 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
3652 context
= DECL_CONTEXT (decl
);
3654 context
= TYPE_MAIN_VARIANT
3655 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
3657 if (context
&& !TYPE_P (context
))
3658 context
= NULL_TREE
;
3663 /* Add an attribute/value pair to a DIE. */
3666 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
3668 /* Maybe this should be an assert? */
3672 vec_safe_reserve (die
->die_attr
, 1);
3673 vec_safe_push (die
->die_attr
, *attr
);
3676 static inline enum dw_val_class
3677 AT_class (dw_attr_ref a
)
3679 return a
->dw_attr_val
.val_class
;
3682 /* Return the index for any attribute that will be referenced with a
3683 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
3684 are stored in dw_attr_val.v.val_str for reference counting
3687 static inline unsigned int
3688 AT_index (dw_attr_ref a
)
3690 if (AT_class (a
) == dw_val_class_str
)
3691 return a
->dw_attr_val
.v
.val_str
->index
;
3692 else if (a
->dw_attr_val
.val_entry
!= NULL
)
3693 return a
->dw_attr_val
.val_entry
->index
;
3697 /* Add a flag value attribute to a DIE. */
3700 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
3704 attr
.dw_attr
= attr_kind
;
3705 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
3706 attr
.dw_attr_val
.val_entry
= NULL
;
3707 attr
.dw_attr_val
.v
.val_flag
= flag
;
3708 add_dwarf_attr (die
, &attr
);
3711 static inline unsigned
3712 AT_flag (dw_attr_ref a
)
3714 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
3715 return a
->dw_attr_val
.v
.val_flag
;
3718 /* Add a signed integer attribute value to a DIE. */
3721 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
3725 attr
.dw_attr
= attr_kind
;
3726 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
3727 attr
.dw_attr_val
.val_entry
= NULL
;
3728 attr
.dw_attr_val
.v
.val_int
= int_val
;
3729 add_dwarf_attr (die
, &attr
);
3732 static inline HOST_WIDE_INT
3733 AT_int (dw_attr_ref a
)
3735 gcc_assert (a
&& AT_class (a
) == dw_val_class_const
);
3736 return a
->dw_attr_val
.v
.val_int
;
3739 /* Add an unsigned integer attribute value to a DIE. */
3742 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3743 unsigned HOST_WIDE_INT unsigned_val
)
3747 attr
.dw_attr
= attr_kind
;
3748 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
3749 attr
.dw_attr_val
.val_entry
= NULL
;
3750 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
3751 add_dwarf_attr (die
, &attr
);
3754 static inline unsigned HOST_WIDE_INT
3755 AT_unsigned (dw_attr_ref a
)
3757 gcc_assert (a
&& AT_class (a
) == dw_val_class_unsigned_const
);
3758 return a
->dw_attr_val
.v
.val_unsigned
;
3761 /* Add an unsigned double integer attribute value to a DIE. */
3764 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3765 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
3769 attr
.dw_attr
= attr_kind
;
3770 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
3771 attr
.dw_attr_val
.val_entry
= NULL
;
3772 attr
.dw_attr_val
.v
.val_double
.high
= high
;
3773 attr
.dw_attr_val
.v
.val_double
.low
= low
;
3774 add_dwarf_attr (die
, &attr
);
3777 /* Add a floating point attribute value to a DIE and return it. */
3780 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3781 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
3785 attr
.dw_attr
= attr_kind
;
3786 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
3787 attr
.dw_attr_val
.val_entry
= NULL
;
3788 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
3789 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
3790 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
3791 add_dwarf_attr (die
, &attr
);
3794 /* Add an 8-byte data attribute value to a DIE. */
3797 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
3798 unsigned char data8
[8])
3802 attr
.dw_attr
= attr_kind
;
3803 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
3804 attr
.dw_attr_val
.val_entry
= NULL
;
3805 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
3806 add_dwarf_attr (die
, &attr
);
3809 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
3810 dwarf_split_debug_info, address attributes in dies destined for the
3811 final executable have force_direct set to avoid using indexed
3815 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
3821 lbl_id
= xstrdup (lbl_low
);
3822 attr
.dw_attr
= DW_AT_low_pc
;
3823 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
3824 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
3825 if (dwarf_split_debug_info
&& !force_direct
)
3826 attr
.dw_attr_val
.val_entry
3827 = add_addr_table_entry (lbl_id
, ate_kind_label
);
3829 attr
.dw_attr_val
.val_entry
= NULL
;
3830 add_dwarf_attr (die
, &attr
);
3832 attr
.dw_attr
= DW_AT_high_pc
;
3833 if (dwarf_version
< 4)
3834 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
3836 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
3837 lbl_id
= xstrdup (lbl_high
);
3838 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
3839 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
3840 && dwarf_split_debug_info
&& !force_direct
)
3841 attr
.dw_attr_val
.val_entry
3842 = add_addr_table_entry (lbl_id
, ate_kind_label
);
3844 attr
.dw_attr_val
.val_entry
= NULL
;
3845 add_dwarf_attr (die
, &attr
);
3848 /* Hash and equality functions for debug_str_hash. */
3851 debug_str_do_hash (const void *x
)
3853 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
3857 debug_str_eq (const void *x1
, const void *x2
)
3859 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
3860 (const char *)x2
) == 0;
3863 /* Add STR to the given string hash table. */
3865 static struct indirect_string_node
*
3866 find_AT_string_in_table (const char *str
, htab_t table
)
3868 struct indirect_string_node
*node
;
3871 slot
= htab_find_slot_with_hash (table
, str
,
3872 htab_hash_string (str
), INSERT
);
3875 node
= ggc_alloc_cleared_indirect_string_node ();
3876 node
->str
= ggc_strdup (str
);
3880 node
= (struct indirect_string_node
*) *slot
;
3886 /* Add STR to the indirect string hash table. */
3888 static struct indirect_string_node
*
3889 find_AT_string (const char *str
)
3891 if (! debug_str_hash
)
3892 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
3893 debug_str_eq
, NULL
);
3895 return find_AT_string_in_table (str
, debug_str_hash
);
3898 /* Add a string attribute value to a DIE. */
3901 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
3904 struct indirect_string_node
*node
;
3906 node
= find_AT_string (str
);
3908 attr
.dw_attr
= attr_kind
;
3909 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
3910 attr
.dw_attr_val
.val_entry
= NULL
;
3911 attr
.dw_attr_val
.v
.val_str
= node
;
3912 add_dwarf_attr (die
, &attr
);
3915 static inline const char *
3916 AT_string (dw_attr_ref a
)
3918 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
3919 return a
->dw_attr_val
.v
.val_str
->str
;
3922 /* Call this function directly to bypass AT_string_form's logic to put
3923 the string inline in the die. */
3926 set_indirect_string (struct indirect_string_node
*node
)
3929 /* Already indirect is a no op. */
3930 if (node
->form
== DW_FORM_strp
|| node
->form
== DW_FORM_GNU_str_index
)
3932 gcc_assert (node
->label
);
3935 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
3936 ++dw2_string_counter
;
3937 node
->label
= xstrdup (label
);
3939 if (!dwarf_split_debug_info
)
3941 node
->form
= DW_FORM_strp
;
3942 node
->index
= NOT_INDEXED
;
3946 node
->form
= DW_FORM_GNU_str_index
;
3947 node
->index
= NO_INDEX_ASSIGNED
;
3951 /* Find out whether a string should be output inline in DIE
3952 or out-of-line in .debug_str section. */
3954 static enum dwarf_form
3955 find_string_form (struct indirect_string_node
*node
)
3962 len
= strlen (node
->str
) + 1;
3964 /* If the string is shorter or equal to the size of the reference, it is
3965 always better to put it inline. */
3966 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
3967 return node
->form
= DW_FORM_string
;
3969 /* If we cannot expect the linker to merge strings in .debug_str
3970 section, only put it into .debug_str if it is worth even in this
3972 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
3973 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
3974 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
3975 return node
->form
= DW_FORM_string
;
3977 set_indirect_string (node
);
3982 /* Find out whether the string referenced from the attribute should be
3983 output inline in DIE or out-of-line in .debug_str section. */
3985 static enum dwarf_form
3986 AT_string_form (dw_attr_ref a
)
3988 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
3989 return find_string_form (a
->dw_attr_val
.v
.val_str
);
3992 /* Add a DIE reference attribute value to a DIE. */
3995 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
3999 #ifdef ENABLE_CHECKING
4000 gcc_assert (targ_die
!= NULL
);
4002 /* With LTO we can end up trying to reference something we didn't create
4003 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4004 if (targ_die
== NULL
)
4008 attr
.dw_attr
= attr_kind
;
4009 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4010 attr
.dw_attr_val
.val_entry
= NULL
;
4011 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4012 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4013 add_dwarf_attr (die
, &attr
);
4016 /* Change DIE reference REF to point to NEW_DIE instead. */
4019 change_AT_die_ref (dw_attr_ref ref
, dw_die_ref new_die
)
4021 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4022 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4023 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4026 /* Add an AT_specification attribute to a DIE, and also make the back
4027 pointer from the specification to the definition. */
4030 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4032 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4033 gcc_assert (!targ_die
->die_definition
);
4034 targ_die
->die_definition
= die
;
4037 static inline dw_die_ref
4038 AT_ref (dw_attr_ref a
)
4040 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4041 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4045 AT_ref_external (dw_attr_ref a
)
4047 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4048 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4054 set_AT_ref_external (dw_attr_ref a
, int i
)
4056 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4057 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4060 /* Add an FDE reference attribute value to a DIE. */
4063 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4067 attr
.dw_attr
= attr_kind
;
4068 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4069 attr
.dw_attr_val
.val_entry
= NULL
;
4070 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4071 add_dwarf_attr (die
, &attr
);
4074 /* Add a location description attribute value to a DIE. */
4077 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4081 attr
.dw_attr
= attr_kind
;
4082 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4083 attr
.dw_attr_val
.val_entry
= NULL
;
4084 attr
.dw_attr_val
.v
.val_loc
= loc
;
4085 add_dwarf_attr (die
, &attr
);
4088 static inline dw_loc_descr_ref
4089 AT_loc (dw_attr_ref a
)
4091 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4092 return a
->dw_attr_val
.v
.val_loc
;
4096 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4100 attr
.dw_attr
= attr_kind
;
4101 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4102 attr
.dw_attr_val
.val_entry
= NULL
;
4103 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4104 add_dwarf_attr (die
, &attr
);
4105 have_location_lists
= true;
4108 static inline dw_loc_list_ref
4109 AT_loc_list (dw_attr_ref a
)
4111 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4112 return a
->dw_attr_val
.v
.val_loc_list
;
4115 static inline dw_loc_list_ref
*
4116 AT_loc_list_ptr (dw_attr_ref a
)
4118 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4119 return &a
->dw_attr_val
.v
.val_loc_list
;
4122 /* Table of entries into the .debug_addr section. */
4124 static GTY ((param_is (addr_table_entry
))) htab_t addr_index_table
;
4126 /* Hash an address_table_entry. */
4129 addr_table_entry_do_hash (const void *x
)
4131 const addr_table_entry
*a
= (const addr_table_entry
*) x
;
4135 return iterative_hash_rtx (a
->addr
.rtl
, 0);
4136 case ate_kind_rtx_dtprel
:
4137 return iterative_hash_rtx (a
->addr
.rtl
, 1);
4138 case ate_kind_label
:
4139 return htab_hash_string (a
->addr
.label
);
4145 /* Determine equality for two address_table_entries. */
4148 addr_table_entry_eq (const void *x1
, const void *x2
)
4150 const addr_table_entry
*a1
= (const addr_table_entry
*) x1
;
4151 const addr_table_entry
*a2
= (const addr_table_entry
*) x2
;
4153 if (a1
->kind
!= a2
->kind
)
4158 case ate_kind_rtx_dtprel
:
4159 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4160 case ate_kind_label
:
4161 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
4167 /* Initialize an addr_table_entry. */
4170 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
4176 case ate_kind_rtx_dtprel
:
4177 e
->addr
.rtl
= (rtx
) addr
;
4179 case ate_kind_label
:
4180 e
->addr
.label
= (char *) addr
;
4184 e
->index
= NO_INDEX_ASSIGNED
;
4187 /* Add attr to the address table entry to the table. Defer setting an
4188 index until output time. */
4190 static addr_table_entry
*
4191 add_addr_table_entry (void *addr
, enum ate_kind kind
)
4193 addr_table_entry
*node
;
4194 addr_table_entry finder
;
4197 gcc_assert (dwarf_split_debug_info
);
4198 if (! addr_index_table
)
4199 addr_index_table
= htab_create_ggc (10, addr_table_entry_do_hash
,
4200 addr_table_entry_eq
, NULL
);
4201 init_addr_table_entry (&finder
, kind
, addr
);
4202 slot
= htab_find_slot (addr_index_table
, &finder
, INSERT
);
4204 if (*slot
== HTAB_EMPTY_ENTRY
)
4206 node
= ggc_alloc_cleared_addr_table_entry ();
4207 init_addr_table_entry (node
, kind
, addr
);
4211 node
= (addr_table_entry
*) *slot
;
4217 /* Remove an entry from the addr table by decrementing its refcount.
4218 Strictly, decrementing the refcount would be enough, but the
4219 assertion that the entry is actually in the table has found
4223 remove_addr_table_entry (addr_table_entry
*entry
)
4225 addr_table_entry
*node
;
4227 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
4228 node
= (addr_table_entry
*) htab_find (addr_index_table
, entry
);
4229 /* After an index is assigned, the table is frozen. */
4230 gcc_assert (node
->refcount
> 0 && node
->index
== NO_INDEX_ASSIGNED
);
4234 /* Given a location list, remove all addresses it refers to from the
4238 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
4240 for (; descr
; descr
= descr
->dw_loc_next
)
4241 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
4243 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
4244 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
4248 /* A helper function for dwarf2out_finish called through
4249 htab_traverse. Assign an addr_table_entry its index. All entries
4250 must be collected into the table when this function is called,
4251 because the indexing code relies on htab_traverse to traverse nodes
4252 in the same order for each run. */
4255 index_addr_table_entry (void **h
, void *v
)
4257 addr_table_entry
*node
= (addr_table_entry
*) *h
;
4258 unsigned int *index
= (unsigned int *) v
;
4260 /* Don't index unreferenced nodes. */
4261 if (node
->refcount
== 0)
4264 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
4265 node
->index
= *index
;
4271 /* Add an address constant attribute value to a DIE. When using
4272 dwarf_split_debug_info, address attributes in dies destined for the
4273 final executable should be direct references--setting the parameter
4274 force_direct ensures this behavior. */
4277 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
4282 attr
.dw_attr
= attr_kind
;
4283 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
4284 attr
.dw_attr_val
.v
.val_addr
= addr
;
4285 if (dwarf_split_debug_info
&& !force_direct
)
4286 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
4288 attr
.dw_attr_val
.val_entry
= NULL
;
4289 add_dwarf_attr (die
, &attr
);
4292 /* Get the RTX from to an address DIE attribute. */
4295 AT_addr (dw_attr_ref a
)
4297 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
4298 return a
->dw_attr_val
.v
.val_addr
;
4301 /* Add a file attribute value to a DIE. */
4304 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4305 struct dwarf_file_data
*fd
)
4309 attr
.dw_attr
= attr_kind
;
4310 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
4311 attr
.dw_attr_val
.val_entry
= NULL
;
4312 attr
.dw_attr_val
.v
.val_file
= fd
;
4313 add_dwarf_attr (die
, &attr
);
4316 /* Get the dwarf_file_data from a file DIE attribute. */
4318 static inline struct dwarf_file_data
*
4319 AT_file (dw_attr_ref a
)
4321 gcc_assert (a
&& AT_class (a
) == dw_val_class_file
);
4322 return a
->dw_attr_val
.v
.val_file
;
4325 /* Add a vms delta attribute value to a DIE. */
4328 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4329 const char *lbl1
, const char *lbl2
)
4333 attr
.dw_attr
= attr_kind
;
4334 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
4335 attr
.dw_attr_val
.val_entry
= NULL
;
4336 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
4337 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
4338 add_dwarf_attr (die
, &attr
);
4341 /* Add a label identifier attribute value to a DIE. */
4344 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4349 attr
.dw_attr
= attr_kind
;
4350 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4351 attr
.dw_attr_val
.val_entry
= NULL
;
4352 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4353 if (dwarf_split_debug_info
)
4354 attr
.dw_attr_val
.val_entry
4355 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
4357 add_dwarf_attr (die
, &attr
);
4360 /* Add a section offset attribute value to a DIE, an offset into the
4361 debug_line section. */
4364 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4369 attr
.dw_attr
= attr_kind
;
4370 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
4371 attr
.dw_attr_val
.val_entry
= NULL
;
4372 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4373 add_dwarf_attr (die
, &attr
);
4376 /* Add a section offset attribute value to a DIE, an offset into the
4377 debug_macinfo section. */
4380 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4385 attr
.dw_attr
= attr_kind
;
4386 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
4387 attr
.dw_attr_val
.val_entry
= NULL
;
4388 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4389 add_dwarf_attr (die
, &attr
);
4392 /* Add an offset attribute value to a DIE. */
4395 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4396 unsigned HOST_WIDE_INT offset
)
4400 attr
.dw_attr
= attr_kind
;
4401 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
4402 attr
.dw_attr_val
.val_entry
= NULL
;
4403 attr
.dw_attr_val
.v
.val_offset
= offset
;
4404 add_dwarf_attr (die
, &attr
);
4407 /* Add a range_list attribute value to a DIE. When using
4408 dwarf_split_debug_info, address attributes in dies destined for the
4409 final executable should be direct references--setting the parameter
4410 force_direct ensures this behavior. */
4412 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4413 #define RELOCATED_OFFSET (NULL)
4416 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4417 long unsigned int offset
, bool force_direct
)
4421 attr
.dw_attr
= attr_kind
;
4422 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
4423 /* For the range_list attribute, use val_entry to store whether the
4424 offset should follow split-debug-info or normal semantics. This
4425 value is read in output_range_list_offset. */
4426 if (dwarf_split_debug_info
&& !force_direct
)
4427 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
4429 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
4430 attr
.dw_attr_val
.v
.val_offset
= offset
;
4431 add_dwarf_attr (die
, &attr
);
4434 /* Return the start label of a delta attribute. */
4436 static inline const char *
4437 AT_vms_delta1 (dw_attr_ref a
)
4439 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4440 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
4443 /* Return the end label of a delta attribute. */
4445 static inline const char *
4446 AT_vms_delta2 (dw_attr_ref a
)
4448 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4449 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
4452 static inline const char *
4453 AT_lbl (dw_attr_ref a
)
4455 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
4456 || AT_class (a
) == dw_val_class_lineptr
4457 || AT_class (a
) == dw_val_class_macptr
4458 || AT_class (a
) == dw_val_class_high_pc
));
4459 return a
->dw_attr_val
.v
.val_lbl_id
;
4462 /* Get the attribute of type attr_kind. */
4465 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4469 dw_die_ref spec
= NULL
;
4474 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4475 if (a
->dw_attr
== attr_kind
)
4477 else if (a
->dw_attr
== DW_AT_specification
4478 || a
->dw_attr
== DW_AT_abstract_origin
)
4482 return get_AT (spec
, attr_kind
);
4487 /* Returns the parent of the declaration of DIE. */
4490 get_die_parent (dw_die_ref die
)
4497 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
4498 || (t
= get_AT_ref (die
, DW_AT_specification
)))
4501 return die
->die_parent
;
4504 /* Return the "low pc" attribute value, typically associated with a subprogram
4505 DIE. Return null if the "low pc" attribute is either not present, or if it
4506 cannot be represented as an assembler label identifier. */
4508 static inline const char *
4509 get_AT_low_pc (dw_die_ref die
)
4511 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
4513 return a
? AT_lbl (a
) : NULL
;
4516 /* Return the "high pc" attribute value, typically associated with a subprogram
4517 DIE. Return null if the "high pc" attribute is either not present, or if it
4518 cannot be represented as an assembler label identifier. */
4520 static inline const char *
4521 get_AT_hi_pc (dw_die_ref die
)
4523 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
4525 return a
? AT_lbl (a
) : NULL
;
4528 /* Return the value of the string attribute designated by ATTR_KIND, or
4529 NULL if it is not present. */
4531 static inline const char *
4532 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4534 dw_attr_ref a
= get_AT (die
, attr_kind
);
4536 return a
? AT_string (a
) : NULL
;
4539 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4540 if it is not present. */
4543 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4545 dw_attr_ref a
= get_AT (die
, attr_kind
);
4547 return a
? AT_flag (a
) : 0;
4550 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4551 if it is not present. */
4553 static inline unsigned
4554 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4556 dw_attr_ref a
= get_AT (die
, attr_kind
);
4558 return a
? AT_unsigned (a
) : 0;
4561 static inline dw_die_ref
4562 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4564 dw_attr_ref a
= get_AT (die
, attr_kind
);
4566 return a
? AT_ref (a
) : NULL
;
4569 static inline struct dwarf_file_data
*
4570 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4572 dw_attr_ref a
= get_AT (die
, attr_kind
);
4574 return a
? AT_file (a
) : NULL
;
4577 /* Return TRUE if the language is C++. */
4582 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4584 return lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
;
4587 /* Return TRUE if the language is Java. */
4592 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4594 return lang
== DW_LANG_Java
;
4597 /* Return TRUE if the language is Fortran. */
4602 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4604 return (lang
== DW_LANG_Fortran77
4605 || lang
== DW_LANG_Fortran90
4606 || lang
== DW_LANG_Fortran95
);
4609 /* Return TRUE if the language is Ada. */
4614 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4616 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
4619 /* Remove the specified attribute if present. */
4622 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4630 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4631 if (a
->dw_attr
== attr_kind
)
4633 if (AT_class (a
) == dw_val_class_str
)
4634 if (a
->dw_attr_val
.v
.val_str
->refcount
)
4635 a
->dw_attr_val
.v
.val_str
->refcount
--;
4637 /* vec::ordered_remove should help reduce the number of abbrevs
4639 die
->die_attr
->ordered_remove (ix
);
4644 /* Remove CHILD from its parent. PREV must have the property that
4645 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4648 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
4650 gcc_assert (child
->die_parent
== prev
->die_parent
);
4651 gcc_assert (prev
->die_sib
== child
);
4654 gcc_assert (child
->die_parent
->die_child
== child
);
4658 prev
->die_sib
= child
->die_sib
;
4659 if (child
->die_parent
->die_child
== child
)
4660 child
->die_parent
->die_child
= prev
;
4663 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4664 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4667 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
4669 dw_die_ref parent
= old_child
->die_parent
;
4671 gcc_assert (parent
== prev
->die_parent
);
4672 gcc_assert (prev
->die_sib
== old_child
);
4674 new_child
->die_parent
= parent
;
4675 if (prev
== old_child
)
4677 gcc_assert (parent
->die_child
== old_child
);
4678 new_child
->die_sib
= new_child
;
4682 prev
->die_sib
= new_child
;
4683 new_child
->die_sib
= old_child
->die_sib
;
4685 if (old_child
->die_parent
->die_child
== old_child
)
4686 old_child
->die_parent
->die_child
= new_child
;
4689 /* Move all children from OLD_PARENT to NEW_PARENT. */
4692 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
4695 new_parent
->die_child
= old_parent
->die_child
;
4696 old_parent
->die_child
= NULL
;
4697 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
4700 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4704 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
4710 dw_die_ref prev
= c
;
4712 while (c
->die_tag
== tag
)
4714 remove_child_with_prev (c
, prev
);
4715 /* Might have removed every child. */
4716 if (c
== c
->die_sib
)
4720 } while (c
!= die
->die_child
);
4723 /* Add a CHILD_DIE as the last child of DIE. */
4726 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
4728 /* FIXME this should probably be an assert. */
4729 if (! die
|| ! child_die
)
4731 gcc_assert (die
!= child_die
);
4733 child_die
->die_parent
= die
;
4736 child_die
->die_sib
= die
->die_child
->die_sib
;
4737 die
->die_child
->die_sib
= child_die
;
4740 child_die
->die_sib
= child_die
;
4741 die
->die_child
= child_die
;
4744 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4745 is the specification, to the end of PARENT's list of children.
4746 This is done by removing and re-adding it. */
4749 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
4753 /* We want the declaration DIE from inside the class, not the
4754 specification DIE at toplevel. */
4755 if (child
->die_parent
!= parent
)
4757 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
4763 gcc_assert (child
->die_parent
== parent
4764 || (child
->die_parent
4765 == get_AT_ref (parent
, DW_AT_specification
)));
4767 for (p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
4768 if (p
->die_sib
== child
)
4770 remove_child_with_prev (child
, p
);
4774 add_child_die (parent
, child
);
4777 /* Return a pointer to a newly created DIE node. */
4779 static inline dw_die_ref
4780 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
4782 dw_die_ref die
= ggc_alloc_cleared_die_node ();
4784 die
->die_tag
= tag_value
;
4786 if (parent_die
!= NULL
)
4787 add_child_die (parent_die
, die
);
4790 limbo_die_node
*limbo_node
;
4792 limbo_node
= ggc_alloc_cleared_limbo_die_node ();
4793 limbo_node
->die
= die
;
4794 limbo_node
->created_for
= t
;
4795 limbo_node
->next
= limbo_die_list
;
4796 limbo_die_list
= limbo_node
;
4802 /* Return the DIE associated with the given type specifier. */
4804 static inline dw_die_ref
4805 lookup_type_die (tree type
)
4807 return TYPE_SYMTAB_DIE (type
);
4810 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
4811 anonymous type named by the typedef TYPE_DIE, return the DIE of the
4812 anonymous type instead the one of the naming typedef. */
4814 static inline dw_die_ref
4815 strip_naming_typedef (tree type
, dw_die_ref type_die
)
4818 && TREE_CODE (type
) == RECORD_TYPE
4820 && type_die
->die_tag
== DW_TAG_typedef
4821 && is_naming_typedef_decl (TYPE_NAME (type
)))
4822 type_die
= get_AT_ref (type_die
, DW_AT_type
);
4826 /* Like lookup_type_die, but if type is an anonymous type named by a
4827 typedef[1], return the DIE of the anonymous type instead the one of
4828 the naming typedef. This is because in gen_typedef_die, we did
4829 equate the anonymous struct named by the typedef with the DIE of
4830 the naming typedef. So by default, lookup_type_die on an anonymous
4831 struct yields the DIE of the naming typedef.
4833 [1]: Read the comment of is_naming_typedef_decl to learn about what
4834 a naming typedef is. */
4836 static inline dw_die_ref
4837 lookup_type_die_strip_naming_typedef (tree type
)
4839 dw_die_ref die
= lookup_type_die (type
);
4840 return strip_naming_typedef (type
, die
);
4843 /* Equate a DIE to a given type specifier. */
4846 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
4848 TYPE_SYMTAB_DIE (type
) = type_die
;
4851 /* Returns a hash value for X (which really is a die_struct). */
4854 decl_die_table_hash (const void *x
)
4856 return (hashval_t
) ((const_dw_die_ref
) x
)->decl_id
;
4859 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
4862 decl_die_table_eq (const void *x
, const void *y
)
4864 return (((const_dw_die_ref
) x
)->decl_id
== DECL_UID ((const_tree
) y
));
4867 /* Return the DIE associated with a given declaration. */
4869 static inline dw_die_ref
4870 lookup_decl_die (tree decl
)
4872 return (dw_die_ref
) htab_find_with_hash (decl_die_table
, decl
, DECL_UID (decl
));
4875 /* Returns a hash value for X (which really is a var_loc_list). */
4878 decl_loc_table_hash (const void *x
)
4880 return (hashval_t
) ((const var_loc_list
*) x
)->decl_id
;
4883 /* Return nonzero if decl_id of var_loc_list X is the same as
4887 decl_loc_table_eq (const void *x
, const void *y
)
4889 return (((const var_loc_list
*) x
)->decl_id
== DECL_UID ((const_tree
) y
));
4892 /* Return the var_loc list associated with a given declaration. */
4894 static inline var_loc_list
*
4895 lookup_decl_loc (const_tree decl
)
4897 if (!decl_loc_table
)
4899 return (var_loc_list
*)
4900 htab_find_with_hash (decl_loc_table
, decl
, DECL_UID (decl
));
4903 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
4906 cached_dw_loc_list_table_hash (const void *x
)
4908 return (hashval_t
) ((const cached_dw_loc_list
*) x
)->decl_id
;
4911 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
4915 cached_dw_loc_list_table_eq (const void *x
, const void *y
)
4917 return (((const cached_dw_loc_list
*) x
)->decl_id
4918 == DECL_UID ((const_tree
) y
));
4921 /* Equate a DIE to a particular declaration. */
4924 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
4926 unsigned int decl_id
= DECL_UID (decl
);
4929 slot
= htab_find_slot_with_hash (decl_die_table
, decl
, decl_id
, INSERT
);
4931 decl_die
->decl_id
= decl_id
;
4934 /* Return how many bits covers PIECE EXPR_LIST. */
4937 decl_piece_bitsize (rtx piece
)
4939 int ret
= (int) GET_MODE (piece
);
4942 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
4943 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
4944 return INTVAL (XEXP (XEXP (piece
, 0), 0));
4947 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
4950 decl_piece_varloc_ptr (rtx piece
)
4952 if ((int) GET_MODE (piece
))
4953 return &XEXP (piece
, 0);
4955 return &XEXP (XEXP (piece
, 0), 1);
4958 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
4959 Next is the chain of following piece nodes. */
4962 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
4964 if (bitsize
<= (int) MAX_MACHINE_MODE
)
4965 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
4967 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
4972 /* Return rtx that should be stored into loc field for
4973 LOC_NOTE and BITPOS/BITSIZE. */
4976 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
4977 HOST_WIDE_INT bitsize
)
4981 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
4983 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
4988 /* This function either modifies location piece list *DEST in
4989 place (if SRC and INNER is NULL), or copies location piece list
4990 *SRC to *DEST while modifying it. Location BITPOS is modified
4991 to contain LOC_NOTE, any pieces overlapping it are removed resp.
4992 not copied and if needed some padding around it is added.
4993 When modifying in place, DEST should point to EXPR_LIST where
4994 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
4995 to the start of the whole list and INNER points to the EXPR_LIST
4996 where earlier pieces cover PIECE_BITPOS bits. */
4999 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
5000 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
5001 HOST_WIDE_INT bitsize
, rtx loc_note
)
5004 bool copy
= inner
!= NULL
;
5008 /* First copy all nodes preceding the current bitpos. */
5009 while (src
!= inner
)
5011 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5012 decl_piece_bitsize (*src
), NULL_RTX
);
5013 dest
= &XEXP (*dest
, 1);
5014 src
= &XEXP (*src
, 1);
5017 /* Add padding if needed. */
5018 if (bitpos
!= piece_bitpos
)
5020 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
5021 copy
? NULL_RTX
: *dest
);
5022 dest
= &XEXP (*dest
, 1);
5024 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
5027 /* A piece with correct bitpos and bitsize already exist,
5028 just update the location for it and return. */
5029 *decl_piece_varloc_ptr (*dest
) = loc_note
;
5032 /* Add the piece that changed. */
5033 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
5034 dest
= &XEXP (*dest
, 1);
5035 /* Skip over pieces that overlap it. */
5036 diff
= bitpos
- piece_bitpos
+ bitsize
;
5039 while (diff
> 0 && *src
)
5042 diff
-= decl_piece_bitsize (piece
);
5044 src
= &XEXP (piece
, 1);
5047 *src
= XEXP (piece
, 1);
5048 free_EXPR_LIST_node (piece
);
5051 /* Add padding if needed. */
5052 if (diff
< 0 && *src
)
5056 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
5057 dest
= &XEXP (*dest
, 1);
5061 /* Finally copy all nodes following it. */
5064 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5065 decl_piece_bitsize (*src
), NULL_RTX
);
5066 dest
= &XEXP (*dest
, 1);
5067 src
= &XEXP (*src
, 1);
5071 /* Add a variable location node to the linked list for DECL. */
5073 static struct var_loc_node
*
5074 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
)
5076 unsigned int decl_id
;
5079 struct var_loc_node
*loc
= NULL
;
5080 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
5082 if (TREE_CODE (decl
) == VAR_DECL
5083 && DECL_HAS_DEBUG_EXPR_P (decl
))
5085 tree realdecl
= DECL_DEBUG_EXPR (decl
);
5086 if (handled_component_p (realdecl
)
5087 || (TREE_CODE (realdecl
) == MEM_REF
5088 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5090 HOST_WIDE_INT maxsize
;
5093 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
, &maxsize
);
5094 if (!DECL_P (innerdecl
)
5095 || DECL_IGNORED_P (innerdecl
)
5096 || TREE_STATIC (innerdecl
)
5098 || bitpos
+ bitsize
> 256
5099 || bitsize
!= maxsize
)
5105 decl_id
= DECL_UID (decl
);
5106 slot
= htab_find_slot_with_hash (decl_loc_table
, decl
, decl_id
, INSERT
);
5109 temp
= ggc_alloc_cleared_var_loc_list ();
5110 temp
->decl_id
= decl_id
;
5114 temp
= (var_loc_list
*) *slot
;
5116 /* For PARM_DECLs try to keep around the original incoming value,
5117 even if that means we'll emit a zero-range .debug_loc entry. */
5119 && temp
->first
== temp
->last
5120 && TREE_CODE (decl
) == PARM_DECL
5121 && NOTE_P (temp
->first
->loc
)
5122 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
5123 && DECL_INCOMING_RTL (decl
)
5124 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
5125 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
5126 == GET_CODE (DECL_INCOMING_RTL (decl
))
5127 && prev_real_insn (temp
->first
->loc
) == NULL_RTX
5129 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
5130 NOTE_VAR_LOCATION_LOC (loc_note
))
5131 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
5132 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
5134 loc
= ggc_alloc_cleared_var_loc_node ();
5135 temp
->first
->next
= loc
;
5137 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5139 else if (temp
->last
)
5141 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
5142 rtx
*piece_loc
= NULL
, last_loc_note
;
5143 int piece_bitpos
= 0;
5147 gcc_assert (last
->next
== NULL
);
5149 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
5151 piece_loc
= &last
->loc
;
5154 int cur_bitsize
= decl_piece_bitsize (*piece_loc
);
5155 if (piece_bitpos
+ cur_bitsize
> bitpos
)
5157 piece_bitpos
+= cur_bitsize
;
5158 piece_loc
= &XEXP (*piece_loc
, 1);
5162 /* TEMP->LAST here is either pointer to the last but one or
5163 last element in the chained list, LAST is pointer to the
5165 if (label
&& strcmp (last
->label
, label
) == 0)
5167 /* For SRA optimized variables if there weren't any real
5168 insns since last note, just modify the last node. */
5169 if (piece_loc
!= NULL
)
5171 adjust_piece_list (piece_loc
, NULL
, NULL
,
5172 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5175 /* If the last note doesn't cover any instructions, remove it. */
5176 if (temp
->last
!= last
)
5178 temp
->last
->next
= NULL
;
5181 gcc_assert (strcmp (last
->label
, label
) != 0);
5185 gcc_assert (temp
->first
== temp
->last
5186 || (temp
->first
->next
== temp
->last
5187 && TREE_CODE (decl
) == PARM_DECL
));
5188 memset (temp
->last
, '\0', sizeof (*temp
->last
));
5189 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5193 if (bitsize
== -1 && NOTE_P (last
->loc
))
5194 last_loc_note
= last
->loc
;
5195 else if (piece_loc
!= NULL
5196 && *piece_loc
!= NULL_RTX
5197 && piece_bitpos
== bitpos
5198 && decl_piece_bitsize (*piece_loc
) == bitsize
)
5199 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
5201 last_loc_note
= NULL_RTX
;
5202 /* If the current location is the same as the end of the list,
5203 and either both or neither of the locations is uninitialized,
5204 we have nothing to do. */
5205 if (last_loc_note
== NULL_RTX
5206 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
5207 NOTE_VAR_LOCATION_LOC (loc_note
)))
5208 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5209 != NOTE_VAR_LOCATION_STATUS (loc_note
))
5210 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5211 == VAR_INIT_STATUS_UNINITIALIZED
)
5212 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
5213 == VAR_INIT_STATUS_UNINITIALIZED
))))
5215 /* Add LOC to the end of list and update LAST. If the last
5216 element of the list has been removed above, reuse its
5217 memory for the new node, otherwise allocate a new one. */
5221 memset (loc
, '\0', sizeof (*loc
));
5224 loc
= ggc_alloc_cleared_var_loc_node ();
5225 if (bitsize
== -1 || piece_loc
== NULL
)
5226 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5228 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
5229 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5231 /* Ensure TEMP->LAST will point either to the new last but one
5232 element of the chain, or to the last element in it. */
5233 if (last
!= temp
->last
)
5241 loc
= ggc_alloc_cleared_var_loc_node ();
5244 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5249 /* Keep track of the number of spaces used to indent the
5250 output of the debugging routines that print the structure of
5251 the DIE internal representation. */
5252 static int print_indent
;
5254 /* Indent the line the number of spaces given by print_indent. */
5257 print_spaces (FILE *outfile
)
5259 fprintf (outfile
, "%*s", print_indent
, "");
5262 /* Print a type signature in hex. */
5265 print_signature (FILE *outfile
, char *sig
)
5269 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
5270 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
5273 /* Print the information associated with a given DIE, and its children.
5274 This routine is a debugging aid only. */
5277 print_die (dw_die_ref die
, FILE *outfile
)
5283 print_spaces (outfile
);
5284 fprintf (outfile
, "DIE %4ld: %s (%p)\n",
5285 die
->die_offset
, dwarf_tag_name (die
->die_tag
),
5287 print_spaces (outfile
);
5288 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
5289 fprintf (outfile
, " offset: %ld", die
->die_offset
);
5290 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
5292 if (die
->comdat_type_p
)
5294 print_spaces (outfile
);
5295 fprintf (outfile
, " signature: ");
5296 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
5297 fprintf (outfile
, "\n");
5300 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5302 print_spaces (outfile
);
5303 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
5305 switch (AT_class (a
))
5307 case dw_val_class_addr
:
5308 fprintf (outfile
, "address");
5310 case dw_val_class_offset
:
5311 fprintf (outfile
, "offset");
5313 case dw_val_class_loc
:
5314 fprintf (outfile
, "location descriptor");
5316 case dw_val_class_loc_list
:
5317 fprintf (outfile
, "location list -> label:%s",
5318 AT_loc_list (a
)->ll_symbol
);
5320 case dw_val_class_range_list
:
5321 fprintf (outfile
, "range list");
5323 case dw_val_class_const
:
5324 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
5326 case dw_val_class_unsigned_const
:
5327 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
5329 case dw_val_class_const_double
:
5330 fprintf (outfile
, "constant ("HOST_WIDE_INT_PRINT_DEC
","\
5331 HOST_WIDE_INT_PRINT_UNSIGNED
")",
5332 a
->dw_attr_val
.v
.val_double
.high
,
5333 a
->dw_attr_val
.v
.val_double
.low
);
5335 case dw_val_class_vec
:
5336 fprintf (outfile
, "floating-point or vector constant");
5338 case dw_val_class_flag
:
5339 fprintf (outfile
, "%u", AT_flag (a
));
5341 case dw_val_class_die_ref
:
5342 if (AT_ref (a
) != NULL
)
5344 if (AT_ref (a
)->comdat_type_p
)
5346 fprintf (outfile
, "die -> signature: ");
5347 print_signature (outfile
,
5348 AT_ref (a
)->die_id
.die_type_node
->signature
);
5350 else if (AT_ref (a
)->die_id
.die_symbol
)
5351 fprintf (outfile
, "die -> label: %s",
5352 AT_ref (a
)->die_id
.die_symbol
);
5354 fprintf (outfile
, "die -> %ld", AT_ref (a
)->die_offset
);
5355 fprintf (outfile
, " (%p)", (void *) AT_ref (a
));
5358 fprintf (outfile
, "die -> <null>");
5360 case dw_val_class_vms_delta
:
5361 fprintf (outfile
, "delta: @slotcount(%s-%s)",
5362 AT_vms_delta2 (a
), AT_vms_delta1 (a
));
5364 case dw_val_class_lbl_id
:
5365 case dw_val_class_lineptr
:
5366 case dw_val_class_macptr
:
5367 case dw_val_class_high_pc
:
5368 fprintf (outfile
, "label: %s", AT_lbl (a
));
5370 case dw_val_class_str
:
5371 if (AT_string (a
) != NULL
)
5372 fprintf (outfile
, "\"%s\"", AT_string (a
));
5374 fprintf (outfile
, "<null>");
5376 case dw_val_class_file
:
5377 fprintf (outfile
, "\"%s\" (%d)", AT_file (a
)->filename
,
5378 AT_file (a
)->emitted_number
);
5380 case dw_val_class_data8
:
5384 for (i
= 0; i
< 8; i
++)
5385 fprintf (outfile
, "%02x", a
->dw_attr_val
.v
.val_data8
[i
]);
5392 fprintf (outfile
, "\n");
5395 if (die
->die_child
!= NULL
)
5398 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
5401 if (print_indent
== 0)
5402 fprintf (outfile
, "\n");
5405 /* Print the information collected for a given DIE. */
5408 debug_dwarf_die (dw_die_ref die
)
5410 print_die (die
, stderr
);
5414 debug (die_struct
&ref
)
5416 print_die (&ref
, stderr
);
5420 debug (die_struct
*ptr
)
5425 fprintf (stderr
, "<nil>\n");
5429 /* Print all DWARF information collected for the compilation unit.
5430 This routine is a debugging aid only. */
5436 print_die (comp_unit_die (), stderr
);
5439 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5440 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5441 DIE that marks the start of the DIEs for this include file. */
5444 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
5446 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
5447 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
5449 new_unit
->die_sib
= old_unit
;
5453 /* Close an include-file CU and reopen the enclosing one. */
5456 pop_compile_unit (dw_die_ref old_unit
)
5458 dw_die_ref new_unit
= old_unit
->die_sib
;
5460 old_unit
->die_sib
= NULL
;
5464 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5465 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5466 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5468 /* Calculate the checksum of a location expression. */
5471 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5476 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
5478 hash
= hash_loc_operands (loc
, hash
);
5482 /* Calculate the checksum of an attribute. */
5485 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
5487 dw_loc_descr_ref loc
;
5490 CHECKSUM (at
->dw_attr
);
5492 /* We don't care that this was compiled with a different compiler
5493 snapshot; if the output is the same, that's what matters. */
5494 if (at
->dw_attr
== DW_AT_producer
)
5497 switch (AT_class (at
))
5499 case dw_val_class_const
:
5500 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
5502 case dw_val_class_unsigned_const
:
5503 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
5505 case dw_val_class_const_double
:
5506 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
5508 case dw_val_class_vec
:
5509 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
5510 (at
->dw_attr_val
.v
.val_vec
.length
5511 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
5513 case dw_val_class_flag
:
5514 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
5516 case dw_val_class_str
:
5517 CHECKSUM_STRING (AT_string (at
));
5520 case dw_val_class_addr
:
5522 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5523 CHECKSUM_STRING (XSTR (r
, 0));
5526 case dw_val_class_offset
:
5527 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
5530 case dw_val_class_loc
:
5531 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5532 loc_checksum (loc
, ctx
);
5535 case dw_val_class_die_ref
:
5536 die_checksum (AT_ref (at
), ctx
, mark
);
5539 case dw_val_class_fde_ref
:
5540 case dw_val_class_vms_delta
:
5541 case dw_val_class_lbl_id
:
5542 case dw_val_class_lineptr
:
5543 case dw_val_class_macptr
:
5544 case dw_val_class_high_pc
:
5547 case dw_val_class_file
:
5548 CHECKSUM_STRING (AT_file (at
)->filename
);
5551 case dw_val_class_data8
:
5552 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
5560 /* Calculate the checksum of a DIE. */
5563 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
5569 /* To avoid infinite recursion. */
5572 CHECKSUM (die
->die_mark
);
5575 die
->die_mark
= ++(*mark
);
5577 CHECKSUM (die
->die_tag
);
5579 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5580 attr_checksum (a
, ctx
, mark
);
5582 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
5586 #undef CHECKSUM_BLOCK
5587 #undef CHECKSUM_STRING
5589 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
5590 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5591 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5592 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
5593 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
5594 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
5595 #define CHECKSUM_ATTR(FOO) \
5596 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
5598 /* Calculate the checksum of a number in signed LEB128 format. */
5601 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
5608 byte
= (value
& 0x7f);
5610 more
= !((value
== 0 && (byte
& 0x40) == 0)
5611 || (value
== -1 && (byte
& 0x40) != 0));
5620 /* Calculate the checksum of a number in unsigned LEB128 format. */
5623 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
5627 unsigned char byte
= (value
& 0x7f);
5630 /* More bytes to follow. */
5638 /* Checksum the context of the DIE. This adds the names of any
5639 surrounding namespaces or structures to the checksum. */
5642 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
5646 int tag
= die
->die_tag
;
5648 if (tag
!= DW_TAG_namespace
5649 && tag
!= DW_TAG_structure_type
5650 && tag
!= DW_TAG_class_type
)
5653 name
= get_AT_string (die
, DW_AT_name
);
5655 spec
= get_AT_ref (die
, DW_AT_specification
);
5659 if (die
->die_parent
!= NULL
)
5660 checksum_die_context (die
->die_parent
, ctx
);
5662 CHECKSUM_ULEB128 ('C');
5663 CHECKSUM_ULEB128 (tag
);
5665 CHECKSUM_STRING (name
);
5668 /* Calculate the checksum of a location expression. */
5671 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5673 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
5674 were emitted as a DW_FORM_sdata instead of a location expression. */
5675 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
5677 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5678 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
5682 /* Otherwise, just checksum the raw location expression. */
5687 CHECKSUM_ULEB128 (loc
->dtprel
);
5688 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
5689 hash
= hash_loc_operands (loc
, hash
);
5691 loc
= loc
->dw_loc_next
;
5695 /* Calculate the checksum of an attribute. */
5698 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_ref at
,
5699 struct md5_ctx
*ctx
, int *mark
)
5701 dw_loc_descr_ref loc
;
5704 if (AT_class (at
) == dw_val_class_die_ref
)
5706 dw_die_ref target_die
= AT_ref (at
);
5708 /* For pointer and reference types, we checksum only the (qualified)
5709 name of the target type (if there is a name). For friend entries,
5710 we checksum only the (qualified) name of the target type or function.
5711 This allows the checksum to remain the same whether the target type
5712 is complete or not. */
5713 if ((at
->dw_attr
== DW_AT_type
5714 && (tag
== DW_TAG_pointer_type
5715 || tag
== DW_TAG_reference_type
5716 || tag
== DW_TAG_rvalue_reference_type
5717 || tag
== DW_TAG_ptr_to_member_type
))
5718 || (at
->dw_attr
== DW_AT_friend
5719 && tag
== DW_TAG_friend
))
5721 dw_attr_ref name_attr
= get_AT (target_die
, DW_AT_name
);
5723 if (name_attr
!= NULL
)
5725 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
5729 CHECKSUM_ULEB128 ('N');
5730 CHECKSUM_ULEB128 (at
->dw_attr
);
5731 if (decl
->die_parent
!= NULL
)
5732 checksum_die_context (decl
->die_parent
, ctx
);
5733 CHECKSUM_ULEB128 ('E');
5734 CHECKSUM_STRING (AT_string (name_attr
));
5739 /* For all other references to another DIE, we check to see if the
5740 target DIE has already been visited. If it has, we emit a
5741 backward reference; if not, we descend recursively. */
5742 if (target_die
->die_mark
> 0)
5744 CHECKSUM_ULEB128 ('R');
5745 CHECKSUM_ULEB128 (at
->dw_attr
);
5746 CHECKSUM_ULEB128 (target_die
->die_mark
);
5750 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
5754 target_die
->die_mark
= ++(*mark
);
5755 CHECKSUM_ULEB128 ('T');
5756 CHECKSUM_ULEB128 (at
->dw_attr
);
5757 if (decl
->die_parent
!= NULL
)
5758 checksum_die_context (decl
->die_parent
, ctx
);
5759 die_checksum_ordered (target_die
, ctx
, mark
);
5764 CHECKSUM_ULEB128 ('A');
5765 CHECKSUM_ULEB128 (at
->dw_attr
);
5767 switch (AT_class (at
))
5769 case dw_val_class_const
:
5770 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5771 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
5774 case dw_val_class_unsigned_const
:
5775 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5776 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
5779 case dw_val_class_const_double
:
5780 CHECKSUM_ULEB128 (DW_FORM_block
);
5781 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
5782 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
5785 case dw_val_class_vec
:
5786 CHECKSUM_ULEB128 (DW_FORM_block
);
5787 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
5788 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
5789 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
5790 (at
->dw_attr_val
.v
.val_vec
.length
5791 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
5794 case dw_val_class_flag
:
5795 CHECKSUM_ULEB128 (DW_FORM_flag
);
5796 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
5799 case dw_val_class_str
:
5800 CHECKSUM_ULEB128 (DW_FORM_string
);
5801 CHECKSUM_STRING (AT_string (at
));
5804 case dw_val_class_addr
:
5806 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5807 CHECKSUM_ULEB128 (DW_FORM_string
);
5808 CHECKSUM_STRING (XSTR (r
, 0));
5811 case dw_val_class_offset
:
5812 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5813 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
5816 case dw_val_class_loc
:
5817 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5818 loc_checksum_ordered (loc
, ctx
);
5821 case dw_val_class_fde_ref
:
5822 case dw_val_class_lbl_id
:
5823 case dw_val_class_lineptr
:
5824 case dw_val_class_macptr
:
5825 case dw_val_class_high_pc
:
5828 case dw_val_class_file
:
5829 CHECKSUM_ULEB128 (DW_FORM_string
);
5830 CHECKSUM_STRING (AT_file (at
)->filename
);
5833 case dw_val_class_data8
:
5834 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
5842 struct checksum_attributes
5844 dw_attr_ref at_name
;
5845 dw_attr_ref at_type
;
5846 dw_attr_ref at_friend
;
5847 dw_attr_ref at_accessibility
;
5848 dw_attr_ref at_address_class
;
5849 dw_attr_ref at_allocated
;
5850 dw_attr_ref at_artificial
;
5851 dw_attr_ref at_associated
;
5852 dw_attr_ref at_binary_scale
;
5853 dw_attr_ref at_bit_offset
;
5854 dw_attr_ref at_bit_size
;
5855 dw_attr_ref at_bit_stride
;
5856 dw_attr_ref at_byte_size
;
5857 dw_attr_ref at_byte_stride
;
5858 dw_attr_ref at_const_value
;
5859 dw_attr_ref at_containing_type
;
5860 dw_attr_ref at_count
;
5861 dw_attr_ref at_data_location
;
5862 dw_attr_ref at_data_member_location
;
5863 dw_attr_ref at_decimal_scale
;
5864 dw_attr_ref at_decimal_sign
;
5865 dw_attr_ref at_default_value
;
5866 dw_attr_ref at_digit_count
;
5867 dw_attr_ref at_discr
;
5868 dw_attr_ref at_discr_list
;
5869 dw_attr_ref at_discr_value
;
5870 dw_attr_ref at_encoding
;
5871 dw_attr_ref at_endianity
;
5872 dw_attr_ref at_explicit
;
5873 dw_attr_ref at_is_optional
;
5874 dw_attr_ref at_location
;
5875 dw_attr_ref at_lower_bound
;
5876 dw_attr_ref at_mutable
;
5877 dw_attr_ref at_ordering
;
5878 dw_attr_ref at_picture_string
;
5879 dw_attr_ref at_prototyped
;
5880 dw_attr_ref at_small
;
5881 dw_attr_ref at_segment
;
5882 dw_attr_ref at_string_length
;
5883 dw_attr_ref at_threads_scaled
;
5884 dw_attr_ref at_upper_bound
;
5885 dw_attr_ref at_use_location
;
5886 dw_attr_ref at_use_UTF8
;
5887 dw_attr_ref at_variable_parameter
;
5888 dw_attr_ref at_virtuality
;
5889 dw_attr_ref at_visibility
;
5890 dw_attr_ref at_vtable_elem_location
;
5893 /* Collect the attributes that we will want to use for the checksum. */
5896 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
5901 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5912 attrs
->at_friend
= a
;
5914 case DW_AT_accessibility
:
5915 attrs
->at_accessibility
= a
;
5917 case DW_AT_address_class
:
5918 attrs
->at_address_class
= a
;
5920 case DW_AT_allocated
:
5921 attrs
->at_allocated
= a
;
5923 case DW_AT_artificial
:
5924 attrs
->at_artificial
= a
;
5926 case DW_AT_associated
:
5927 attrs
->at_associated
= a
;
5929 case DW_AT_binary_scale
:
5930 attrs
->at_binary_scale
= a
;
5932 case DW_AT_bit_offset
:
5933 attrs
->at_bit_offset
= a
;
5935 case DW_AT_bit_size
:
5936 attrs
->at_bit_size
= a
;
5938 case DW_AT_bit_stride
:
5939 attrs
->at_bit_stride
= a
;
5941 case DW_AT_byte_size
:
5942 attrs
->at_byte_size
= a
;
5944 case DW_AT_byte_stride
:
5945 attrs
->at_byte_stride
= a
;
5947 case DW_AT_const_value
:
5948 attrs
->at_const_value
= a
;
5950 case DW_AT_containing_type
:
5951 attrs
->at_containing_type
= a
;
5954 attrs
->at_count
= a
;
5956 case DW_AT_data_location
:
5957 attrs
->at_data_location
= a
;
5959 case DW_AT_data_member_location
:
5960 attrs
->at_data_member_location
= a
;
5962 case DW_AT_decimal_scale
:
5963 attrs
->at_decimal_scale
= a
;
5965 case DW_AT_decimal_sign
:
5966 attrs
->at_decimal_sign
= a
;
5968 case DW_AT_default_value
:
5969 attrs
->at_default_value
= a
;
5971 case DW_AT_digit_count
:
5972 attrs
->at_digit_count
= a
;
5975 attrs
->at_discr
= a
;
5977 case DW_AT_discr_list
:
5978 attrs
->at_discr_list
= a
;
5980 case DW_AT_discr_value
:
5981 attrs
->at_discr_value
= a
;
5983 case DW_AT_encoding
:
5984 attrs
->at_encoding
= a
;
5986 case DW_AT_endianity
:
5987 attrs
->at_endianity
= a
;
5989 case DW_AT_explicit
:
5990 attrs
->at_explicit
= a
;
5992 case DW_AT_is_optional
:
5993 attrs
->at_is_optional
= a
;
5995 case DW_AT_location
:
5996 attrs
->at_location
= a
;
5998 case DW_AT_lower_bound
:
5999 attrs
->at_lower_bound
= a
;
6002 attrs
->at_mutable
= a
;
6004 case DW_AT_ordering
:
6005 attrs
->at_ordering
= a
;
6007 case DW_AT_picture_string
:
6008 attrs
->at_picture_string
= a
;
6010 case DW_AT_prototyped
:
6011 attrs
->at_prototyped
= a
;
6014 attrs
->at_small
= a
;
6017 attrs
->at_segment
= a
;
6019 case DW_AT_string_length
:
6020 attrs
->at_string_length
= a
;
6022 case DW_AT_threads_scaled
:
6023 attrs
->at_threads_scaled
= a
;
6025 case DW_AT_upper_bound
:
6026 attrs
->at_upper_bound
= a
;
6028 case DW_AT_use_location
:
6029 attrs
->at_use_location
= a
;
6031 case DW_AT_use_UTF8
:
6032 attrs
->at_use_UTF8
= a
;
6034 case DW_AT_variable_parameter
:
6035 attrs
->at_variable_parameter
= a
;
6037 case DW_AT_virtuality
:
6038 attrs
->at_virtuality
= a
;
6040 case DW_AT_visibility
:
6041 attrs
->at_visibility
= a
;
6043 case DW_AT_vtable_elem_location
:
6044 attrs
->at_vtable_elem_location
= a
;
6052 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6055 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6059 struct checksum_attributes attrs
;
6061 CHECKSUM_ULEB128 ('D');
6062 CHECKSUM_ULEB128 (die
->die_tag
);
6064 memset (&attrs
, 0, sizeof (attrs
));
6066 decl
= get_AT_ref (die
, DW_AT_specification
);
6068 collect_checksum_attributes (&attrs
, decl
);
6069 collect_checksum_attributes (&attrs
, die
);
6071 CHECKSUM_ATTR (attrs
.at_name
);
6072 CHECKSUM_ATTR (attrs
.at_accessibility
);
6073 CHECKSUM_ATTR (attrs
.at_address_class
);
6074 CHECKSUM_ATTR (attrs
.at_allocated
);
6075 CHECKSUM_ATTR (attrs
.at_artificial
);
6076 CHECKSUM_ATTR (attrs
.at_associated
);
6077 CHECKSUM_ATTR (attrs
.at_binary_scale
);
6078 CHECKSUM_ATTR (attrs
.at_bit_offset
);
6079 CHECKSUM_ATTR (attrs
.at_bit_size
);
6080 CHECKSUM_ATTR (attrs
.at_bit_stride
);
6081 CHECKSUM_ATTR (attrs
.at_byte_size
);
6082 CHECKSUM_ATTR (attrs
.at_byte_stride
);
6083 CHECKSUM_ATTR (attrs
.at_const_value
);
6084 CHECKSUM_ATTR (attrs
.at_containing_type
);
6085 CHECKSUM_ATTR (attrs
.at_count
);
6086 CHECKSUM_ATTR (attrs
.at_data_location
);
6087 CHECKSUM_ATTR (attrs
.at_data_member_location
);
6088 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
6089 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
6090 CHECKSUM_ATTR (attrs
.at_default_value
);
6091 CHECKSUM_ATTR (attrs
.at_digit_count
);
6092 CHECKSUM_ATTR (attrs
.at_discr
);
6093 CHECKSUM_ATTR (attrs
.at_discr_list
);
6094 CHECKSUM_ATTR (attrs
.at_discr_value
);
6095 CHECKSUM_ATTR (attrs
.at_encoding
);
6096 CHECKSUM_ATTR (attrs
.at_endianity
);
6097 CHECKSUM_ATTR (attrs
.at_explicit
);
6098 CHECKSUM_ATTR (attrs
.at_is_optional
);
6099 CHECKSUM_ATTR (attrs
.at_location
);
6100 CHECKSUM_ATTR (attrs
.at_lower_bound
);
6101 CHECKSUM_ATTR (attrs
.at_mutable
);
6102 CHECKSUM_ATTR (attrs
.at_ordering
);
6103 CHECKSUM_ATTR (attrs
.at_picture_string
);
6104 CHECKSUM_ATTR (attrs
.at_prototyped
);
6105 CHECKSUM_ATTR (attrs
.at_small
);
6106 CHECKSUM_ATTR (attrs
.at_segment
);
6107 CHECKSUM_ATTR (attrs
.at_string_length
);
6108 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
6109 CHECKSUM_ATTR (attrs
.at_upper_bound
);
6110 CHECKSUM_ATTR (attrs
.at_use_location
);
6111 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
6112 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
6113 CHECKSUM_ATTR (attrs
.at_virtuality
);
6114 CHECKSUM_ATTR (attrs
.at_visibility
);
6115 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
6116 CHECKSUM_ATTR (attrs
.at_type
);
6117 CHECKSUM_ATTR (attrs
.at_friend
);
6119 /* Checksum the child DIEs. */
6122 dw_attr_ref name_attr
;
6125 name_attr
= get_AT (c
, DW_AT_name
);
6126 if (is_template_instantiation (c
))
6128 /* Ignore instantiations of member type and function templates. */
6130 else if (name_attr
!= NULL
6131 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
6133 /* Use a shallow checksum for named nested types and member
6135 CHECKSUM_ULEB128 ('S');
6136 CHECKSUM_ULEB128 (c
->die_tag
);
6137 CHECKSUM_STRING (AT_string (name_attr
));
6141 /* Use a deep checksum for other children. */
6142 /* Mark this DIE so it gets processed when unmarking. */
6143 if (c
->die_mark
== 0)
6145 die_checksum_ordered (c
, ctx
, mark
);
6147 } while (c
!= die
->die_child
);
6149 CHECKSUM_ULEB128 (0);
6152 /* Add a type name and tag to a hash. */
6154 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
6156 CHECKSUM_ULEB128 (tag
);
6157 CHECKSUM_STRING (name
);
6161 #undef CHECKSUM_STRING
6162 #undef CHECKSUM_ATTR
6163 #undef CHECKSUM_LEB128
6164 #undef CHECKSUM_ULEB128
6166 /* Generate the type signature for DIE. This is computed by generating an
6167 MD5 checksum over the DIE's tag, its relevant attributes, and its
6168 children. Attributes that are references to other DIEs are processed
6169 by recursion, using the MARK field to prevent infinite recursion.
6170 If the DIE is nested inside a namespace or another type, we also
6171 need to include that context in the signature. The lower 64 bits
6172 of the resulting MD5 checksum comprise the signature. */
6175 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
6179 unsigned char checksum
[16];
6184 name
= get_AT_string (die
, DW_AT_name
);
6185 decl
= get_AT_ref (die
, DW_AT_specification
);
6186 parent
= get_die_parent (die
);
6188 /* First, compute a signature for just the type name (and its surrounding
6189 context, if any. This is stored in the type unit DIE for link-time
6190 ODR (one-definition rule) checking. */
6192 if (is_cxx () && name
!= NULL
)
6194 md5_init_ctx (&ctx
);
6196 /* Checksum the names of surrounding namespaces and structures. */
6198 checksum_die_context (parent
, &ctx
);
6200 /* Checksum the current DIE. */
6201 die_odr_checksum (die
->die_tag
, name
, &ctx
);
6202 md5_finish_ctx (&ctx
, checksum
);
6204 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
6207 /* Next, compute the complete type signature. */
6209 md5_init_ctx (&ctx
);
6211 die
->die_mark
= mark
;
6213 /* Checksum the names of surrounding namespaces and structures. */
6215 checksum_die_context (parent
, &ctx
);
6217 /* Checksum the DIE and its children. */
6218 die_checksum_ordered (die
, &ctx
, &mark
);
6219 unmark_all_dies (die
);
6220 md5_finish_ctx (&ctx
, checksum
);
6222 /* Store the signature in the type node and link the type DIE and the
6223 type node together. */
6224 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
6225 DWARF_TYPE_SIGNATURE_SIZE
);
6226 die
->comdat_type_p
= true;
6227 die
->die_id
.die_type_node
= type_node
;
6228 type_node
->type_die
= die
;
6230 /* If the DIE is a specification, link its declaration to the type node
6234 decl
->comdat_type_p
= true;
6235 decl
->die_id
.die_type_node
= type_node
;
6239 /* Do the location expressions look same? */
6241 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
6243 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
6244 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
6245 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
6248 /* Do the values look the same? */
6250 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
6252 dw_loc_descr_ref loc1
, loc2
;
6255 if (v1
->val_class
!= v2
->val_class
)
6258 switch (v1
->val_class
)
6260 case dw_val_class_const
:
6261 return v1
->v
.val_int
== v2
->v
.val_int
;
6262 case dw_val_class_unsigned_const
:
6263 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
6264 case dw_val_class_const_double
:
6265 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
6266 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
6267 case dw_val_class_vec
:
6268 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
6269 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
6271 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
6272 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
6275 case dw_val_class_flag
:
6276 return v1
->v
.val_flag
== v2
->v
.val_flag
;
6277 case dw_val_class_str
:
6278 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
6280 case dw_val_class_addr
:
6281 r1
= v1
->v
.val_addr
;
6282 r2
= v2
->v
.val_addr
;
6283 if (GET_CODE (r1
) != GET_CODE (r2
))
6285 return !rtx_equal_p (r1
, r2
);
6287 case dw_val_class_offset
:
6288 return v1
->v
.val_offset
== v2
->v
.val_offset
;
6290 case dw_val_class_loc
:
6291 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
6293 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
6294 if (!same_loc_p (loc1
, loc2
, mark
))
6296 return !loc1
&& !loc2
;
6298 case dw_val_class_die_ref
:
6299 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
6301 case dw_val_class_fde_ref
:
6302 case dw_val_class_vms_delta
:
6303 case dw_val_class_lbl_id
:
6304 case dw_val_class_lineptr
:
6305 case dw_val_class_macptr
:
6306 case dw_val_class_high_pc
:
6309 case dw_val_class_file
:
6310 return v1
->v
.val_file
== v2
->v
.val_file
;
6312 case dw_val_class_data8
:
6313 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
6320 /* Do the attributes look the same? */
6323 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
6325 if (at1
->dw_attr
!= at2
->dw_attr
)
6328 /* We don't care that this was compiled with a different compiler
6329 snapshot; if the output is the same, that's what matters. */
6330 if (at1
->dw_attr
== DW_AT_producer
)
6333 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
6336 /* Do the dies look the same? */
6339 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
6345 /* To avoid infinite recursion. */
6347 return die1
->die_mark
== die2
->die_mark
;
6348 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
6350 if (die1
->die_tag
!= die2
->die_tag
)
6353 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
6356 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
6357 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
6360 c1
= die1
->die_child
;
6361 c2
= die2
->die_child
;
6370 if (!same_die_p (c1
, c2
, mark
))
6374 if (c1
== die1
->die_child
)
6376 if (c2
== die2
->die_child
)
6386 /* Do the dies look the same? Wrapper around same_die_p. */
6389 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
6392 int ret
= same_die_p (die1
, die2
, &mark
);
6394 unmark_all_dies (die1
);
6395 unmark_all_dies (die2
);
6400 /* The prefix to attach to symbols on DIEs in the current comdat debug
6402 static const char *comdat_symbol_id
;
6404 /* The index of the current symbol within the current comdat CU. */
6405 static unsigned int comdat_symbol_number
;
6407 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6408 children, and set comdat_symbol_id accordingly. */
6411 compute_section_prefix (dw_die_ref unit_die
)
6413 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
6414 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
6415 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
6418 unsigned char checksum
[16];
6421 /* Compute the checksum of the DIE, then append part of it as hex digits to
6422 the name filename of the unit. */
6424 md5_init_ctx (&ctx
);
6426 die_checksum (unit_die
, &ctx
, &mark
);
6427 unmark_all_dies (unit_die
);
6428 md5_finish_ctx (&ctx
, checksum
);
6430 sprintf (name
, "%s.", base
);
6431 clean_symbol_name (name
);
6433 p
= name
+ strlen (name
);
6434 for (i
= 0; i
< 4; i
++)
6436 sprintf (p
, "%.2x", checksum
[i
]);
6440 comdat_symbol_id
= unit_die
->die_id
.die_symbol
= xstrdup (name
);
6441 comdat_symbol_number
= 0;
6444 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6447 is_type_die (dw_die_ref die
)
6449 switch (die
->die_tag
)
6451 case DW_TAG_array_type
:
6452 case DW_TAG_class_type
:
6453 case DW_TAG_interface_type
:
6454 case DW_TAG_enumeration_type
:
6455 case DW_TAG_pointer_type
:
6456 case DW_TAG_reference_type
:
6457 case DW_TAG_rvalue_reference_type
:
6458 case DW_TAG_string_type
:
6459 case DW_TAG_structure_type
:
6460 case DW_TAG_subroutine_type
:
6461 case DW_TAG_union_type
:
6462 case DW_TAG_ptr_to_member_type
:
6463 case DW_TAG_set_type
:
6464 case DW_TAG_subrange_type
:
6465 case DW_TAG_base_type
:
6466 case DW_TAG_const_type
:
6467 case DW_TAG_file_type
:
6468 case DW_TAG_packed_type
:
6469 case DW_TAG_volatile_type
:
6470 case DW_TAG_typedef
:
6477 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6478 Basically, we want to choose the bits that are likely to be shared between
6479 compilations (types) and leave out the bits that are specific to individual
6480 compilations (functions). */
6483 is_comdat_die (dw_die_ref c
)
6485 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6486 we do for stabs. The advantage is a greater likelihood of sharing between
6487 objects that don't include headers in the same order (and therefore would
6488 put the base types in a different comdat). jason 8/28/00 */
6490 if (c
->die_tag
== DW_TAG_base_type
)
6493 if (c
->die_tag
== DW_TAG_pointer_type
6494 || c
->die_tag
== DW_TAG_reference_type
6495 || c
->die_tag
== DW_TAG_rvalue_reference_type
6496 || c
->die_tag
== DW_TAG_const_type
6497 || c
->die_tag
== DW_TAG_volatile_type
)
6499 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
6501 return t
? is_comdat_die (t
) : 0;
6504 return is_type_die (c
);
6507 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6508 compilation unit. */
6511 is_symbol_die (dw_die_ref c
)
6513 return (is_type_die (c
)
6514 || is_declaration_die (c
)
6515 || c
->die_tag
== DW_TAG_namespace
6516 || c
->die_tag
== DW_TAG_module
);
6519 /* Returns true iff C is a compile-unit DIE. */
6522 is_cu_die (dw_die_ref c
)
6524 return c
&& c
->die_tag
== DW_TAG_compile_unit
;
6527 /* Returns true iff C is a unit DIE of some sort. */
6530 is_unit_die (dw_die_ref c
)
6532 return c
&& (c
->die_tag
== DW_TAG_compile_unit
6533 || c
->die_tag
== DW_TAG_partial_unit
6534 || c
->die_tag
== DW_TAG_type_unit
);
6537 /* Returns true iff C is a namespace DIE. */
6540 is_namespace_die (dw_die_ref c
)
6542 return c
&& c
->die_tag
== DW_TAG_namespace
;
6545 /* Returns true iff C is a class or structure DIE. */
6548 is_class_die (dw_die_ref c
)
6550 return c
&& (c
->die_tag
== DW_TAG_class_type
6551 || c
->die_tag
== DW_TAG_structure_type
);
6554 /* Return non-zero if this DIE is a template parameter. */
6557 is_template_parameter (dw_die_ref die
)
6559 switch (die
->die_tag
)
6561 case DW_TAG_template_type_param
:
6562 case DW_TAG_template_value_param
:
6563 case DW_TAG_GNU_template_template_param
:
6564 case DW_TAG_GNU_template_parameter_pack
:
6571 /* Return non-zero if this DIE represents a template instantiation. */
6574 is_template_instantiation (dw_die_ref die
)
6578 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
6580 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
6585 gen_internal_sym (const char *prefix
)
6589 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
6590 return xstrdup (buf
);
6593 /* Assign symbols to all worthy DIEs under DIE. */
6596 assign_symbol_names (dw_die_ref die
)
6600 if (is_symbol_die (die
) && !die
->comdat_type_p
)
6602 if (comdat_symbol_id
)
6604 char *p
= XALLOCAVEC (char, strlen (comdat_symbol_id
) + 64);
6606 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
6607 comdat_symbol_id
, comdat_symbol_number
++);
6608 die
->die_id
.die_symbol
= xstrdup (p
);
6611 die
->die_id
.die_symbol
= gen_internal_sym ("LDIE");
6614 FOR_EACH_CHILD (die
, c
, assign_symbol_names (c
));
6617 struct cu_hash_table_entry
6620 unsigned min_comdat_num
, max_comdat_num
;
6621 struct cu_hash_table_entry
*next
;
6624 /* Helpers to manipulate hash table of CUs. */
6626 struct cu_hash_table_entry_hasher
6628 typedef cu_hash_table_entry value_type
;
6629 typedef die_struct compare_type
;
6630 static inline hashval_t
hash (const value_type
*);
6631 static inline bool equal (const value_type
*, const compare_type
*);
6632 static inline void remove (value_type
*);
6636 cu_hash_table_entry_hasher::hash (const value_type
*entry
)
6638 return htab_hash_string (entry
->cu
->die_id
.die_symbol
);
6642 cu_hash_table_entry_hasher::equal (const value_type
*entry1
,
6643 const compare_type
*entry2
)
6645 return !strcmp (entry1
->cu
->die_id
.die_symbol
, entry2
->die_id
.die_symbol
);
6649 cu_hash_table_entry_hasher::remove (value_type
*entry
)
6651 struct cu_hash_table_entry
*next
;
6661 typedef hash_table
<cu_hash_table_entry_hasher
> cu_hash_type
;
6663 /* Check whether we have already seen this CU and set up SYM_NUM
6666 check_duplicate_cu (dw_die_ref cu
, cu_hash_type htable
, unsigned int *sym_num
)
6668 struct cu_hash_table_entry dummy
;
6669 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
6671 dummy
.max_comdat_num
= 0;
6673 slot
= htable
.find_slot_with_hash (cu
,
6674 htab_hash_string (cu
->die_id
.die_symbol
),
6678 for (; entry
; last
= entry
, entry
= entry
->next
)
6680 if (same_die_p_wrap (cu
, entry
->cu
))
6686 *sym_num
= entry
->min_comdat_num
;
6690 entry
= XCNEW (struct cu_hash_table_entry
);
6692 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
6693 entry
->next
= *slot
;
6699 /* Record SYM_NUM to record of CU in HTABLE. */
6701 record_comdat_symbol_number (dw_die_ref cu
, cu_hash_type htable
,
6702 unsigned int sym_num
)
6704 struct cu_hash_table_entry
**slot
, *entry
;
6706 slot
= htable
.find_slot_with_hash (cu
,
6707 htab_hash_string (cu
->die_id
.die_symbol
),
6711 entry
->max_comdat_num
= sym_num
;
6714 /* Traverse the DIE (which is always comp_unit_die), and set up
6715 additional compilation units for each of the include files we see
6716 bracketed by BINCL/EINCL. */
6719 break_out_includes (dw_die_ref die
)
6722 dw_die_ref unit
= NULL
;
6723 limbo_die_node
*node
, **pnode
;
6724 cu_hash_type cu_hash_table
;
6728 dw_die_ref prev
= c
;
6730 while (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
6731 || (unit
&& is_comdat_die (c
)))
6733 dw_die_ref next
= c
->die_sib
;
6735 /* This DIE is for a secondary CU; remove it from the main one. */
6736 remove_child_with_prev (c
, prev
);
6738 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
6739 unit
= push_new_compile_unit (unit
, c
);
6740 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
6741 unit
= pop_compile_unit (unit
);
6743 add_child_die (unit
, c
);
6745 if (c
== die
->die_child
)
6748 } while (c
!= die
->die_child
);
6751 /* We can only use this in debugging, since the frontend doesn't check
6752 to make sure that we leave every include file we enter. */
6756 assign_symbol_names (die
);
6757 cu_hash_table
.create (10);
6758 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
6764 compute_section_prefix (node
->die
);
6765 is_dupl
= check_duplicate_cu (node
->die
, cu_hash_table
,
6766 &comdat_symbol_number
);
6767 assign_symbol_names (node
->die
);
6769 *pnode
= node
->next
;
6772 pnode
= &node
->next
;
6773 record_comdat_symbol_number (node
->die
, cu_hash_table
,
6774 comdat_symbol_number
);
6777 cu_hash_table
.dispose ();
6780 /* Return non-zero if this DIE is a declaration. */
6783 is_declaration_die (dw_die_ref die
)
6788 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6789 if (a
->dw_attr
== DW_AT_declaration
)
6795 /* Return non-zero if this DIE is nested inside a subprogram. */
6798 is_nested_in_subprogram (dw_die_ref die
)
6800 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
6804 return local_scope_p (decl
);
6807 /* Return non-zero if this DIE contains a defining declaration of a
6811 contains_subprogram_definition (dw_die_ref die
)
6815 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
6817 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
6821 /* Return non-zero if this is a type DIE that should be moved to a
6822 COMDAT .debug_types section. */
6825 should_move_die_to_comdat (dw_die_ref die
)
6827 switch (die
->die_tag
)
6829 case DW_TAG_class_type
:
6830 case DW_TAG_structure_type
:
6831 case DW_TAG_enumeration_type
:
6832 case DW_TAG_union_type
:
6833 /* Don't move declarations, inlined instances, or types nested in a
6835 if (is_declaration_die (die
)
6836 || get_AT (die
, DW_AT_abstract_origin
)
6837 || is_nested_in_subprogram (die
))
6839 /* A type definition should never contain a subprogram definition. */
6840 gcc_assert (!contains_subprogram_definition (die
));
6842 case DW_TAG_array_type
:
6843 case DW_TAG_interface_type
:
6844 case DW_TAG_pointer_type
:
6845 case DW_TAG_reference_type
:
6846 case DW_TAG_rvalue_reference_type
:
6847 case DW_TAG_string_type
:
6848 case DW_TAG_subroutine_type
:
6849 case DW_TAG_ptr_to_member_type
:
6850 case DW_TAG_set_type
:
6851 case DW_TAG_subrange_type
:
6852 case DW_TAG_base_type
:
6853 case DW_TAG_const_type
:
6854 case DW_TAG_file_type
:
6855 case DW_TAG_packed_type
:
6856 case DW_TAG_volatile_type
:
6857 case DW_TAG_typedef
:
6863 /* Make a clone of DIE. */
6866 clone_die (dw_die_ref die
)
6872 clone
= ggc_alloc_cleared_die_node ();
6873 clone
->die_tag
= die
->die_tag
;
6875 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6876 add_dwarf_attr (clone
, a
);
6881 /* Make a clone of the tree rooted at DIE. */
6884 clone_tree (dw_die_ref die
)
6887 dw_die_ref clone
= clone_die (die
);
6889 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
6894 /* Make a clone of DIE as a declaration. */
6897 clone_as_declaration (dw_die_ref die
)
6904 /* If the DIE is already a declaration, just clone it. */
6905 if (is_declaration_die (die
))
6906 return clone_die (die
);
6908 /* If the DIE is a specification, just clone its declaration DIE. */
6909 decl
= get_AT_ref (die
, DW_AT_specification
);
6912 clone
= clone_die (decl
);
6913 if (die
->comdat_type_p
)
6914 add_AT_die_ref (clone
, DW_AT_signature
, die
);
6918 clone
= ggc_alloc_cleared_die_node ();
6919 clone
->die_tag
= die
->die_tag
;
6921 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6923 /* We don't want to copy over all attributes.
6924 For example we don't want DW_AT_byte_size because otherwise we will no
6925 longer have a declaration and GDB will treat it as a definition. */
6929 case DW_AT_artificial
:
6930 case DW_AT_containing_type
:
6931 case DW_AT_external
:
6934 case DW_AT_virtuality
:
6935 case DW_AT_linkage_name
:
6936 case DW_AT_MIPS_linkage_name
:
6937 add_dwarf_attr (clone
, a
);
6939 case DW_AT_byte_size
:
6945 if (die
->comdat_type_p
)
6946 add_AT_die_ref (clone
, DW_AT_signature
, die
);
6948 add_AT_flag (clone
, DW_AT_declaration
, 1);
6953 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
6955 struct decl_table_entry
6961 /* Helpers to manipulate hash table of copied declarations. */
6963 /* Hashtable helpers. */
6965 struct decl_table_entry_hasher
: typed_free_remove
<decl_table_entry
>
6967 typedef decl_table_entry value_type
;
6968 typedef die_struct compare_type
;
6969 static inline hashval_t
hash (const value_type
*);
6970 static inline bool equal (const value_type
*, const compare_type
*);
6974 decl_table_entry_hasher::hash (const value_type
*entry
)
6976 return htab_hash_pointer (entry
->orig
);
6980 decl_table_entry_hasher::equal (const value_type
*entry1
,
6981 const compare_type
*entry2
)
6983 return entry1
->orig
== entry2
;
6986 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
6988 /* Copy DIE and its ancestors, up to, but not including, the compile unit
6989 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
6990 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
6991 to check if the ancestor has already been copied into UNIT. */
6994 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
, decl_hash_type decl_table
)
6996 dw_die_ref parent
= die
->die_parent
;
6997 dw_die_ref new_parent
= unit
;
6999 decl_table_entry
**slot
= NULL
;
7000 struct decl_table_entry
*entry
= NULL
;
7002 if (decl_table
.is_created ())
7004 /* Check if the entry has already been copied to UNIT. */
7005 slot
= decl_table
.find_slot_with_hash (die
, htab_hash_pointer (die
),
7007 if (*slot
!= HTAB_EMPTY_ENTRY
)
7013 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7014 entry
= XCNEW (struct decl_table_entry
);
7022 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
7025 if (!is_unit_die (parent
))
7026 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
7029 copy
= clone_as_declaration (die
);
7030 add_child_die (new_parent
, copy
);
7032 if (decl_table
.is_created ())
7034 /* Record the pointer to the copy. */
7040 /* Copy the declaration context to the new type unit DIE. This includes
7041 any surrounding namespace or type declarations. If the DIE has an
7042 AT_specification attribute, it also includes attributes and children
7043 attached to the specification, and returns a pointer to the original
7044 parent of the declaration DIE. Returns NULL otherwise. */
7047 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
7050 dw_die_ref new_decl
;
7051 dw_die_ref orig_parent
= NULL
;
7053 decl
= get_AT_ref (die
, DW_AT_specification
);
7062 /* The original DIE will be changed to a declaration, and must
7063 be moved to be a child of the original declaration DIE. */
7064 orig_parent
= decl
->die_parent
;
7066 /* Copy the type node pointer from the new DIE to the original
7067 declaration DIE so we can forward references later. */
7068 decl
->comdat_type_p
= true;
7069 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
7071 remove_AT (die
, DW_AT_specification
);
7073 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
7075 if (a
->dw_attr
!= DW_AT_name
7076 && a
->dw_attr
!= DW_AT_declaration
7077 && a
->dw_attr
!= DW_AT_external
)
7078 add_dwarf_attr (die
, a
);
7081 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
7084 if (decl
->die_parent
!= NULL
7085 && !is_unit_die (decl
->die_parent
))
7087 new_decl
= copy_ancestor_tree (unit
, decl
, decl_hash_type ());
7088 if (new_decl
!= NULL
)
7090 remove_AT (new_decl
, DW_AT_signature
);
7091 add_AT_specification (die
, new_decl
);
7098 /* Generate the skeleton ancestor tree for the given NODE, then clone
7099 the DIE and add the clone into the tree. */
7102 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
7104 if (node
->new_die
!= NULL
)
7107 node
->new_die
= clone_as_declaration (node
->old_die
);
7109 if (node
->parent
!= NULL
)
7111 generate_skeleton_ancestor_tree (node
->parent
);
7112 add_child_die (node
->parent
->new_die
, node
->new_die
);
7116 /* Generate a skeleton tree of DIEs containing any declarations that are
7117 found in the original tree. We traverse the tree looking for declaration
7118 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7121 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
7123 skeleton_chain_node node
;
7126 dw_die_ref prev
= NULL
;
7127 dw_die_ref next
= NULL
;
7129 node
.parent
= parent
;
7131 first
= c
= parent
->old_die
->die_child
;
7135 if (prev
== NULL
|| prev
->die_sib
== c
)
7138 next
= (c
== first
? NULL
: c
->die_sib
);
7140 node
.new_die
= NULL
;
7141 if (is_declaration_die (c
))
7143 if (is_template_instantiation (c
))
7145 /* Instantiated templates do not need to be cloned into the
7146 type unit. Just move the DIE and its children back to
7147 the skeleton tree (in the main CU). */
7148 remove_child_with_prev (c
, prev
);
7149 add_child_die (parent
->new_die
, c
);
7154 /* Clone the existing DIE, move the original to the skeleton
7155 tree (which is in the main CU), and put the clone, with
7156 all the original's children, where the original came from
7157 (which is about to be moved to the type unit). */
7158 dw_die_ref clone
= clone_die (c
);
7159 move_all_children (c
, clone
);
7161 replace_child (c
, clone
, prev
);
7162 generate_skeleton_ancestor_tree (parent
);
7163 add_child_die (parent
->new_die
, c
);
7168 generate_skeleton_bottom_up (&node
);
7169 } while (next
!= NULL
);
7172 /* Wrapper function for generate_skeleton_bottom_up. */
7175 generate_skeleton (dw_die_ref die
)
7177 skeleton_chain_node node
;
7180 node
.new_die
= NULL
;
7183 /* If this type definition is nested inside another type,
7184 and is not an instantiation of a template, always leave
7185 at least a declaration in its place. */
7186 if (die
->die_parent
!= NULL
7187 && is_type_die (die
->die_parent
)
7188 && !is_template_instantiation (die
))
7189 node
.new_die
= clone_as_declaration (die
);
7191 generate_skeleton_bottom_up (&node
);
7192 return node
.new_die
;
7195 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7196 declaration. The original DIE is moved to a new compile unit so that
7197 existing references to it follow it to the new location. If any of the
7198 original DIE's descendants is a declaration, we need to replace the
7199 original DIE with a skeleton tree and move the declarations back into the
7203 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
7206 dw_die_ref skeleton
, orig_parent
;
7208 /* Copy the declaration context to the type unit DIE. If the returned
7209 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7211 orig_parent
= copy_declaration_context (unit
, child
);
7213 skeleton
= generate_skeleton (child
);
7214 if (skeleton
== NULL
)
7215 remove_child_with_prev (child
, prev
);
7218 skeleton
->comdat_type_p
= true;
7219 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
7221 /* If the original DIE was a specification, we need to put
7222 the skeleton under the parent DIE of the declaration.
7223 This leaves the original declaration in the tree, but
7224 it will be pruned later since there are no longer any
7225 references to it. */
7226 if (orig_parent
!= NULL
)
7228 remove_child_with_prev (child
, prev
);
7229 add_child_die (orig_parent
, skeleton
);
7232 replace_child (child
, skeleton
, prev
);
7238 /* Traverse the DIE and set up additional .debug_types sections for each
7239 type worthy of being placed in a COMDAT section. */
7242 break_out_comdat_types (dw_die_ref die
)
7246 dw_die_ref prev
= NULL
;
7247 dw_die_ref next
= NULL
;
7248 dw_die_ref unit
= NULL
;
7250 first
= c
= die
->die_child
;
7254 if (prev
== NULL
|| prev
->die_sib
== c
)
7257 next
= (c
== first
? NULL
: c
->die_sib
);
7258 if (should_move_die_to_comdat (c
))
7260 dw_die_ref replacement
;
7261 comdat_type_node_ref type_node
;
7263 /* Break out nested types into their own type units. */
7264 break_out_comdat_types (c
);
7266 /* Create a new type unit DIE as the root for the new tree, and
7267 add it to the list of comdat types. */
7268 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
7269 add_AT_unsigned (unit
, DW_AT_language
,
7270 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
7271 type_node
= ggc_alloc_cleared_comdat_type_node ();
7272 type_node
->root_die
= unit
;
7273 type_node
->next
= comdat_type_list
;
7274 comdat_type_list
= type_node
;
7276 /* Generate the type signature. */
7277 generate_type_signature (c
, type_node
);
7279 /* Copy the declaration context, attributes, and children of the
7280 declaration into the new type unit DIE, then remove this DIE
7281 from the main CU (or replace it with a skeleton if necessary). */
7282 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
7283 type_node
->skeleton_die
= replacement
;
7285 /* Add the DIE to the new compunit. */
7286 add_child_die (unit
, c
);
7288 if (replacement
!= NULL
)
7291 else if (c
->die_tag
== DW_TAG_namespace
7292 || c
->die_tag
== DW_TAG_class_type
7293 || c
->die_tag
== DW_TAG_structure_type
7294 || c
->die_tag
== DW_TAG_union_type
)
7296 /* Look for nested types that can be broken out. */
7297 break_out_comdat_types (c
);
7299 } while (next
!= NULL
);
7302 /* Like clone_tree, but additionally enter all the children into
7303 the hash table decl_table. */
7306 clone_tree_hash (dw_die_ref die
, decl_hash_type decl_table
)
7309 dw_die_ref clone
= clone_die (die
);
7310 struct decl_table_entry
*entry
;
7311 decl_table_entry
**slot
= decl_table
.find_slot_with_hash (die
,
7312 htab_hash_pointer (die
), INSERT
);
7313 /* Assert that DIE isn't in the hash table yet. If it would be there
7314 before, the ancestors would be necessarily there as well, therefore
7315 clone_tree_hash wouldn't be called. */
7316 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
7317 entry
= XCNEW (struct decl_table_entry
);
7319 entry
->copy
= clone
;
7322 FOR_EACH_CHILD (die
, c
,
7323 add_child_die (clone
, clone_tree_hash (c
, decl_table
)));
7328 /* Walk the DIE and its children, looking for references to incomplete
7329 or trivial types that are unmarked (i.e., that are not in the current
7333 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type decl_table
)
7339 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7341 if (AT_class (a
) == dw_val_class_die_ref
)
7343 dw_die_ref targ
= AT_ref (a
);
7344 decl_table_entry
**slot
;
7345 struct decl_table_entry
*entry
;
7347 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
7350 slot
= decl_table
.find_slot_with_hash (targ
, htab_hash_pointer (targ
),
7353 if (*slot
!= HTAB_EMPTY_ENTRY
)
7355 /* TARG has already been copied, so we just need to
7356 modify the reference to point to the copy. */
7358 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
7362 dw_die_ref parent
= unit
;
7363 dw_die_ref copy
= clone_die (targ
);
7365 /* Record in DECL_TABLE that TARG has been copied.
7366 Need to do this now, before the recursive call,
7367 because DECL_TABLE may be expanded and SLOT
7368 would no longer be a valid pointer. */
7369 entry
= XCNEW (struct decl_table_entry
);
7374 FOR_EACH_CHILD (targ
, c
,
7375 add_child_die (copy
,
7376 clone_tree_hash (c
, decl_table
)));
7378 /* Make sure the cloned tree is marked as part of the
7382 /* If TARG has surrounding context, copy its ancestor tree
7383 into the new type unit. */
7384 if (targ
->die_parent
!= NULL
7385 && !is_unit_die (targ
->die_parent
))
7386 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
7389 add_child_die (parent
, copy
);
7390 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
7392 /* Make sure the newly-copied DIE is walked. If it was
7393 installed in a previously-added context, it won't
7394 get visited otherwise. */
7397 /* Find the highest point of the newly-added tree,
7398 mark each node along the way, and walk from there. */
7399 parent
->die_mark
= 1;
7400 while (parent
->die_parent
7401 && parent
->die_parent
->die_mark
== 0)
7403 parent
= parent
->die_parent
;
7404 parent
->die_mark
= 1;
7406 copy_decls_walk (unit
, parent
, decl_table
);
7412 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
7415 /* Copy declarations for "unworthy" types into the new comdat section.
7416 Incomplete types, modified types, and certain other types aren't broken
7417 out into comdat sections of their own, so they don't have a signature,
7418 and we need to copy the declaration into the same section so that we
7419 don't have an external reference. */
7422 copy_decls_for_unworthy_types (dw_die_ref unit
)
7424 decl_hash_type decl_table
;
7427 decl_table
.create (10);
7428 copy_decls_walk (unit
, unit
, decl_table
);
7429 decl_table
.dispose ();
7433 /* Traverse the DIE and add a sibling attribute if it may have the
7434 effect of speeding up access to siblings. To save some space,
7435 avoid generating sibling attributes for DIE's without children. */
7438 add_sibling_attributes (dw_die_ref die
)
7442 if (! die
->die_child
)
7445 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
7446 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
7448 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
7451 /* Output all location lists for the DIE and its children. */
7454 output_location_lists (dw_die_ref die
)
7460 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7461 if (AT_class (a
) == dw_val_class_loc_list
)
7462 output_loc_list (AT_loc_list (a
));
7464 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
7467 /* We want to limit the number of external references, because they are
7468 larger than local references: a relocation takes multiple words, and
7469 even a sig8 reference is always eight bytes, whereas a local reference
7470 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
7471 So if we encounter multiple external references to the same type DIE, we
7472 make a local typedef stub for it and redirect all references there.
7474 This is the element of the hash table for keeping track of these
7484 /* Hashtable helpers. */
7486 struct external_ref_hasher
: typed_free_remove
<external_ref
>
7488 typedef external_ref value_type
;
7489 typedef external_ref compare_type
;
7490 static inline hashval_t
hash (const value_type
*);
7491 static inline bool equal (const value_type
*, const compare_type
*);
7495 external_ref_hasher::hash (const value_type
*r
)
7497 dw_die_ref die
= r
->type
;
7500 /* We can't use the address of the DIE for hashing, because
7501 that will make the order of the stub DIEs non-deterministic. */
7502 if (! die
->comdat_type_p
)
7503 /* We have a symbol; use it to compute a hash. */
7504 h
= htab_hash_string (die
->die_id
.die_symbol
);
7507 /* We have a type signature; use a subset of the bits as the hash.
7508 The 8-byte signature is at least as large as hashval_t. */
7509 comdat_type_node_ref type_node
= die
->die_id
.die_type_node
;
7510 memcpy (&h
, type_node
->signature
, sizeof (h
));
7516 external_ref_hasher::equal (const value_type
*r1
, const compare_type
*r2
)
7518 return r1
->type
== r2
->type
;
7521 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
7523 /* Return a pointer to the external_ref for references to DIE. */
7525 static struct external_ref
*
7526 lookup_external_ref (external_ref_hash_type map
, dw_die_ref die
)
7528 struct external_ref ref
, *ref_p
;
7529 external_ref
**slot
;
7532 slot
= map
.find_slot (&ref
, INSERT
);
7533 if (*slot
!= HTAB_EMPTY_ENTRY
)
7536 ref_p
= XCNEW (struct external_ref
);
7542 /* Subroutine of optimize_external_refs, below.
7544 If we see a type skeleton, record it as our stub. If we see external
7545 references, remember how many we've seen. */
7548 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type map
)
7553 struct external_ref
*ref_p
;
7555 if (is_type_die (die
)
7556 && (c
= get_AT_ref (die
, DW_AT_signature
)))
7558 /* This is a local skeleton; use it for local references. */
7559 ref_p
= lookup_external_ref (map
, c
);
7563 /* Scan the DIE references, and remember any that refer to DIEs from
7564 other CUs (i.e. those which are not marked). */
7565 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7566 if (AT_class (a
) == dw_val_class_die_ref
7567 && (c
= AT_ref (a
))->die_mark
== 0
7570 ref_p
= lookup_external_ref (map
, c
);
7574 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
7577 /* htab_traverse callback function for optimize_external_refs, below. SLOT
7578 points to an external_ref, DATA is the CU we're processing. If we don't
7579 already have a local stub, and we have multiple refs, build a stub. */
7582 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
7584 struct external_ref
*ref_p
= *slot
;
7586 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
7588 /* We have multiple references to this type, so build a small stub.
7589 Both of these forms are a bit dodgy from the perspective of the
7590 DWARF standard, since technically they should have names. */
7591 dw_die_ref cu
= data
;
7592 dw_die_ref type
= ref_p
->type
;
7593 dw_die_ref stub
= NULL
;
7595 if (type
->comdat_type_p
)
7597 /* If we refer to this type via sig8, use AT_signature. */
7598 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
7599 add_AT_die_ref (stub
, DW_AT_signature
, type
);
7603 /* Otherwise, use a typedef with no name. */
7604 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
7605 add_AT_die_ref (stub
, DW_AT_type
, type
);
7614 /* DIE is a unit; look through all the DIE references to see if there are
7615 any external references to types, and if so, create local stubs for
7616 them which will be applied in build_abbrev_table. This is useful because
7617 references to local DIEs are smaller. */
7619 static external_ref_hash_type
7620 optimize_external_refs (dw_die_ref die
)
7622 external_ref_hash_type map
;
7624 optimize_external_refs_1 (die
, map
);
7625 map
.traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
7629 /* The format of each DIE (and its attribute value pairs) is encoded in an
7630 abbreviation table. This routine builds the abbreviation table and assigns
7631 a unique abbreviation id for each abbreviation entry. The children of each
7632 die are visited recursively. */
7635 build_abbrev_table (dw_die_ref die
, external_ref_hash_type extern_map
)
7637 unsigned long abbrev_id
;
7638 unsigned int n_alloc
;
7643 /* Scan the DIE references, and replace any that refer to
7644 DIEs from other CUs (i.e. those which are not marked) with
7645 the local stubs we built in optimize_external_refs. */
7646 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7647 if (AT_class (a
) == dw_val_class_die_ref
7648 && (c
= AT_ref (a
))->die_mark
== 0)
7650 struct external_ref
*ref_p
;
7651 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
7653 ref_p
= lookup_external_ref (extern_map
, c
);
7654 if (ref_p
->stub
&& ref_p
->stub
!= die
)
7655 change_AT_die_ref (a
, ref_p
->stub
);
7657 /* We aren't changing this reference, so mark it external. */
7658 set_AT_ref_external (a
, 1);
7661 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
7663 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
7664 dw_attr_ref die_a
, abbrev_a
;
7668 if (abbrev
->die_tag
!= die
->die_tag
)
7670 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
7673 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
7676 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
7678 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
7679 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
7680 || (value_format (abbrev_a
) != value_format (die_a
)))
7690 if (abbrev_id
>= abbrev_die_table_in_use
)
7692 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
7694 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
7695 abbrev_die_table
= GGC_RESIZEVEC (dw_die_ref
, abbrev_die_table
,
7698 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
7699 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
7700 abbrev_die_table_allocated
= n_alloc
;
7703 ++abbrev_die_table_in_use
;
7704 abbrev_die_table
[abbrev_id
] = die
;
7707 die
->die_abbrev
= abbrev_id
;
7708 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
7711 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7714 constant_size (unsigned HOST_WIDE_INT value
)
7721 log
= floor_log2 (value
);
7724 log
= 1 << (floor_log2 (log
) + 1);
7729 /* Return the size of a DIE as it is represented in the
7730 .debug_info section. */
7732 static unsigned long
7733 size_of_die (dw_die_ref die
)
7735 unsigned long size
= 0;
7738 enum dwarf_form form
;
7740 size
+= size_of_uleb128 (die
->die_abbrev
);
7741 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7743 switch (AT_class (a
))
7745 case dw_val_class_addr
:
7746 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7748 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7749 size
+= size_of_uleb128 (AT_index (a
));
7752 size
+= DWARF2_ADDR_SIZE
;
7754 case dw_val_class_offset
:
7755 size
+= DWARF_OFFSET_SIZE
;
7757 case dw_val_class_loc
:
7759 unsigned long lsize
= size_of_locs (AT_loc (a
));
7762 if (dwarf_version
>= 4)
7763 size
+= size_of_uleb128 (lsize
);
7765 size
+= constant_size (lsize
);
7769 case dw_val_class_loc_list
:
7770 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7772 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7773 size
+= size_of_uleb128 (AT_index (a
));
7776 size
+= DWARF_OFFSET_SIZE
;
7778 case dw_val_class_range_list
:
7779 size
+= DWARF_OFFSET_SIZE
;
7781 case dw_val_class_const
:
7782 size
+= size_of_sleb128 (AT_int (a
));
7784 case dw_val_class_unsigned_const
:
7786 int csize
= constant_size (AT_unsigned (a
));
7787 if (dwarf_version
== 3
7788 && a
->dw_attr
== DW_AT_data_member_location
7790 size
+= size_of_uleb128 (AT_unsigned (a
));
7795 case dw_val_class_const_double
:
7796 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
7797 if (HOST_BITS_PER_WIDE_INT
>= 64)
7800 case dw_val_class_vec
:
7801 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
7802 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
7803 + a
->dw_attr_val
.v
.val_vec
.length
7804 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
7806 case dw_val_class_flag
:
7807 if (dwarf_version
>= 4)
7808 /* Currently all add_AT_flag calls pass in 1 as last argument,
7809 so DW_FORM_flag_present can be used. If that ever changes,
7810 we'll need to use DW_FORM_flag and have some optimization
7811 in build_abbrev_table that will change those to
7812 DW_FORM_flag_present if it is set to 1 in all DIEs using
7813 the same abbrev entry. */
7814 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
7818 case dw_val_class_die_ref
:
7819 if (AT_ref_external (a
))
7821 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
7822 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
7823 is sized by target address length, whereas in DWARF3
7824 it's always sized as an offset. */
7825 if (use_debug_types
)
7826 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
7827 else if (dwarf_version
== 2)
7828 size
+= DWARF2_ADDR_SIZE
;
7830 size
+= DWARF_OFFSET_SIZE
;
7833 size
+= DWARF_OFFSET_SIZE
;
7835 case dw_val_class_fde_ref
:
7836 size
+= DWARF_OFFSET_SIZE
;
7838 case dw_val_class_lbl_id
:
7839 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
7841 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
7842 size
+= size_of_uleb128 (AT_index (a
));
7845 size
+= DWARF2_ADDR_SIZE
;
7847 case dw_val_class_lineptr
:
7848 case dw_val_class_macptr
:
7849 size
+= DWARF_OFFSET_SIZE
;
7851 case dw_val_class_str
:
7852 form
= AT_string_form (a
);
7853 if (form
== DW_FORM_strp
)
7854 size
+= DWARF_OFFSET_SIZE
;
7855 else if (form
== DW_FORM_GNU_str_index
)
7856 size
+= size_of_uleb128 (AT_index (a
));
7858 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
7860 case dw_val_class_file
:
7861 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
7863 case dw_val_class_data8
:
7866 case dw_val_class_vms_delta
:
7867 size
+= DWARF_OFFSET_SIZE
;
7869 case dw_val_class_high_pc
:
7870 size
+= DWARF2_ADDR_SIZE
;
7880 /* Size the debugging information associated with a given DIE. Visits the
7881 DIE's children recursively. Updates the global variable next_die_offset, on
7882 each time through. Uses the current value of next_die_offset to update the
7883 die_offset field in each DIE. */
7886 calc_die_sizes (dw_die_ref die
)
7890 gcc_assert (die
->die_offset
== 0
7891 || (unsigned long int) die
->die_offset
== next_die_offset
);
7892 die
->die_offset
= next_die_offset
;
7893 next_die_offset
+= size_of_die (die
);
7895 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
7897 if (die
->die_child
!= NULL
)
7898 /* Count the null byte used to terminate sibling lists. */
7899 next_die_offset
+= 1;
7902 /* Size just the base type children at the start of the CU.
7903 This is needed because build_abbrev needs to size locs
7904 and sizing of type based stack ops needs to know die_offset
7905 values for the base types. */
7908 calc_base_type_die_sizes (void)
7910 unsigned long die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
7912 dw_die_ref base_type
;
7913 #if ENABLE_ASSERT_CHECKING
7914 dw_die_ref prev
= comp_unit_die ()->die_child
;
7917 die_offset
+= size_of_die (comp_unit_die ());
7918 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
7920 #if ENABLE_ASSERT_CHECKING
7921 gcc_assert (base_type
->die_offset
== 0
7922 && prev
->die_sib
== base_type
7923 && base_type
->die_child
== NULL
7924 && base_type
->die_abbrev
);
7927 base_type
->die_offset
= die_offset
;
7928 die_offset
+= size_of_die (base_type
);
7932 /* Set the marks for a die and its children. We do this so
7933 that we know whether or not a reference needs to use FORM_ref_addr; only
7934 DIEs in the same CU will be marked. We used to clear out the offset
7935 and use that as the flag, but ran into ordering problems. */
7938 mark_dies (dw_die_ref die
)
7942 gcc_assert (!die
->die_mark
);
7945 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
7948 /* Clear the marks for a die and its children. */
7951 unmark_dies (dw_die_ref die
)
7955 if (! use_debug_types
)
7956 gcc_assert (die
->die_mark
);
7959 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
7962 /* Clear the marks for a die, its children and referred dies. */
7965 unmark_all_dies (dw_die_ref die
)
7975 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
7977 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7978 if (AT_class (a
) == dw_val_class_die_ref
)
7979 unmark_all_dies (AT_ref (a
));
7982 /* Calculate if the entry should appear in the final output file. It may be
7983 from a pruned a type. */
7986 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
7988 /* By limiting gnu pubnames to definitions only, gold can generate a
7989 gdb index without entries for declarations, which don't include
7990 enough information to be useful. */
7991 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
7994 if (table
== pubname_table
)
7996 /* Enumerator names are part of the pubname table, but the
7997 parent DW_TAG_enumeration_type die may have been pruned.
7998 Don't output them if that is the case. */
7999 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
8000 (p
->die
->die_parent
== NULL
8001 || !p
->die
->die_parent
->die_perennial_p
))
8004 /* Everything else in the pubname table is included. */
8008 /* The pubtypes table shouldn't include types that have been
8010 return (p
->die
->die_offset
!= 0
8011 || !flag_eliminate_unused_debug_types
);
8014 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8015 generated for the compilation unit. */
8017 static unsigned long
8018 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
8023 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
8025 size
= DWARF_PUBNAMES_HEADER_SIZE
;
8026 FOR_EACH_VEC_ELT (*names
, i
, p
)
8027 if (include_pubname_in_output (names
, p
))
8028 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
8030 size
+= DWARF_OFFSET_SIZE
;
8034 /* Return the size of the information in the .debug_aranges section. */
8036 static unsigned long
8037 size_of_aranges (void)
8041 size
= DWARF_ARANGES_HEADER_SIZE
;
8043 /* Count the address/length pair for this compilation unit. */
8044 if (text_section_used
)
8045 size
+= 2 * DWARF2_ADDR_SIZE
;
8046 if (cold_text_section_used
)
8047 size
+= 2 * DWARF2_ADDR_SIZE
;
8048 if (have_multiple_function_sections
)
8053 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
8055 if (DECL_IGNORED_P (fde
->decl
))
8057 if (!fde
->in_std_section
)
8058 size
+= 2 * DWARF2_ADDR_SIZE
;
8059 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
8060 size
+= 2 * DWARF2_ADDR_SIZE
;
8064 /* Count the two zero words used to terminated the address range table. */
8065 size
+= 2 * DWARF2_ADDR_SIZE
;
8069 /* Select the encoding of an attribute value. */
8071 static enum dwarf_form
8072 value_format (dw_attr_ref a
)
8074 switch (AT_class (a
))
8076 case dw_val_class_addr
:
8077 /* Only very few attributes allow DW_FORM_addr. */
8082 case DW_AT_entry_pc
:
8083 case DW_AT_trampoline
:
8084 return (AT_index (a
) == NOT_INDEXED
8085 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8089 switch (DWARF2_ADDR_SIZE
)
8092 return DW_FORM_data1
;
8094 return DW_FORM_data2
;
8096 return DW_FORM_data4
;
8098 return DW_FORM_data8
;
8102 case dw_val_class_range_list
:
8103 case dw_val_class_loc_list
:
8104 if (dwarf_version
>= 4)
8105 return DW_FORM_sec_offset
;
8107 case dw_val_class_vms_delta
:
8108 case dw_val_class_offset
:
8109 switch (DWARF_OFFSET_SIZE
)
8112 return DW_FORM_data4
;
8114 return DW_FORM_data8
;
8118 case dw_val_class_loc
:
8119 if (dwarf_version
>= 4)
8120 return DW_FORM_exprloc
;
8121 switch (constant_size (size_of_locs (AT_loc (a
))))
8124 return DW_FORM_block1
;
8126 return DW_FORM_block2
;
8128 return DW_FORM_block4
;
8132 case dw_val_class_const
:
8133 return DW_FORM_sdata
;
8134 case dw_val_class_unsigned_const
:
8135 switch (constant_size (AT_unsigned (a
)))
8138 return DW_FORM_data1
;
8140 return DW_FORM_data2
;
8142 /* In DWARF3 DW_AT_data_member_location with
8143 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8144 constant, so we need to use DW_FORM_udata if we need
8145 a large constant. */
8146 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8147 return DW_FORM_udata
;
8148 return DW_FORM_data4
;
8150 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8151 return DW_FORM_udata
;
8152 return DW_FORM_data8
;
8156 case dw_val_class_const_double
:
8157 switch (HOST_BITS_PER_WIDE_INT
)
8160 return DW_FORM_data2
;
8162 return DW_FORM_data4
;
8164 return DW_FORM_data8
;
8167 return DW_FORM_block1
;
8169 case dw_val_class_vec
:
8170 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
8171 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
8174 return DW_FORM_block1
;
8176 return DW_FORM_block2
;
8178 return DW_FORM_block4
;
8182 case dw_val_class_flag
:
8183 if (dwarf_version
>= 4)
8185 /* Currently all add_AT_flag calls pass in 1 as last argument,
8186 so DW_FORM_flag_present can be used. If that ever changes,
8187 we'll need to use DW_FORM_flag and have some optimization
8188 in build_abbrev_table that will change those to
8189 DW_FORM_flag_present if it is set to 1 in all DIEs using
8190 the same abbrev entry. */
8191 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
8192 return DW_FORM_flag_present
;
8194 return DW_FORM_flag
;
8195 case dw_val_class_die_ref
:
8196 if (AT_ref_external (a
))
8197 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
8200 case dw_val_class_fde_ref
:
8201 return DW_FORM_data
;
8202 case dw_val_class_lbl_id
:
8203 return (AT_index (a
) == NOT_INDEXED
8204 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
8205 case dw_val_class_lineptr
:
8206 case dw_val_class_macptr
:
8207 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
8208 case dw_val_class_str
:
8209 return AT_string_form (a
);
8210 case dw_val_class_file
:
8211 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
8214 return DW_FORM_data1
;
8216 return DW_FORM_data2
;
8218 return DW_FORM_data4
;
8223 case dw_val_class_data8
:
8224 return DW_FORM_data8
;
8226 case dw_val_class_high_pc
:
8227 switch (DWARF2_ADDR_SIZE
)
8230 return DW_FORM_data1
;
8232 return DW_FORM_data2
;
8234 return DW_FORM_data4
;
8236 return DW_FORM_data8
;
8246 /* Output the encoding of an attribute value. */
8249 output_value_format (dw_attr_ref a
)
8251 enum dwarf_form form
= value_format (a
);
8253 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
8256 /* Given a die and id, produce the appropriate abbreviations. */
8259 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
8264 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
8265 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
8266 dwarf_tag_name (abbrev
->die_tag
));
8268 if (abbrev
->die_child
!= NULL
)
8269 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
8271 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
8273 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
8275 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
8276 dwarf_attr_name (a_attr
->dw_attr
));
8277 output_value_format (a_attr
);
8280 dw2_asm_output_data (1, 0, NULL
);
8281 dw2_asm_output_data (1, 0, NULL
);
8285 /* Output the .debug_abbrev section which defines the DIE abbreviation
8289 output_abbrev_section (void)
8291 unsigned long abbrev_id
;
8293 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
8294 output_die_abbrevs (abbrev_id
, abbrev_die_table
[abbrev_id
]);
8296 /* Terminate the table. */
8297 dw2_asm_output_data (1, 0, NULL
);
8300 /* Output a symbol we can use to refer to this DIE from another CU. */
8303 output_die_symbol (dw_die_ref die
)
8305 const char *sym
= die
->die_id
.die_symbol
;
8307 gcc_assert (!die
->comdat_type_p
);
8312 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
8313 /* We make these global, not weak; if the target doesn't support
8314 .linkonce, it doesn't support combining the sections, so debugging
8316 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
8318 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
8321 /* Return a new location list, given the begin and end range, and the
8324 static inline dw_loc_list_ref
8325 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
8326 const char *section
)
8328 dw_loc_list_ref retlist
= ggc_alloc_cleared_dw_loc_list_node ();
8330 retlist
->begin
= begin
;
8331 retlist
->begin_entry
= NULL
;
8333 retlist
->expr
= expr
;
8334 retlist
->section
= section
;
8339 /* Generate a new internal symbol for this location list node, if it
8340 hasn't got one yet. */
8343 gen_llsym (dw_loc_list_ref list
)
8345 gcc_assert (!list
->ll_symbol
);
8346 list
->ll_symbol
= gen_internal_sym ("LLST");
8349 /* Output the location list given to us. */
8352 output_loc_list (dw_loc_list_ref list_head
)
8354 dw_loc_list_ref curr
= list_head
;
8356 if (list_head
->emitted
)
8358 list_head
->emitted
= true;
8360 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
8362 /* Walk the location list, and output each range + expression. */
8363 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
8366 /* Don't output an entry that starts and ends at the same address. */
8367 if (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
)
8369 size
= size_of_locs (curr
->expr
);
8370 /* If the expression is too large, drop it on the floor. We could
8371 perhaps put it into DW_TAG_dwarf_procedure and refer to that
8372 in the expression, but >= 64KB expressions for a single value
8373 in a single range are unlikely very useful. */
8376 if (dwarf_split_debug_info
)
8378 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
8379 "Location list start/length entry (%s)",
8380 list_head
->ll_symbol
);
8381 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
8382 "Location list range start index (%s)",
8384 /* The length field is 4 bytes. If we ever need to support
8385 an 8-byte length, we can add a new DW_LLE code or fall back
8386 to DW_LLE_GNU_start_end_entry. */
8387 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
8388 "Location list range length (%s)",
8389 list_head
->ll_symbol
);
8391 else if (!have_multiple_function_sections
)
8393 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
8394 "Location list begin address (%s)",
8395 list_head
->ll_symbol
);
8396 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
8397 "Location list end address (%s)",
8398 list_head
->ll_symbol
);
8402 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
8403 "Location list begin address (%s)",
8404 list_head
->ll_symbol
);
8405 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
8406 "Location list end address (%s)",
8407 list_head
->ll_symbol
);
8410 /* Output the block length for this list of location operations. */
8411 gcc_assert (size
<= 0xffff);
8412 dw2_asm_output_data (2, size
, "%s", "Location expression size");
8414 output_loc_sequence (curr
->expr
, -1);
8417 if (dwarf_split_debug_info
)
8418 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
8419 "Location list terminator (%s)",
8420 list_head
->ll_symbol
);
8423 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8424 "Location list terminator begin (%s)",
8425 list_head
->ll_symbol
);
8426 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8427 "Location list terminator end (%s)",
8428 list_head
->ll_symbol
);
8432 /* Output a range_list offset into the debug_range section. Emit a
8433 relocated reference if val_entry is NULL, otherwise, emit an
8434 indirect reference. */
8437 output_range_list_offset (dw_attr_ref a
)
8439 const char *name
= dwarf_attr_name (a
->dw_attr
);
8441 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
8443 char *p
= strchr (ranges_section_label
, '\0');
8444 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
, a
->dw_attr_val
.v
.val_offset
);
8445 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
8446 debug_ranges_section
, "%s", name
);
8450 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8451 "%s (offset from %s)", name
, ranges_section_label
);
8454 /* Output the offset into the debug_loc section. */
8457 output_loc_list_offset (dw_attr_ref a
)
8459 char *sym
= AT_loc_list (a
)->ll_symbol
;
8462 if (dwarf_split_debug_info
)
8463 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
8464 "%s", dwarf_attr_name (a
->dw_attr
));
8466 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
8467 "%s", dwarf_attr_name (a
->dw_attr
));
8470 /* Output an attribute's index or value appropriately. */
8473 output_attr_index_or_value (dw_attr_ref a
)
8475 const char *name
= dwarf_attr_name (a
->dw_attr
);
8477 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8479 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
8482 switch (AT_class (a
))
8484 case dw_val_class_addr
:
8485 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
8487 case dw_val_class_high_pc
:
8488 case dw_val_class_lbl_id
:
8489 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
8491 case dw_val_class_loc_list
:
8492 output_loc_list_offset (a
);
8499 /* Output a type signature. */
8502 output_signature (const char *sig
, const char *name
)
8506 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
8507 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
8510 /* Output the DIE and its attributes. Called recursively to generate
8511 the definitions of each child DIE. */
8514 output_die (dw_die_ref die
)
8521 /* If someone in another CU might refer to us, set up a symbol for
8522 them to point to. */
8523 if (! die
->comdat_type_p
&& die
->die_id
.die_symbol
)
8524 output_die_symbol (die
);
8526 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
8527 (unsigned long)die
->die_offset
,
8528 dwarf_tag_name (die
->die_tag
));
8530 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8532 const char *name
= dwarf_attr_name (a
->dw_attr
);
8534 switch (AT_class (a
))
8536 case dw_val_class_addr
:
8537 output_attr_index_or_value (a
);
8540 case dw_val_class_offset
:
8541 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8545 case dw_val_class_range_list
:
8546 output_range_list_offset (a
);
8549 case dw_val_class_loc
:
8550 size
= size_of_locs (AT_loc (a
));
8552 /* Output the block length for this list of location operations. */
8553 if (dwarf_version
>= 4)
8554 dw2_asm_output_data_uleb128 (size
, "%s", name
);
8556 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
8558 output_loc_sequence (AT_loc (a
), -1);
8561 case dw_val_class_const
:
8562 /* ??? It would be slightly more efficient to use a scheme like is
8563 used for unsigned constants below, but gdb 4.x does not sign
8564 extend. Gdb 5.x does sign extend. */
8565 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
8568 case dw_val_class_unsigned_const
:
8570 int csize
= constant_size (AT_unsigned (a
));
8571 if (dwarf_version
== 3
8572 && a
->dw_attr
== DW_AT_data_member_location
8574 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
8576 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
8580 case dw_val_class_const_double
:
8582 unsigned HOST_WIDE_INT first
, second
;
8584 if (HOST_BITS_PER_WIDE_INT
>= 64)
8585 dw2_asm_output_data (1,
8586 HOST_BITS_PER_DOUBLE_INT
8587 / HOST_BITS_PER_CHAR
,
8590 if (WORDS_BIG_ENDIAN
)
8592 first
= a
->dw_attr_val
.v
.val_double
.high
;
8593 second
= a
->dw_attr_val
.v
.val_double
.low
;
8597 first
= a
->dw_attr_val
.v
.val_double
.low
;
8598 second
= a
->dw_attr_val
.v
.val_double
.high
;
8601 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8603 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8608 case dw_val_class_vec
:
8610 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
8611 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
8615 dw2_asm_output_data (constant_size (len
* elt_size
),
8616 len
* elt_size
, "%s", name
);
8617 if (elt_size
> sizeof (HOST_WIDE_INT
))
8622 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
8625 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
8626 "fp or vector constant word %u", i
);
8630 case dw_val_class_flag
:
8631 if (dwarf_version
>= 4)
8633 /* Currently all add_AT_flag calls pass in 1 as last argument,
8634 so DW_FORM_flag_present can be used. If that ever changes,
8635 we'll need to use DW_FORM_flag and have some optimization
8636 in build_abbrev_table that will change those to
8637 DW_FORM_flag_present if it is set to 1 in all DIEs using
8638 the same abbrev entry. */
8639 gcc_assert (AT_flag (a
) == 1);
8641 fprintf (asm_out_file
, "\t\t\t%s %s\n",
8642 ASM_COMMENT_START
, name
);
8645 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
8648 case dw_val_class_loc_list
:
8649 output_attr_index_or_value (a
);
8652 case dw_val_class_die_ref
:
8653 if (AT_ref_external (a
))
8655 if (AT_ref (a
)->comdat_type_p
)
8657 comdat_type_node_ref type_node
=
8658 AT_ref (a
)->die_id
.die_type_node
;
8660 gcc_assert (type_node
);
8661 output_signature (type_node
->signature
, name
);
8665 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
8669 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8670 length, whereas in DWARF3 it's always sized as an
8672 if (dwarf_version
== 2)
8673 size
= DWARF2_ADDR_SIZE
;
8675 size
= DWARF_OFFSET_SIZE
;
8676 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
8682 gcc_assert (AT_ref (a
)->die_offset
);
8683 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
8688 case dw_val_class_fde_ref
:
8692 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
8693 a
->dw_attr_val
.v
.val_fde_index
* 2);
8694 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
8699 case dw_val_class_vms_delta
:
8700 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
8701 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
8705 case dw_val_class_lbl_id
:
8706 output_attr_index_or_value (a
);
8709 case dw_val_class_lineptr
:
8710 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8711 debug_line_section
, "%s", name
);
8714 case dw_val_class_macptr
:
8715 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8716 debug_macinfo_section
, "%s", name
);
8719 case dw_val_class_str
:
8720 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
8721 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
8722 a
->dw_attr_val
.v
.val_str
->label
,
8724 "%s: \"%s\"", name
, AT_string (a
));
8725 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_GNU_str_index
)
8726 dw2_asm_output_data_uleb128 (AT_index (a
),
8727 "%s: \"%s\"", name
, AT_string (a
));
8729 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
8732 case dw_val_class_file
:
8734 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
8736 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
8737 a
->dw_attr_val
.v
.val_file
->filename
);
8741 case dw_val_class_data8
:
8745 for (i
= 0; i
< 8; i
++)
8746 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
8747 i
== 0 ? "%s" : NULL
, name
);
8751 case dw_val_class_high_pc
:
8752 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
8753 get_AT_low_pc (die
), "DW_AT_high_pc");
8761 FOR_EACH_CHILD (die
, c
, output_die (c
));
8763 /* Add null byte to terminate sibling list. */
8764 if (die
->die_child
!= NULL
)
8765 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
8766 (unsigned long) die
->die_offset
);
8769 /* Output the compilation unit that appears at the beginning of the
8770 .debug_info section, and precedes the DIE descriptions. */
8773 output_compilation_unit_header (void)
8775 int ver
= dwarf_version
;
8777 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8778 dw2_asm_output_data (4, 0xffffffff,
8779 "Initial length escape value indicating 64-bit DWARF extension");
8780 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
8781 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
8782 "Length of Compilation Unit Info");
8783 dw2_asm_output_data (2, ver
, "DWARF version number");
8784 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
8785 debug_abbrev_section
,
8786 "Offset Into Abbrev. Section");
8787 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
8790 /* Output the compilation unit DIE and its children. */
8793 output_comp_unit (dw_die_ref die
, int output_if_empty
)
8795 const char *secname
, *oldsym
;
8797 external_ref_hash_type extern_map
;
8799 /* Unless we are outputting main CU, we may throw away empty ones. */
8800 if (!output_if_empty
&& die
->die_child
== NULL
)
8803 /* Even if there are no children of this DIE, we must output the information
8804 about the compilation unit. Otherwise, on an empty translation unit, we
8805 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8806 will then complain when examining the file. First mark all the DIEs in
8807 this CU so we know which get local refs. */
8810 extern_map
= optimize_external_refs (die
);
8812 build_abbrev_table (die
, extern_map
);
8814 extern_map
.dispose ();
8816 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8817 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8818 calc_die_sizes (die
);
8820 oldsym
= die
->die_id
.die_symbol
;
8823 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
8825 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
8827 die
->die_id
.die_symbol
= NULL
;
8828 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
8832 switch_to_section (debug_info_section
);
8833 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
8834 info_section_emitted
= true;
8837 /* Output debugging information. */
8838 output_compilation_unit_header ();
8841 /* Leave the marks on the main CU, so we can check them in
8846 die
->die_id
.die_symbol
= oldsym
;
8850 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
8851 and .debug_pubtypes. This is configured per-target, but can be
8852 overridden by the -gpubnames or -gno-pubnames options. */
8855 want_pubnames (void)
8857 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
8859 if (debug_generate_pub_sections
!= -1)
8860 return debug_generate_pub_sections
;
8861 return targetm
.want_debug_pub_sections
;
8864 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
8867 add_AT_pubnames (dw_die_ref die
)
8869 if (want_pubnames ())
8870 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
8873 /* Add a string attribute value to a skeleton DIE. */
8876 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
8880 struct indirect_string_node
*node
;
8882 if (! skeleton_debug_str_hash
)
8883 skeleton_debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
8884 debug_str_eq
, NULL
);
8886 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
8887 find_string_form (node
);
8888 if (node
->form
== DW_FORM_GNU_str_index
)
8889 node
->form
= DW_FORM_strp
;
8891 attr
.dw_attr
= attr_kind
;
8892 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
8893 attr
.dw_attr_val
.val_entry
= NULL
;
8894 attr
.dw_attr_val
.v
.val_str
= node
;
8895 add_dwarf_attr (die
, &attr
);
8898 /* Helper function to generate top-level dies for skeleton debug_info and
8902 add_top_level_skeleton_die_attrs (dw_die_ref die
)
8904 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
8905 const char *comp_dir
= comp_dir_string ();
8907 add_skeleton_AT_string (die
, DW_AT_GNU_dwo_name
, dwo_file_name
);
8908 if (comp_dir
!= NULL
)
8909 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
8910 add_AT_pubnames (die
);
8911 add_AT_lineptr (die
, DW_AT_GNU_addr_base
, debug_addr_section_label
);
8914 /* Return the single type-unit die for skeleton type units. */
8917 get_skeleton_type_unit (void)
8919 /* For dwarf_split_debug_sections with use_type info, all type units in the
8920 skeleton sections have identical dies (but different headers). This
8921 single die will be output many times. */
8923 static dw_die_ref skeleton_type_unit
= NULL
;
8925 if (skeleton_type_unit
== NULL
)
8927 skeleton_type_unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8928 add_top_level_skeleton_die_attrs (skeleton_type_unit
);
8929 skeleton_type_unit
->die_abbrev
= SKELETON_TYPE_DIE_ABBREV
;
8931 return skeleton_type_unit
;
8934 /* Output skeleton debug sections that point to the dwo file. */
8937 output_skeleton_debug_sections (dw_die_ref comp_unit
)
8939 /* These attributes will be found in the full debug_info section. */
8940 remove_AT (comp_unit
, DW_AT_producer
);
8941 remove_AT (comp_unit
, DW_AT_language
);
8943 switch_to_section (debug_skeleton_info_section
);
8944 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
8946 /* Produce the skeleton compilation-unit header. This one differs enough from
8947 a normal CU header that it's better not to call output_compilation_unit
8949 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8950 dw2_asm_output_data (4, 0xffffffff,
8951 "Initial length escape value indicating 64-bit DWARF extension");
8953 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
8954 DWARF_COMPILE_UNIT_HEADER_SIZE
8955 - DWARF_INITIAL_LENGTH_SIZE
8956 + size_of_die (comp_unit
),
8957 "Length of Compilation Unit Info");
8958 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
8959 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
8960 debug_abbrev_section
,
8961 "Offset Into Abbrev. Section");
8962 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
8964 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
8965 output_die (comp_unit
);
8967 /* Build the skeleton debug_abbrev section. */
8968 switch_to_section (debug_skeleton_abbrev_section
);
8969 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
8971 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
8972 if (use_debug_types
)
8973 output_die_abbrevs (SKELETON_TYPE_DIE_ABBREV
, get_skeleton_type_unit ());
8975 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
8978 /* Output a comdat type unit DIE and its children. */
8981 output_comdat_type_unit (comdat_type_node
*node
)
8983 const char *secname
;
8986 #if defined (OBJECT_FORMAT_ELF)
8989 external_ref_hash_type extern_map
;
8991 /* First mark all the DIEs in this CU so we know which get local refs. */
8992 mark_dies (node
->root_die
);
8994 extern_map
= optimize_external_refs (node
->root_die
);
8996 build_abbrev_table (node
->root_die
, extern_map
);
8998 extern_map
.dispose ();
9000 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9001 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
9002 calc_die_sizes (node
->root_die
);
9004 #if defined (OBJECT_FORMAT_ELF)
9005 if (!dwarf_split_debug_info
)
9006 secname
= ".debug_types";
9008 secname
= ".debug_types.dwo";
9010 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9011 sprintf (tmp
, "wt.");
9012 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9013 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9014 comdat_key
= get_identifier (tmp
);
9015 targetm
.asm_out
.named_section (secname
,
9016 SECTION_DEBUG
| SECTION_LINKONCE
,
9019 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
9020 sprintf (tmp
, ".gnu.linkonce.wt.");
9021 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9022 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
9024 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
9027 /* Output debugging information. */
9028 output_compilation_unit_header ();
9029 output_signature (node
->signature
, "Type Signature");
9030 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
9031 "Offset to Type DIE");
9032 output_die (node
->root_die
);
9034 unmark_dies (node
->root_die
);
9036 #if defined (OBJECT_FORMAT_ELF)
9037 if (dwarf_split_debug_info
)
9039 /* Produce the skeleton type-unit header. */
9040 const char *secname
= ".debug_types";
9042 targetm
.asm_out
.named_section (secname
,
9043 SECTION_DEBUG
| SECTION_LINKONCE
,
9045 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9046 dw2_asm_output_data (4, 0xffffffff,
9047 "Initial length escape value indicating 64-bit DWARF extension");
9049 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9050 DWARF_COMPILE_UNIT_HEADER_SIZE
9051 - DWARF_INITIAL_LENGTH_SIZE
9052 + size_of_die (get_skeleton_type_unit ())
9053 + DWARF_TYPE_SIGNATURE_SIZE
+ DWARF_OFFSET_SIZE
,
9054 "Length of Type Unit Info");
9055 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
9056 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
9057 debug_skeleton_abbrev_section_label
,
9058 debug_abbrev_section
,
9059 "Offset Into Abbrev. Section");
9060 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
9061 output_signature (node
->signature
, "Type Signature");
9062 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, "Offset to Type DIE");
9064 output_die (get_skeleton_type_unit ());
9069 /* Return the DWARF2/3 pubname associated with a decl. */
9072 dwarf2_name (tree decl
, int scope
)
9074 if (DECL_NAMELESS (decl
))
9076 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
9079 /* Add a new entry to .debug_pubnames if appropriate. */
9082 add_pubname_string (const char *str
, dw_die_ref die
)
9087 e
.name
= xstrdup (str
);
9088 vec_safe_push (pubname_table
, e
);
9092 add_pubname (tree decl
, dw_die_ref die
)
9094 if (!want_pubnames ())
9097 /* Don't add items to the table when we expect that the consumer will have
9098 just read the enclosing die. For example, if the consumer is looking at a
9099 class_member, it will either be inside the class already, or will have just
9100 looked up the class to find the member. Either way, searching the class is
9101 faster than searching the index. */
9102 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
9103 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9105 const char *name
= dwarf2_name (decl
, 1);
9108 add_pubname_string (name
, die
);
9112 /* Add an enumerator to the pubnames section. */
9115 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
9119 gcc_assert (scope_name
);
9120 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
9122 vec_safe_push (pubname_table
, e
);
9125 /* Add a new entry to .debug_pubtypes if appropriate. */
9128 add_pubtype (tree decl
, dw_die_ref die
)
9132 if (!want_pubnames ())
9135 if ((TREE_PUBLIC (decl
)
9136 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
9137 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
9140 const char *scope_name
= "";
9141 const char *sep
= is_cxx () ? "::" : ".";
9144 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
9145 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
9147 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
9148 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
9149 scope_name
= concat (scope_name
, sep
, NULL
);
9155 name
= type_tag (decl
);
9157 name
= lang_hooks
.dwarf_name (decl
, 1);
9159 /* If we don't have a name for the type, there's no point in adding
9161 if (name
!= NULL
&& name
[0] != '\0')
9164 e
.name
= concat (scope_name
, name
, NULL
);
9165 vec_safe_push (pubtype_table
, e
);
9168 /* Although it might be more consistent to add the pubinfo for the
9169 enumerators as their dies are created, they should only be added if the
9170 enum type meets the criteria above. So rather than re-check the parent
9171 enum type whenever an enumerator die is created, just output them all
9172 here. This isn't protected by the name conditional because anonymous
9173 enums don't have names. */
9174 if (die
->die_tag
== DW_TAG_enumeration_type
)
9178 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
9183 /* Output a single entry in the pubnames table. */
9186 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
9188 dw_die_ref die
= entry
->die
;
9189 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
9191 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
9193 if (debug_generate_pub_sections
== 2)
9195 /* This logic follows gdb's method for determining the value of the flag
9197 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
9198 switch (die
->die_tag
)
9200 case DW_TAG_typedef
:
9201 case DW_TAG_base_type
:
9202 case DW_TAG_subrange_type
:
9203 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9204 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9206 case DW_TAG_enumerator
:
9207 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9208 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9209 if (!is_cxx () && !is_java ())
9210 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9212 case DW_TAG_subprogram
:
9213 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9214 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
9216 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9218 case DW_TAG_constant
:
9219 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9220 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9221 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9223 case DW_TAG_variable
:
9224 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
9225 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
9226 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
9228 case DW_TAG_namespace
:
9229 case DW_TAG_imported_declaration
:
9230 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9232 case DW_TAG_class_type
:
9233 case DW_TAG_interface_type
:
9234 case DW_TAG_structure_type
:
9235 case DW_TAG_union_type
:
9236 case DW_TAG_enumeration_type
:
9237 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
9238 if (!is_cxx () && !is_java ())
9239 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
9242 /* An unusual tag. Leave the flag-byte empty. */
9245 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
9249 dw2_asm_output_nstring (entry
->name
, -1, "external name");
9253 /* Output the public names table used to speed up access to externally
9254 visible names; or the public types table used to find type definitions. */
9257 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9260 unsigned long pubnames_length
= size_of_pubnames (names
);
9263 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9264 dw2_asm_output_data (4, 0xffffffff,
9265 "Initial length escape value indicating 64-bit DWARF extension");
9266 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
, "Pub Info Length");
9268 /* Version number for pubnames/pubtypes is independent of dwarf version. */
9269 dw2_asm_output_data (2, 2, "DWARF Version");
9271 if (dwarf_split_debug_info
)
9272 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9273 debug_skeleton_info_section
,
9274 "Offset of Compilation Unit Info");
9276 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9278 "Offset of Compilation Unit Info");
9279 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
9280 "Compilation Unit Length");
9282 FOR_EACH_VEC_ELT (*names
, i
, pub
)
9284 if (include_pubname_in_output (names
, pub
))
9286 dw_offset die_offset
= pub
->die
->die_offset
;
9288 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9289 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
9290 gcc_assert (pub
->die
->die_mark
);
9292 /* If we're putting types in their own .debug_types sections,
9293 the .debug_pubtypes table will still point to the compile
9294 unit (not the type unit), so we want to use the offset of
9295 the skeleton DIE (if there is one). */
9296 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
9298 comdat_type_node_ref type_node
= pub
->die
->die_id
.die_type_node
;
9300 if (type_node
!= NULL
)
9301 die_offset
= (type_node
->skeleton_die
!= NULL
9302 ? type_node
->skeleton_die
->die_offset
9303 : comp_unit_die ()->die_offset
);
9306 output_pubname (die_offset
, pub
);
9310 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
9313 /* Output public names and types tables if necessary. */
9316 output_pubtables (void)
9318 if (!want_pubnames () || !info_section_emitted
)
9321 switch_to_section (debug_pubnames_section
);
9322 output_pubnames (pubname_table
);
9323 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
9324 It shouldn't hurt to emit it always, since pure DWARF2 consumers
9325 simply won't look for the section. */
9326 switch_to_section (debug_pubtypes_section
);
9327 output_pubnames (pubtype_table
);
9331 /* Output the information that goes into the .debug_aranges table.
9332 Namely, define the beginning and ending address range of the
9333 text section generated for this compilation unit. */
9336 output_aranges (unsigned long aranges_length
)
9340 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9341 dw2_asm_output_data (4, 0xffffffff,
9342 "Initial length escape value indicating 64-bit DWARF extension");
9343 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
9344 "Length of Address Ranges Info");
9345 /* Version number for aranges is still 2, even in DWARF3. */
9346 dw2_asm_output_data (2, 2, "DWARF Version");
9347 if (dwarf_split_debug_info
)
9348 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
9349 debug_skeleton_info_section
,
9350 "Offset of Compilation Unit Info");
9352 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
9354 "Offset of Compilation Unit Info");
9355 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
9356 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9358 /* We need to align to twice the pointer size here. */
9359 if (DWARF_ARANGES_PAD_SIZE
)
9361 /* Pad using a 2 byte words so that padding is correct for any
9363 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9364 2 * DWARF2_ADDR_SIZE
);
9365 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
9366 dw2_asm_output_data (2, 0, NULL
);
9369 /* It is necessary not to output these entries if the sections were
9370 not used; if the sections were not used, the length will be 0 and
9371 the address may end up as 0 if the section is discarded by ld
9372 --gc-sections, leaving an invalid (0, 0) entry that can be
9373 confused with the terminator. */
9374 if (text_section_used
)
9376 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
9377 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
9378 text_section_label
, "Length");
9380 if (cold_text_section_used
)
9382 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
9384 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
9385 cold_text_section_label
, "Length");
9388 if (have_multiple_function_sections
)
9393 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9395 if (DECL_IGNORED_P (fde
->decl
))
9397 if (!fde
->in_std_section
)
9399 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
9401 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
9402 fde
->dw_fde_begin
, "Length");
9404 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9406 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
9408 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
9409 fde
->dw_fde_second_begin
, "Length");
9414 /* Output the terminator words. */
9415 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9416 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9419 /* Add a new entry to .debug_ranges. Return the offset at which it
9423 add_ranges_num (int num
)
9425 unsigned int in_use
= ranges_table_in_use
;
9427 if (in_use
== ranges_table_allocated
)
9429 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
9430 ranges_table
= GGC_RESIZEVEC (struct dw_ranges_struct
, ranges_table
,
9431 ranges_table_allocated
);
9432 memset (ranges_table
+ ranges_table_in_use
, 0,
9433 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
9436 ranges_table
[in_use
].num
= num
;
9437 ranges_table_in_use
= in_use
+ 1;
9439 return in_use
* 2 * DWARF2_ADDR_SIZE
;
9442 /* Add a new entry to .debug_ranges corresponding to a block, or a
9443 range terminator if BLOCK is NULL. */
9446 add_ranges (const_tree block
)
9448 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0);
9451 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
9452 When using dwarf_split_debug_info, address attributes in dies destined
9453 for the final executable should be direct references--setting the
9454 parameter force_direct ensures this behavior. */
9457 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
9458 bool *added
, bool force_direct
)
9460 unsigned int in_use
= ranges_by_label_in_use
;
9461 unsigned int offset
;
9463 if (in_use
== ranges_by_label_allocated
)
9465 ranges_by_label_allocated
+= RANGES_TABLE_INCREMENT
;
9466 ranges_by_label
= GGC_RESIZEVEC (struct dw_ranges_by_label_struct
,
9468 ranges_by_label_allocated
);
9469 memset (ranges_by_label
+ ranges_by_label_in_use
, 0,
9470 RANGES_TABLE_INCREMENT
9471 * sizeof (struct dw_ranges_by_label_struct
));
9474 ranges_by_label
[in_use
].begin
= begin
;
9475 ranges_by_label
[in_use
].end
= end
;
9476 ranges_by_label_in_use
= in_use
+ 1;
9478 offset
= add_ranges_num (-(int)in_use
- 1);
9481 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
9487 output_ranges (void)
9490 static const char *const start_fmt
= "Offset %#x";
9491 const char *fmt
= start_fmt
;
9493 for (i
= 0; i
< ranges_table_in_use
; i
++)
9495 int block_num
= ranges_table
[i
].num
;
9499 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
9500 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
9502 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
9503 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
9505 /* If all code is in the text section, then the compilation
9506 unit base address defaults to DW_AT_low_pc, which is the
9507 base of the text section. */
9508 if (!have_multiple_function_sections
)
9510 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
9512 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9513 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
9514 text_section_label
, NULL
);
9517 /* Otherwise, the compilation unit base address is zero,
9518 which allows us to use absolute addresses, and not worry
9519 about whether the target supports cross-section
9523 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
9524 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9525 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
9531 /* Negative block_num stands for an index into ranges_by_label. */
9532 else if (block_num
< 0)
9534 int lab_idx
= - block_num
- 1;
9536 if (!have_multiple_function_sections
)
9540 /* If we ever use add_ranges_by_labels () for a single
9541 function section, all we have to do is to take out
9543 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9544 ranges_by_label
[lab_idx
].begin
,
9546 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9547 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9548 ranges_by_label
[lab_idx
].end
,
9549 text_section_label
, NULL
);
9554 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9555 ranges_by_label
[lab_idx
].begin
,
9556 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9557 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9558 ranges_by_label
[lab_idx
].end
,
9564 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9565 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9571 /* Data structure containing information about input files. */
9574 const char *path
; /* Complete file name. */
9575 const char *fname
; /* File name part. */
9576 int length
; /* Length of entire string. */
9577 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
9578 int dir_idx
; /* Index in directory table. */
9581 /* Data structure containing information about directories with source
9585 const char *path
; /* Path including directory name. */
9586 int length
; /* Path length. */
9587 int prefix
; /* Index of directory entry which is a prefix. */
9588 int count
; /* Number of files in this directory. */
9589 int dir_idx
; /* Index of directory used as base. */
9592 /* Callback function for file_info comparison. We sort by looking at
9593 the directories in the path. */
9596 file_info_cmp (const void *p1
, const void *p2
)
9598 const struct file_info
*const s1
= (const struct file_info
*) p1
;
9599 const struct file_info
*const s2
= (const struct file_info
*) p2
;
9600 const unsigned char *cp1
;
9601 const unsigned char *cp2
;
9603 /* Take care of file names without directories. We need to make sure that
9604 we return consistent values to qsort since some will get confused if
9605 we return the same value when identical operands are passed in opposite
9606 orders. So if neither has a directory, return 0 and otherwise return
9607 1 or -1 depending on which one has the directory. */
9608 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
9609 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
9611 cp1
= (const unsigned char *) s1
->path
;
9612 cp2
= (const unsigned char *) s2
->path
;
9618 /* Reached the end of the first path? If so, handle like above. */
9619 if ((cp1
== (const unsigned char *) s1
->fname
)
9620 || (cp2
== (const unsigned char *) s2
->fname
))
9621 return ((cp2
== (const unsigned char *) s2
->fname
)
9622 - (cp1
== (const unsigned char *) s1
->fname
));
9624 /* Character of current path component the same? */
9625 else if (*cp1
!= *cp2
)
9630 struct file_name_acquire_data
9632 struct file_info
*files
;
9637 /* Traversal function for the hash table. */
9640 file_name_acquire (void ** slot
, void *data
)
9642 struct file_name_acquire_data
*fnad
= (struct file_name_acquire_data
*) data
;
9643 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
9644 struct file_info
*fi
;
9647 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
9649 if (! d
->emitted_number
)
9652 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
9654 fi
= fnad
->files
+ fnad
->used_files
++;
9656 /* Skip all leading "./". */
9658 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
9661 /* Create a new array entry. */
9663 fi
->length
= strlen (f
);
9666 /* Search for the file name part. */
9667 f
= strrchr (f
, DIR_SEPARATOR
);
9668 #if defined (DIR_SEPARATOR_2)
9670 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
9674 if (f
== NULL
|| f
< g
)
9680 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
9684 /* Output the directory table and the file name table. We try to minimize
9685 the total amount of memory needed. A heuristic is used to avoid large
9686 slowdowns with many input files. */
9689 output_file_names (void)
9691 struct file_name_acquire_data fnad
;
9693 struct file_info
*files
;
9694 struct dir_info
*dirs
;
9702 if (!last_emitted_file
)
9704 dw2_asm_output_data (1, 0, "End directory table");
9705 dw2_asm_output_data (1, 0, "End file name table");
9709 numfiles
= last_emitted_file
->emitted_number
;
9711 /* Allocate the various arrays we need. */
9712 files
= XALLOCAVEC (struct file_info
, numfiles
);
9713 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
9716 fnad
.used_files
= 0;
9717 fnad
.max_files
= numfiles
;
9718 htab_traverse (file_table
, file_name_acquire
, &fnad
);
9719 gcc_assert (fnad
.used_files
== fnad
.max_files
);
9721 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
9723 /* Find all the different directories used. */
9724 dirs
[0].path
= files
[0].path
;
9725 dirs
[0].length
= files
[0].fname
- files
[0].path
;
9726 dirs
[0].prefix
= -1;
9728 dirs
[0].dir_idx
= 0;
9729 files
[0].dir_idx
= 0;
9732 for (i
= 1; i
< numfiles
; i
++)
9733 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
9734 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
9735 dirs
[ndirs
- 1].length
) == 0)
9737 /* Same directory as last entry. */
9738 files
[i
].dir_idx
= ndirs
- 1;
9739 ++dirs
[ndirs
- 1].count
;
9745 /* This is a new directory. */
9746 dirs
[ndirs
].path
= files
[i
].path
;
9747 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
9748 dirs
[ndirs
].count
= 1;
9749 dirs
[ndirs
].dir_idx
= ndirs
;
9750 files
[i
].dir_idx
= ndirs
;
9752 /* Search for a prefix. */
9753 dirs
[ndirs
].prefix
= -1;
9754 for (j
= 0; j
< ndirs
; j
++)
9755 if (dirs
[j
].length
< dirs
[ndirs
].length
9756 && dirs
[j
].length
> 1
9757 && (dirs
[ndirs
].prefix
== -1
9758 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
9759 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
9760 dirs
[ndirs
].prefix
= j
;
9765 /* Now to the actual work. We have to find a subset of the directories which
9766 allow expressing the file name using references to the directory table
9767 with the least amount of characters. We do not do an exhaustive search
9768 where we would have to check out every combination of every single
9769 possible prefix. Instead we use a heuristic which provides nearly optimal
9770 results in most cases and never is much off. */
9771 saved
= XALLOCAVEC (int, ndirs
);
9772 savehere
= XALLOCAVEC (int, ndirs
);
9774 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
9775 for (i
= 0; i
< ndirs
; i
++)
9780 /* We can always save some space for the current directory. But this
9781 does not mean it will be enough to justify adding the directory. */
9782 savehere
[i
] = dirs
[i
].length
;
9783 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
9785 for (j
= i
+ 1; j
< ndirs
; j
++)
9788 if (saved
[j
] < dirs
[i
].length
)
9790 /* Determine whether the dirs[i] path is a prefix of the
9795 while (k
!= -1 && k
!= (int) i
)
9800 /* Yes it is. We can possibly save some memory by
9801 writing the filenames in dirs[j] relative to
9803 savehere
[j
] = dirs
[i
].length
;
9804 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
9809 /* Check whether we can save enough to justify adding the dirs[i]
9811 if (total
> dirs
[i
].length
+ 1)
9813 /* It's worthwhile adding. */
9814 for (j
= i
; j
< ndirs
; j
++)
9815 if (savehere
[j
] > 0)
9817 /* Remember how much we saved for this directory so far. */
9818 saved
[j
] = savehere
[j
];
9820 /* Remember the prefix directory. */
9821 dirs
[j
].dir_idx
= i
;
9826 /* Emit the directory name table. */
9827 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
9828 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
9829 dw2_asm_output_nstring (dirs
[i
].path
,
9831 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
9832 "Directory Entry: %#x", i
+ idx_offset
);
9834 dw2_asm_output_data (1, 0, "End directory table");
9836 /* We have to emit them in the order of emitted_number since that's
9837 used in the debug info generation. To do this efficiently we
9838 generate a back-mapping of the indices first. */
9839 backmap
= XALLOCAVEC (int, numfiles
);
9840 for (i
= 0; i
< numfiles
; i
++)
9841 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
9843 /* Now write all the file names. */
9844 for (i
= 0; i
< numfiles
; i
++)
9846 int file_idx
= backmap
[i
];
9847 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
9849 #ifdef VMS_DEBUGGING_INFO
9850 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
9852 /* Setting these fields can lead to debugger miscomparisons,
9853 but VMS Debug requires them to be set correctly. */
9858 int maxfilelen
= strlen (files
[file_idx
].path
)
9859 + dirs
[dir_idx
].length
9860 + MAX_VMS_VERSION_LEN
+ 1;
9861 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
9863 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
9864 snprintf (filebuf
, maxfilelen
, "%s;%d",
9865 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
9867 dw2_asm_output_nstring
9868 (filebuf
, -1, "File Entry: %#x", (unsigned) i
+ 1);
9870 /* Include directory index. */
9871 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
9873 /* Modification time. */
9874 dw2_asm_output_data_uleb128
9875 ((vms_file_stats_name (files
[file_idx
].path
, &cdt
, 0, 0, 0) == 0)
9879 /* File length in bytes. */
9880 dw2_asm_output_data_uleb128
9881 ((vms_file_stats_name (files
[file_idx
].path
, 0, &siz
, 0, 0) == 0)
9885 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
9886 "File Entry: %#x", (unsigned) i
+ 1);
9888 /* Include directory index. */
9889 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
9891 /* Modification time. */
9892 dw2_asm_output_data_uleb128 (0, NULL
);
9894 /* File length in bytes. */
9895 dw2_asm_output_data_uleb128 (0, NULL
);
9896 #endif /* VMS_DEBUGGING_INFO */
9899 dw2_asm_output_data (1, 0, "End file name table");
9903 /* Output one line number table into the .debug_line section. */
9906 output_one_line_info_table (dw_line_info_table
*table
)
9908 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
9909 unsigned int current_line
= 1;
9910 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
9911 dw_line_info_entry
*ent
;
9914 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
9916 switch (ent
->opcode
)
9918 case LI_set_address
:
9919 /* ??? Unfortunately, we have little choice here currently, and
9920 must always use the most general form. GCC does not know the
9921 address delta itself, so we can't use DW_LNS_advance_pc. Many
9922 ports do have length attributes which will give an upper bound
9923 on the address range. We could perhaps use length attributes
9924 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
9925 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
9927 /* This can handle any delta. This takes
9928 4+DWARF2_ADDR_SIZE bytes. */
9929 dw2_asm_output_data (1, 0, "set address %s", line_label
);
9930 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
9931 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
9932 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
9936 if (ent
->val
== current_line
)
9938 /* We still need to start a new row, so output a copy insn. */
9939 dw2_asm_output_data (1, DW_LNS_copy
,
9940 "copy line %u", current_line
);
9944 int line_offset
= ent
->val
- current_line
;
9945 int line_delta
= line_offset
- DWARF_LINE_BASE
;
9947 current_line
= ent
->val
;
9948 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
9950 /* This can handle deltas from -10 to 234, using the current
9951 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
9952 This takes 1 byte. */
9953 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
9954 "line %u", current_line
);
9958 /* This can handle any delta. This takes at least 4 bytes,
9959 depending on the value being encoded. */
9960 dw2_asm_output_data (1, DW_LNS_advance_line
,
9961 "advance to line %u", current_line
);
9962 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
9963 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
9969 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
9970 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
9974 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
9975 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
9978 case LI_negate_stmt
:
9979 current_is_stmt
= !current_is_stmt
;
9980 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
9981 "is_stmt %d", current_is_stmt
);
9984 case LI_set_prologue_end
:
9985 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
9986 "set prologue end");
9989 case LI_set_epilogue_begin
:
9990 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
9991 "set epilogue begin");
9994 case LI_set_discriminator
:
9995 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
9996 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
9997 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
9998 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
10003 /* Emit debug info for the address of the end of the table. */
10004 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
10005 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
10006 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
10007 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
10009 dw2_asm_output_data (1, 0, "end sequence");
10010 dw2_asm_output_data_uleb128 (1, NULL
);
10011 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
10014 /* Output the source line number correspondence information. This
10015 information goes into the .debug_line section. */
10018 output_line_info (bool prologue_only
)
10020 char l1
[20], l2
[20], p1
[20], p2
[20];
10021 int ver
= dwarf_version
;
10022 bool saw_one
= false;
10025 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
10026 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
10027 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
10028 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
10030 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10031 dw2_asm_output_data (4, 0xffffffff,
10032 "Initial length escape value indicating 64-bit DWARF extension");
10033 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
10034 "Length of Source Line Info");
10035 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
10037 dw2_asm_output_data (2, ver
, "DWARF Version");
10038 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
10039 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
10041 /* Define the architecture-dependent minimum instruction length (in bytes).
10042 In this implementation of DWARF, this field is used for information
10043 purposes only. Since GCC generates assembly language, we have no
10044 a priori knowledge of how many instruction bytes are generated for each
10045 source line, and therefore can use only the DW_LNE_set_address and
10046 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
10047 this as '1', which is "correct enough" for all architectures,
10048 and don't let the target override. */
10049 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
10052 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
10053 "Maximum Operations Per Instruction");
10054 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
10055 "Default is_stmt_start flag");
10056 dw2_asm_output_data (1, DWARF_LINE_BASE
,
10057 "Line Base Value (Special Opcodes)");
10058 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
10059 "Line Range Value (Special Opcodes)");
10060 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
10061 "Special Opcode Base");
10063 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
10068 case DW_LNS_advance_pc
:
10069 case DW_LNS_advance_line
:
10070 case DW_LNS_set_file
:
10071 case DW_LNS_set_column
:
10072 case DW_LNS_fixed_advance_pc
:
10073 case DW_LNS_set_isa
:
10081 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
10085 /* Write out the information about the files we use. */
10086 output_file_names ();
10087 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
10090 /* Output the marker for the end of the line number info. */
10091 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10095 if (separate_line_info
)
10097 dw_line_info_table
*table
;
10100 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
10103 output_one_line_info_table (table
);
10107 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
10109 output_one_line_info_table (cold_text_section_line_info
);
10113 /* ??? Some Darwin linkers crash on a .debug_line section with no
10114 sequences. Further, merely a DW_LNE_end_sequence entry is not
10115 sufficient -- the address column must also be initialized.
10116 Make sure to output at least one set_address/end_sequence pair,
10117 choosing .text since that section is always present. */
10118 if (text_section_line_info
->in_use
|| !saw_one
)
10119 output_one_line_info_table (text_section_line_info
);
10121 /* Output the marker for the end of the line number info. */
10122 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
10125 /* Given a pointer to a tree node for some base type, return a pointer to
10126 a DIE that describes the given type.
10128 This routine must only be called for GCC type nodes that correspond to
10129 Dwarf base (fundamental) types. */
10132 base_type_die (tree type
)
10134 dw_die_ref base_type_result
;
10135 enum dwarf_type encoding
;
10137 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
10140 /* If this is a subtype that should not be emitted as a subrange type,
10141 use the base type. See subrange_type_for_debug_p. */
10142 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
10143 type
= TREE_TYPE (type
);
10145 switch (TREE_CODE (type
))
10148 if ((dwarf_version
>= 4 || !dwarf_strict
)
10149 && TYPE_NAME (type
)
10150 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10151 && DECL_IS_BUILTIN (TYPE_NAME (type
))
10152 && DECL_NAME (TYPE_NAME (type
)))
10154 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
10155 if (strcmp (name
, "char16_t") == 0
10156 || strcmp (name
, "char32_t") == 0)
10158 encoding
= DW_ATE_UTF
;
10162 if (TYPE_STRING_FLAG (type
))
10164 if (TYPE_UNSIGNED (type
))
10165 encoding
= DW_ATE_unsigned_char
;
10167 encoding
= DW_ATE_signed_char
;
10169 else if (TYPE_UNSIGNED (type
))
10170 encoding
= DW_ATE_unsigned
;
10172 encoding
= DW_ATE_signed
;
10176 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
10178 if (dwarf_version
>= 3 || !dwarf_strict
)
10179 encoding
= DW_ATE_decimal_float
;
10181 encoding
= DW_ATE_lo_user
;
10184 encoding
= DW_ATE_float
;
10187 case FIXED_POINT_TYPE
:
10188 if (!(dwarf_version
>= 3 || !dwarf_strict
))
10189 encoding
= DW_ATE_lo_user
;
10190 else if (TYPE_UNSIGNED (type
))
10191 encoding
= DW_ATE_unsigned_fixed
;
10193 encoding
= DW_ATE_signed_fixed
;
10196 /* Dwarf2 doesn't know anything about complex ints, so use
10197 a user defined type for it. */
10199 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
10200 encoding
= DW_ATE_complex_float
;
10202 encoding
= DW_ATE_lo_user
;
10206 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10207 encoding
= DW_ATE_boolean
;
10211 /* No other TREE_CODEs are Dwarf fundamental types. */
10212 gcc_unreachable ();
10215 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die (), type
);
10217 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
10218 int_size_in_bytes (type
));
10219 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
10220 add_pubtype (type
, base_type_result
);
10222 return base_type_result
;
10225 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
10226 named 'auto' in its type: return true for it, false otherwise. */
10229 is_cxx_auto (tree type
)
10233 tree name
= TYPE_IDENTIFIER (type
);
10234 if (name
== get_identifier ("auto")
10235 || name
== get_identifier ("decltype(auto)"))
10241 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10242 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10245 is_base_type (tree type
)
10247 switch (TREE_CODE (type
))
10253 case FIXED_POINT_TYPE
:
10261 case QUAL_UNION_TYPE
:
10262 case ENUMERAL_TYPE
:
10263 case FUNCTION_TYPE
:
10266 case REFERENCE_TYPE
:
10274 if (is_cxx_auto (type
))
10276 gcc_unreachable ();
10282 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10283 node, return the size in bits for the type if it is a constant, or else
10284 return the alignment for the type if the type's size is not constant, or
10285 else return BITS_PER_WORD if the type actually turns out to be an
10286 ERROR_MARK node. */
10288 static inline unsigned HOST_WIDE_INT
10289 simple_type_size_in_bits (const_tree type
)
10291 if (TREE_CODE (type
) == ERROR_MARK
)
10292 return BITS_PER_WORD
;
10293 else if (TYPE_SIZE (type
) == NULL_TREE
)
10295 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
10296 return tree_to_uhwi (TYPE_SIZE (type
));
10298 return TYPE_ALIGN (type
);
10301 /* Similarly, but return a double_int instead of UHWI. */
10303 static inline double_int
10304 double_int_type_size_in_bits (const_tree type
)
10306 if (TREE_CODE (type
) == ERROR_MARK
)
10307 return double_int::from_uhwi (BITS_PER_WORD
);
10308 else if (TYPE_SIZE (type
) == NULL_TREE
)
10309 return double_int_zero
;
10310 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
10311 return tree_to_double_int (TYPE_SIZE (type
));
10313 return double_int::from_uhwi (TYPE_ALIGN (type
));
10316 /* Given a pointer to a tree node for a subrange type, return a pointer
10317 to a DIE that describes the given type. */
10320 subrange_type_die (tree type
, tree low
, tree high
, dw_die_ref context_die
)
10322 dw_die_ref subrange_die
;
10323 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
10325 if (context_die
== NULL
)
10326 context_die
= comp_unit_die ();
10328 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
10330 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
10332 /* The size of the subrange type and its base type do not match,
10333 so we need to generate a size attribute for the subrange type. */
10334 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
10338 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
);
10340 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
);
10342 return subrange_die
;
10345 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10346 entry that chains various modifiers in front of the given type. */
10349 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
10350 dw_die_ref context_die
)
10352 enum tree_code code
= TREE_CODE (type
);
10353 dw_die_ref mod_type_die
;
10354 dw_die_ref sub_die
= NULL
;
10355 tree item_type
= NULL
;
10356 tree qualified_type
;
10357 tree name
, low
, high
;
10358 dw_die_ref mod_scope
;
10360 if (code
== ERROR_MARK
)
10363 /* See if we already have the appropriately qualified variant of
10366 = get_qualified_type (type
,
10367 ((is_const_type
? TYPE_QUAL_CONST
: 0)
10368 | (is_volatile_type
? TYPE_QUAL_VOLATILE
: 0)));
10370 if (qualified_type
== sizetype
10371 && TYPE_NAME (qualified_type
)
10372 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
10374 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
10376 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
10377 && TYPE_PRECISION (t
)
10378 == TYPE_PRECISION (qualified_type
)
10379 && TYPE_UNSIGNED (t
)
10380 == TYPE_UNSIGNED (qualified_type
));
10381 qualified_type
= t
;
10384 /* If we do, then we can just use its DIE, if it exists. */
10385 if (qualified_type
)
10387 mod_type_die
= lookup_type_die (qualified_type
);
10389 return mod_type_die
;
10392 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
10394 /* Handle C typedef types. */
10395 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
10396 && !DECL_ARTIFICIAL (name
))
10398 tree dtype
= TREE_TYPE (name
);
10400 if (qualified_type
== dtype
)
10402 /* For a named type, use the typedef. */
10403 gen_type_die (qualified_type
, context_die
);
10404 return lookup_type_die (qualified_type
);
10406 else if (is_const_type
< TYPE_READONLY (dtype
)
10407 || is_volatile_type
< TYPE_VOLATILE (dtype
)
10408 || (is_const_type
<= TYPE_READONLY (dtype
)
10409 && is_volatile_type
<= TYPE_VOLATILE (dtype
)
10410 && DECL_ORIGINAL_TYPE (name
) != type
))
10411 /* cv-unqualified version of named type. Just use the unnamed
10412 type to which it refers. */
10413 return modified_type_die (DECL_ORIGINAL_TYPE (name
),
10414 is_const_type
, is_volatile_type
,
10416 /* Else cv-qualified version of named type; fall through. */
10419 mod_scope
= scope_die_for (type
, context_die
);
10422 /* If both is_const_type and is_volatile_type, prefer the path
10423 which leads to a qualified type. */
10424 && (!is_volatile_type
10425 || get_qualified_type (type
, TYPE_QUAL_CONST
) == NULL_TREE
10426 || get_qualified_type (type
, TYPE_QUAL_VOLATILE
) != NULL_TREE
))
10428 mod_type_die
= new_die (DW_TAG_const_type
, mod_scope
, type
);
10429 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
10431 else if (is_volatile_type
)
10433 mod_type_die
= new_die (DW_TAG_volatile_type
, mod_scope
, type
);
10434 sub_die
= modified_type_die (type
, is_const_type
, 0, context_die
);
10436 else if (code
== POINTER_TYPE
)
10438 mod_type_die
= new_die (DW_TAG_pointer_type
, mod_scope
, type
);
10439 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10440 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10441 item_type
= TREE_TYPE (type
);
10442 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10443 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10444 TYPE_ADDR_SPACE (item_type
));
10446 else if (code
== REFERENCE_TYPE
)
10448 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
10449 mod_type_die
= new_die (DW_TAG_rvalue_reference_type
, mod_scope
,
10452 mod_type_die
= new_die (DW_TAG_reference_type
, mod_scope
, type
);
10453 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10454 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10455 item_type
= TREE_TYPE (type
);
10456 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10457 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10458 TYPE_ADDR_SPACE (item_type
));
10460 else if (code
== INTEGER_TYPE
10461 && TREE_TYPE (type
) != NULL_TREE
10462 && subrange_type_for_debug_p (type
, &low
, &high
))
10464 mod_type_die
= subrange_type_die (type
, low
, high
, context_die
);
10465 item_type
= TREE_TYPE (type
);
10467 else if (is_base_type (type
))
10468 mod_type_die
= base_type_die (type
);
10471 gen_type_die (type
, context_die
);
10473 /* We have to get the type_main_variant here (and pass that to the
10474 `lookup_type_die' routine) because the ..._TYPE node we have
10475 might simply be a *copy* of some original type node (where the
10476 copy was created to help us keep track of typedef names) and
10477 that copy might have a different TYPE_UID from the original
10479 if (TREE_CODE (type
) != VECTOR_TYPE
)
10480 return lookup_type_die (type_main_variant (type
));
10482 /* Vectors have the debugging information in the type,
10483 not the main variant. */
10484 return lookup_type_die (type
);
10487 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10488 don't output a DW_TAG_typedef, since there isn't one in the
10489 user's program; just attach a DW_AT_name to the type.
10490 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
10491 if the base type already has the same name. */
10493 && ((TREE_CODE (name
) != TYPE_DECL
10494 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
10495 || (!is_const_type
&& !is_volatile_type
)))
10496 || (TREE_CODE (name
) == TYPE_DECL
10497 && TREE_TYPE (name
) == qualified_type
10498 && DECL_NAME (name
))))
10500 if (TREE_CODE (name
) == TYPE_DECL
)
10501 /* Could just call add_name_and_src_coords_attributes here,
10502 but since this is a builtin type it doesn't have any
10503 useful source coordinates anyway. */
10504 name
= DECL_NAME (name
);
10505 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
10507 /* This probably indicates a bug. */
10508 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
10510 name
= TYPE_IDENTIFIER (type
);
10511 add_name_attribute (mod_type_die
,
10512 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
10515 if (qualified_type
)
10516 equate_type_number_to_die (qualified_type
, mod_type_die
);
10519 /* We must do this after the equate_type_number_to_die call, in case
10520 this is a recursive type. This ensures that the modified_type_die
10521 recursion will terminate even if the type is recursive. Recursive
10522 types are possible in Ada. */
10523 sub_die
= modified_type_die (item_type
,
10524 TYPE_READONLY (item_type
),
10525 TYPE_VOLATILE (item_type
),
10528 if (sub_die
!= NULL
)
10529 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
10531 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
10532 if (TYPE_ARTIFICIAL (type
))
10533 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
10535 return mod_type_die
;
10538 /* Generate DIEs for the generic parameters of T.
10539 T must be either a generic type or a generic function.
10540 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10543 gen_generic_params_dies (tree t
)
10547 dw_die_ref die
= NULL
;
10550 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
10554 die
= lookup_type_die (t
);
10555 else if (DECL_P (t
))
10556 die
= lookup_decl_die (t
);
10560 parms
= lang_hooks
.get_innermost_generic_parms (t
);
10562 /* T has no generic parameter. It means T is neither a generic type
10563 or function. End of story. */
10566 parms_num
= TREE_VEC_LENGTH (parms
);
10567 args
= lang_hooks
.get_innermost_generic_args (t
);
10568 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
10569 non_default
= int_cst_value (TREE_CHAIN (args
));
10571 non_default
= TREE_VEC_LENGTH (args
);
10572 for (i
= 0; i
< parms_num
; i
++)
10574 tree parm
, arg
, arg_pack_elems
;
10575 dw_die_ref parm_die
;
10577 parm
= TREE_VEC_ELT (parms
, i
);
10578 arg
= TREE_VEC_ELT (args
, i
);
10579 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
10580 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
10582 if (parm
&& TREE_VALUE (parm
) && arg
)
10584 /* If PARM represents a template parameter pack,
10585 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10586 by DW_TAG_template_*_parameter DIEs for the argument
10587 pack elements of ARG. Note that ARG would then be
10588 an argument pack. */
10589 if (arg_pack_elems
)
10590 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
10594 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
10595 true /* emit name */, die
);
10596 if (i
>= non_default
)
10597 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
10602 /* Create and return a DIE for PARM which should be
10603 the representation of a generic type parameter.
10604 For instance, in the C++ front end, PARM would be a template parameter.
10605 ARG is the argument to PARM.
10606 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10608 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10609 as a child node. */
10612 generic_parameter_die (tree parm
, tree arg
,
10614 dw_die_ref parent_die
)
10616 dw_die_ref tmpl_die
= NULL
;
10617 const char *name
= NULL
;
10619 if (!parm
|| !DECL_NAME (parm
) || !arg
)
10622 /* We support non-type generic parameters and arguments,
10623 type generic parameters and arguments, as well as
10624 generic generic parameters (a.k.a. template template parameters in C++)
10626 if (TREE_CODE (parm
) == PARM_DECL
)
10627 /* PARM is a nontype generic parameter */
10628 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
10629 else if (TREE_CODE (parm
) == TYPE_DECL
)
10630 /* PARM is a type generic parameter. */
10631 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
10632 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10633 /* PARM is a generic generic parameter.
10634 Its DIE is a GNU extension. It shall have a
10635 DW_AT_name attribute to represent the name of the template template
10636 parameter, and a DW_AT_GNU_template_name attribute to represent the
10637 name of the template template argument. */
10638 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
10641 gcc_unreachable ();
10647 /* If PARM is a generic parameter pack, it means we are
10648 emitting debug info for a template argument pack element.
10649 In other terms, ARG is a template argument pack element.
10650 In that case, we don't emit any DW_AT_name attribute for
10654 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
10656 add_AT_string (tmpl_die
, DW_AT_name
, name
);
10659 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10661 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10662 TMPL_DIE should have a child DW_AT_type attribute that is set
10663 to the type of the argument to PARM, which is ARG.
10664 If PARM is a type generic parameter, TMPL_DIE should have a
10665 child DW_AT_type that is set to ARG. */
10666 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
10667 add_type_attribute (tmpl_die
, tmpl_type
, 0,
10668 TREE_THIS_VOLATILE (tmpl_type
),
10673 /* So TMPL_DIE is a DIE representing a
10674 a generic generic template parameter, a.k.a template template
10675 parameter in C++ and arg is a template. */
10677 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10678 to the name of the argument. */
10679 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
10681 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
10684 if (TREE_CODE (parm
) == PARM_DECL
)
10685 /* So PARM is a non-type generic parameter.
10686 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10687 attribute of TMPL_DIE which value represents the value
10689 We must be careful here:
10690 The value of ARG might reference some function decls.
10691 We might currently be emitting debug info for a generic
10692 type and types are emitted before function decls, we don't
10693 know if the function decls referenced by ARG will actually be
10694 emitted after cgraph computations.
10695 So must defer the generation of the DW_AT_const_value to
10696 after cgraph is ready. */
10697 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
10703 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
10704 PARM_PACK must be a template parameter pack. The returned DIE
10705 will be child DIE of PARENT_DIE. */
10708 template_parameter_pack_die (tree parm_pack
,
10709 tree parm_pack_args
,
10710 dw_die_ref parent_die
)
10715 gcc_assert (parent_die
&& parm_pack
);
10717 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
10718 add_name_and_src_coords_attributes (die
, parm_pack
);
10719 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
10720 generic_parameter_die (parm_pack
,
10721 TREE_VEC_ELT (parm_pack_args
, j
),
10722 false /* Don't emit DW_AT_name */,
10727 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10728 an enumerated type. */
10731 type_is_enum (const_tree type
)
10733 return TREE_CODE (type
) == ENUMERAL_TYPE
;
10736 /* Return the DBX register number described by a given RTL node. */
10738 static unsigned int
10739 dbx_reg_number (const_rtx rtl
)
10741 unsigned regno
= REGNO (rtl
);
10743 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
10745 #ifdef LEAF_REG_REMAP
10746 if (crtl
->uses_only_leaf_regs
)
10748 int leaf_reg
= LEAF_REG_REMAP (regno
);
10749 if (leaf_reg
!= -1)
10750 regno
= (unsigned) leaf_reg
;
10754 regno
= DBX_REGISTER_NUMBER (regno
);
10755 gcc_assert (regno
!= INVALID_REGNUM
);
10759 /* Optionally add a DW_OP_piece term to a location description expression.
10760 DW_OP_piece is only added if the location description expression already
10761 doesn't end with DW_OP_piece. */
10764 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
10766 dw_loc_descr_ref loc
;
10768 if (*list_head
!= NULL
)
10770 /* Find the end of the chain. */
10771 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
10774 if (loc
->dw_loc_opc
!= DW_OP_piece
)
10775 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
10779 /* Return a location descriptor that designates a machine register or
10780 zero if there is none. */
10782 static dw_loc_descr_ref
10783 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
10787 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
10790 /* We only use "frame base" when we're sure we're talking about the
10791 post-prologue local stack frame. We do this by *not* running
10792 register elimination until this point, and recognizing the special
10793 argument pointer and soft frame pointer rtx's.
10794 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
10795 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
10796 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
10798 dw_loc_descr_ref result
= NULL
;
10800 if (dwarf_version
>= 4 || !dwarf_strict
)
10802 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
10805 add_loc_descr (&result
,
10806 new_loc_descr (DW_OP_stack_value
, 0, 0));
10811 regs
= targetm
.dwarf_register_span (rtl
);
10813 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1 || regs
)
10814 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
10817 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
10818 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
10820 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
10824 /* Return a location descriptor that designates a machine register for
10825 a given hard register number. */
10827 static dw_loc_descr_ref
10828 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
10830 dw_loc_descr_ref reg_loc_descr
;
10834 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
10836 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
10838 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10839 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10841 return reg_loc_descr
;
10844 /* Given an RTL of a register, return a location descriptor that
10845 designates a value that spans more than one register. */
10847 static dw_loc_descr_ref
10848 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
10849 enum var_init_status initialized
)
10852 dw_loc_descr_ref loc_result
= NULL
;
10854 /* Simple, contiguous registers. */
10855 if (regs
== NULL_RTX
)
10857 unsigned reg
= REGNO (rtl
);
10860 #ifdef LEAF_REG_REMAP
10861 if (crtl
->uses_only_leaf_regs
)
10863 int leaf_reg
= LEAF_REG_REMAP (reg
);
10864 if (leaf_reg
!= -1)
10865 reg
= (unsigned) leaf_reg
;
10869 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
10870 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
10872 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
10877 dw_loc_descr_ref t
;
10879 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
10880 VAR_INIT_STATUS_INITIALIZED
);
10881 add_loc_descr (&loc_result
, t
);
10882 add_loc_descr_op_piece (&loc_result
, size
);
10888 /* Now onto stupid register sets in non contiguous locations. */
10890 gcc_assert (GET_CODE (regs
) == PARALLEL
);
10892 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
10895 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
10897 dw_loc_descr_ref t
;
10899 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
10900 VAR_INIT_STATUS_INITIALIZED
);
10901 add_loc_descr (&loc_result
, t
);
10902 add_loc_descr_op_piece (&loc_result
, size
);
10905 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10906 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10910 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
10912 /* Return a location descriptor that designates a constant i,
10913 as a compound operation from constant (i >> shift), constant shift
10916 static dw_loc_descr_ref
10917 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
10919 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
10920 add_loc_descr (&ret
, int_loc_descriptor (shift
));
10921 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
10925 /* Return a location descriptor that designates a constant. */
10927 static dw_loc_descr_ref
10928 int_loc_descriptor (HOST_WIDE_INT i
)
10930 enum dwarf_location_atom op
;
10932 /* Pick the smallest representation of a constant, rather than just
10933 defaulting to the LEB encoding. */
10936 int clz
= clz_hwi (i
);
10937 int ctz
= ctz_hwi (i
);
10939 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
10940 else if (i
<= 0xff)
10941 op
= DW_OP_const1u
;
10942 else if (i
<= 0xffff)
10943 op
= DW_OP_const2u
;
10944 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
10945 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
10946 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
10947 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
10948 while DW_OP_const4u is 5 bytes. */
10949 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
10950 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
10951 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
10952 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
10953 while DW_OP_const4u is 5 bytes. */
10954 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
10955 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
10956 op
= DW_OP_const4u
;
10957 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
10958 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
10959 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
10960 while DW_OP_constu of constant >= 0x100000000 takes at least
10962 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
10963 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
10964 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
10965 >= HOST_BITS_PER_WIDE_INT
)
10966 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
10967 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
10968 while DW_OP_constu takes in this case at least 6 bytes. */
10969 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
10970 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
10971 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
10972 && size_of_uleb128 (i
) > 6)
10973 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
10974 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
10981 op
= DW_OP_const1s
;
10982 else if (i
>= -0x8000)
10983 op
= DW_OP_const2s
;
10984 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
10986 if (size_of_int_loc_descriptor (i
) < 5)
10988 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
10989 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
10992 op
= DW_OP_const4s
;
10996 if (size_of_int_loc_descriptor (i
)
10997 < (unsigned long) 1 + size_of_sleb128 (i
))
10999 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11000 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11007 return new_loc_descr (op
, i
, 0);
11010 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
11011 without actually allocating it. */
11013 static unsigned long
11014 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11016 return size_of_int_loc_descriptor (i
>> shift
)
11017 + size_of_int_loc_descriptor (shift
)
11021 /* Return size_of_locs (int_loc_descriptor (i)) without
11022 actually allocating it. */
11024 static unsigned long
11025 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
11034 else if (i
<= 0xff)
11036 else if (i
<= 0xffff)
11040 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11041 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11042 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11044 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11045 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11046 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11048 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11050 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
11051 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11052 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11053 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11055 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11056 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
11057 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11059 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11060 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11062 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11071 else if (i
>= -0x8000)
11073 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11075 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11077 s
= size_of_int_loc_descriptor (-i
) + 1;
11085 unsigned long r
= 1 + size_of_sleb128 (i
);
11086 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11088 s
= size_of_int_loc_descriptor (-i
) + 1;
11097 /* Return loc description representing "address" of integer value.
11098 This can appear only as toplevel expression. */
11100 static dw_loc_descr_ref
11101 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
11104 dw_loc_descr_ref loc_result
= NULL
;
11106 if (!(dwarf_version
>= 4 || !dwarf_strict
))
11109 litsize
= size_of_int_loc_descriptor (i
);
11110 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11111 is more compact. For DW_OP_stack_value we need:
11112 litsize + 1 (DW_OP_stack_value)
11113 and for DW_OP_implicit_value:
11114 1 (DW_OP_implicit_value) + 1 (length) + size. */
11115 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
11117 loc_result
= int_loc_descriptor (i
);
11118 add_loc_descr (&loc_result
,
11119 new_loc_descr (DW_OP_stack_value
, 0, 0));
11123 loc_result
= new_loc_descr (DW_OP_implicit_value
,
11125 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
11126 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
11130 /* Return a location descriptor that designates a base+offset location. */
11132 static dw_loc_descr_ref
11133 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
11134 enum var_init_status initialized
)
11136 unsigned int regno
;
11137 dw_loc_descr_ref result
;
11138 dw_fde_ref fde
= cfun
->fde
;
11140 /* We only use "frame base" when we're sure we're talking about the
11141 post-prologue local stack frame. We do this by *not* running
11142 register elimination until this point, and recognizing the special
11143 argument pointer and soft frame pointer rtx's. */
11144 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
11146 rtx elim
= (ira_use_lra_p
11147 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
11148 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
11152 if (GET_CODE (elim
) == PLUS
)
11154 offset
+= INTVAL (XEXP (elim
, 1));
11155 elim
= XEXP (elim
, 0);
11157 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
11158 && (elim
== hard_frame_pointer_rtx
11159 || elim
== stack_pointer_rtx
))
11160 || elim
== (frame_pointer_needed
11161 ? hard_frame_pointer_rtx
11162 : stack_pointer_rtx
));
11164 /* If drap register is used to align stack, use frame
11165 pointer + offset to access stack variables. If stack
11166 is aligned without drap, use stack pointer + offset to
11167 access stack variables. */
11168 if (crtl
->stack_realign_tried
11169 && reg
== frame_pointer_rtx
)
11172 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
11173 ? HARD_FRAME_POINTER_REGNUM
11175 return new_reg_loc_descr (base_reg
, offset
);
11178 gcc_assert (frame_pointer_fb_offset_valid
);
11179 offset
+= frame_pointer_fb_offset
;
11180 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11184 regno
= REGNO (reg
);
11185 #ifdef LEAF_REG_REMAP
11186 if (crtl
->uses_only_leaf_regs
)
11188 int leaf_reg
= LEAF_REG_REMAP (regno
);
11189 if (leaf_reg
!= -1)
11190 regno
= (unsigned) leaf_reg
;
11193 regno
= DWARF_FRAME_REGNUM (regno
);
11195 if (!optimize
&& fde
11196 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
))
11198 /* Use cfa+offset to represent the location of arguments passed
11199 on the stack when drap is used to align stack.
11200 Only do this when not optimizing, for optimized code var-tracking
11201 is supposed to track where the arguments live and the register
11202 used as vdrap or drap in some spot might be used for something
11203 else in other part of the routine. */
11204 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11208 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
11211 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
11213 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11214 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11219 /* Return true if this RTL expression describes a base+offset calculation. */
11222 is_based_loc (const_rtx rtl
)
11224 return (GET_CODE (rtl
) == PLUS
11225 && ((REG_P (XEXP (rtl
, 0))
11226 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
11227 && CONST_INT_P (XEXP (rtl
, 1)))));
11230 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11233 static dw_loc_descr_ref
11234 tls_mem_loc_descriptor (rtx mem
)
11237 dw_loc_descr_ref loc_result
;
11239 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
11242 base
= get_base_address (MEM_EXPR (mem
));
11244 || TREE_CODE (base
) != VAR_DECL
11245 || !DECL_THREAD_LOCAL_P (base
))
11248 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1);
11249 if (loc_result
== NULL
)
11252 if (MEM_OFFSET (mem
))
11253 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
11258 /* Output debug info about reason why we failed to expand expression as dwarf
11262 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
11264 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
11266 fprintf (dump_file
, "Failed to expand as dwarf: ");
11268 print_generic_expr (dump_file
, expr
, dump_flags
);
11271 fprintf (dump_file
, "\n");
11272 print_rtl (dump_file
, rtl
);
11274 fprintf (dump_file
, "\nReason: %s\n", reason
);
11278 /* Helper function for const_ok_for_output, called either directly
11279 or via for_each_rtx. */
11282 const_ok_for_output_1 (rtx
*rtlp
, void *data ATTRIBUTE_UNUSED
)
11286 if (GET_CODE (rtl
) == UNSPEC
)
11288 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
11289 we can't express it in the debug info. */
11290 #ifdef ENABLE_CHECKING
11291 /* Don't complain about TLS UNSPECs, those are just too hard to
11292 delegitimize. Note this could be a non-decl SYMBOL_REF such as
11293 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
11294 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
11295 if (XVECLEN (rtl
, 0) == 0
11296 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
11297 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
)
11298 inform (current_function_decl
11299 ? DECL_SOURCE_LOCATION (current_function_decl
)
11300 : UNKNOWN_LOCATION
,
11301 #if NUM_UNSPEC_VALUES > 0
11302 "non-delegitimized UNSPEC %s (%d) found in variable location",
11303 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
11304 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
11307 "non-delegitimized UNSPEC %d found in variable location",
11311 expansion_failed (NULL_TREE
, rtl
,
11312 "UNSPEC hasn't been delegitimized.\n");
11316 if (targetm
.const_not_ok_for_debug_p (rtl
))
11318 expansion_failed (NULL_TREE
, rtl
,
11319 "Expression rejected for debug by the backend.\n");
11323 /* FIXME: Refer to PR60655. It is possible for simplification
11324 of rtl expressions in var tracking to produce such expressions.
11325 We should really identify / validate expressions
11326 enclosed in CONST that can be handled by assemblers on various
11327 targets and only handle legitimate cases here. */
11328 if (GET_CODE (rtl
) != SYMBOL_REF
)
11330 if (GET_CODE (rtl
) == NOT
)
11336 if (CONSTANT_POOL_ADDRESS_P (rtl
))
11339 get_pool_constant_mark (rtl
, &marked
);
11340 /* If all references to this pool constant were optimized away,
11341 it was not output and thus we can't represent it. */
11344 expansion_failed (NULL_TREE
, rtl
,
11345 "Constant was removed from constant pool.\n");
11350 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
11353 /* Avoid references to external symbols in debug info, on several targets
11354 the linker might even refuse to link when linking a shared library,
11355 and in many other cases the relocations for .debug_info/.debug_loc are
11356 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
11357 to be defined within the same shared library or executable are fine. */
11358 if (SYMBOL_REF_EXTERNAL_P (rtl
))
11360 tree decl
= SYMBOL_REF_DECL (rtl
);
11362 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
11364 expansion_failed (NULL_TREE
, rtl
,
11365 "Symbol not defined in current TU.\n");
11373 /* Return true if constant RTL can be emitted in DW_OP_addr or
11374 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
11375 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
11378 const_ok_for_output (rtx rtl
)
11380 if (GET_CODE (rtl
) == SYMBOL_REF
)
11381 return const_ok_for_output_1 (&rtl
, NULL
) == 0;
11383 if (GET_CODE (rtl
) == CONST
)
11384 return for_each_rtx (&XEXP (rtl
, 0), const_ok_for_output_1
, NULL
) == 0;
11389 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
11390 if possible, NULL otherwise. */
11393 base_type_for_mode (enum machine_mode mode
, bool unsignedp
)
11395 dw_die_ref type_die
;
11396 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
11400 switch (TREE_CODE (type
))
11408 type_die
= lookup_type_die (type
);
11410 type_die
= modified_type_die (type
, false, false, comp_unit_die ());
11411 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
11416 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
11417 type matching MODE, or, if MODE is narrower than or as wide as
11418 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
11421 static dw_loc_descr_ref
11422 convert_descriptor_to_mode (enum machine_mode mode
, dw_loc_descr_ref op
)
11424 enum machine_mode outer_mode
= mode
;
11425 dw_die_ref type_die
;
11426 dw_loc_descr_ref cvt
;
11428 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
11430 add_loc_descr (&op
, new_loc_descr (DW_OP_GNU_convert
, 0, 0));
11433 type_die
= base_type_for_mode (outer_mode
, 1);
11434 if (type_die
== NULL
)
11436 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11437 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11438 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11439 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11440 add_loc_descr (&op
, cvt
);
11444 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
11446 static dw_loc_descr_ref
11447 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
11448 dw_loc_descr_ref op1
)
11450 dw_loc_descr_ref ret
= op0
;
11451 add_loc_descr (&ret
, op1
);
11452 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11453 if (STORE_FLAG_VALUE
!= 1)
11455 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
11456 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
11461 /* Return location descriptor for signed comparison OP RTL. */
11463 static dw_loc_descr_ref
11464 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11465 enum machine_mode mem_mode
)
11467 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11468 dw_loc_descr_ref op0
, op1
;
11471 if (op_mode
== VOIDmode
)
11472 op_mode
= GET_MODE (XEXP (rtl
, 1));
11473 if (op_mode
== VOIDmode
)
11477 && (GET_MODE_CLASS (op_mode
) != MODE_INT
11478 || GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
))
11481 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11482 VAR_INIT_STATUS_INITIALIZED
);
11483 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11484 VAR_INIT_STATUS_INITIALIZED
);
11486 if (op0
== NULL
|| op1
== NULL
)
11489 if (GET_MODE_CLASS (op_mode
) != MODE_INT
11490 || GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11491 return compare_loc_descriptor (op
, op0
, op1
);
11493 if (GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11495 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
11496 dw_loc_descr_ref cvt
;
11498 if (type_die
== NULL
)
11500 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11501 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11502 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11503 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11504 add_loc_descr (&op0
, cvt
);
11505 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11506 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11507 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11508 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11509 add_loc_descr (&op1
, cvt
);
11510 return compare_loc_descriptor (op
, op0
, op1
);
11513 shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
11514 /* For eq/ne, if the operands are known to be zero-extended,
11515 there is no need to do the fancy shifting up. */
11516 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
11518 dw_loc_descr_ref last0
, last1
;
11519 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11521 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11523 /* deref_size zero extends, and for constants we can check
11524 whether they are zero extended or not. */
11525 if (((last0
->dw_loc_opc
== DW_OP_deref_size
11526 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11527 || (CONST_INT_P (XEXP (rtl
, 0))
11528 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
11529 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
11530 && ((last1
->dw_loc_opc
== DW_OP_deref_size
11531 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11532 || (CONST_INT_P (XEXP (rtl
, 1))
11533 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
11534 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
11535 return compare_loc_descriptor (op
, op0
, op1
);
11537 /* EQ/NE comparison against constant in narrower type than
11538 DWARF2_ADDR_SIZE can be performed either as
11539 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
11542 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
11543 DW_OP_{eq,ne}. Pick whatever is shorter. */
11544 if (CONST_INT_P (XEXP (rtl
, 1))
11545 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
11546 && (size_of_int_loc_descriptor (shift
) + 1
11547 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
)
11548 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
11549 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11550 & GET_MODE_MASK (op_mode
))))
11552 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
11553 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11554 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11555 & GET_MODE_MASK (op_mode
));
11556 return compare_loc_descriptor (op
, op0
, op1
);
11559 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11560 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11561 if (CONST_INT_P (XEXP (rtl
, 1)))
11562 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
);
11565 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11566 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11568 return compare_loc_descriptor (op
, op0
, op1
);
11571 /* Return location descriptor for unsigned comparison OP RTL. */
11573 static dw_loc_descr_ref
11574 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11575 enum machine_mode mem_mode
)
11577 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11578 dw_loc_descr_ref op0
, op1
;
11580 if (op_mode
== VOIDmode
)
11581 op_mode
= GET_MODE (XEXP (rtl
, 1));
11582 if (op_mode
== VOIDmode
)
11584 if (GET_MODE_CLASS (op_mode
) != MODE_INT
)
11587 if (dwarf_strict
&& GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11590 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11591 VAR_INIT_STATUS_INITIALIZED
);
11592 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11593 VAR_INIT_STATUS_INITIALIZED
);
11595 if (op0
== NULL
|| op1
== NULL
)
11598 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
11600 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
11601 dw_loc_descr_ref last0
, last1
;
11602 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11604 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11606 if (CONST_INT_P (XEXP (rtl
, 0)))
11607 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
11608 /* deref_size zero extends, so no need to mask it again. */
11609 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
11610 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11612 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11613 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11615 if (CONST_INT_P (XEXP (rtl
, 1)))
11616 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
11617 /* deref_size zero extends, so no need to mask it again. */
11618 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
11619 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11621 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11622 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11625 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11627 HOST_WIDE_INT bias
= 1;
11628 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11629 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11630 if (CONST_INT_P (XEXP (rtl
, 1)))
11631 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
11632 + INTVAL (XEXP (rtl
, 1)));
11634 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
11637 return compare_loc_descriptor (op
, op0
, op1
);
11640 /* Return location descriptor for {U,S}{MIN,MAX}. */
11642 static dw_loc_descr_ref
11643 minmax_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11644 enum machine_mode mem_mode
)
11646 enum dwarf_location_atom op
;
11647 dw_loc_descr_ref op0
, op1
, ret
;
11648 dw_loc_descr_ref bra_node
, drop_node
;
11651 && (GET_MODE_CLASS (mode
) != MODE_INT
11652 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
))
11655 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11656 VAR_INIT_STATUS_INITIALIZED
);
11657 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11658 VAR_INIT_STATUS_INITIALIZED
);
11660 if (op0
== NULL
|| op1
== NULL
)
11663 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
11664 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
11665 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
11666 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
11668 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11670 HOST_WIDE_INT mask
= GET_MODE_MASK (mode
);
11671 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11672 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11673 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11674 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11676 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
11678 HOST_WIDE_INT bias
= 1;
11679 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11680 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11681 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11684 else if (GET_MODE_CLASS (mode
) == MODE_INT
11685 && GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11687 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (mode
)) * BITS_PER_UNIT
;
11688 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11689 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11690 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11691 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11693 else if (GET_MODE_CLASS (mode
) == MODE_INT
11694 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11696 dw_die_ref type_die
= base_type_for_mode (mode
, 0);
11697 dw_loc_descr_ref cvt
;
11698 if (type_die
== NULL
)
11700 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11701 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11702 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11703 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11704 add_loc_descr (&op0
, cvt
);
11705 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11706 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11707 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11708 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11709 add_loc_descr (&op1
, cvt
);
11712 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
11717 add_loc_descr (&ret
, op1
);
11718 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11719 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
11720 add_loc_descr (&ret
, bra_node
);
11721 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11722 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
11723 add_loc_descr (&ret
, drop_node
);
11724 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11725 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
11726 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
11727 && GET_MODE_CLASS (mode
) == MODE_INT
11728 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11729 ret
= convert_descriptor_to_mode (mode
, ret
);
11733 /* Helper function for mem_loc_descriptor. Perform OP binary op,
11734 but after converting arguments to type_die, afterwards
11735 convert back to unsigned. */
11737 static dw_loc_descr_ref
11738 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
11739 enum machine_mode mode
, enum machine_mode mem_mode
)
11741 dw_loc_descr_ref cvt
, op0
, op1
;
11743 if (type_die
== NULL
)
11745 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11746 VAR_INIT_STATUS_INITIALIZED
);
11747 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11748 VAR_INIT_STATUS_INITIALIZED
);
11749 if (op0
== NULL
|| op1
== NULL
)
11751 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11752 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11753 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11754 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11755 add_loc_descr (&op0
, cvt
);
11756 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11757 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11758 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11759 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11760 add_loc_descr (&op1
, cvt
);
11761 add_loc_descr (&op0
, op1
);
11762 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
11763 return convert_descriptor_to_mode (mode
, op0
);
11766 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
11767 const0 is DW_OP_lit0 or corresponding typed constant,
11768 const1 is DW_OP_lit1 or corresponding typed constant
11769 and constMSB is constant with just the MSB bit set
11771 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11772 L1: const0 DW_OP_swap
11773 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
11774 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11779 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11780 L1: const0 DW_OP_swap
11781 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11782 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11787 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
11788 L1: const1 DW_OP_swap
11789 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11790 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11794 static dw_loc_descr_ref
11795 clz_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11796 enum machine_mode mem_mode
)
11798 dw_loc_descr_ref op0
, ret
, tmp
;
11799 HOST_WIDE_INT valv
;
11800 dw_loc_descr_ref l1jump
, l1label
;
11801 dw_loc_descr_ref l2jump
, l2label
;
11802 dw_loc_descr_ref l3jump
, l3label
;
11803 dw_loc_descr_ref l4jump
, l4label
;
11806 if (GET_MODE_CLASS (mode
) != MODE_INT
11807 || GET_MODE (XEXP (rtl
, 0)) != mode
11808 || (GET_CODE (rtl
) == CLZ
11809 && GET_MODE_BITSIZE (mode
) > HOST_BITS_PER_DOUBLE_INT
))
11812 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11813 VAR_INIT_STATUS_INITIALIZED
);
11817 if (GET_CODE (rtl
) == CLZ
)
11819 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11820 valv
= GET_MODE_BITSIZE (mode
);
11822 else if (GET_CODE (rtl
) == FFS
)
11824 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11825 valv
= GET_MODE_BITSIZE (mode
);
11826 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11827 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11828 add_loc_descr (&ret
, l1jump
);
11829 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
11830 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
11831 VAR_INIT_STATUS_INITIALIZED
);
11834 add_loc_descr (&ret
, tmp
);
11835 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11836 add_loc_descr (&ret
, l4jump
);
11837 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
11838 ? const1_rtx
: const0_rtx
,
11840 VAR_INIT_STATUS_INITIALIZED
);
11841 if (l1label
== NULL
)
11843 add_loc_descr (&ret
, l1label
);
11844 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11845 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
11846 add_loc_descr (&ret
, l2label
);
11847 if (GET_CODE (rtl
) != CLZ
)
11849 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
11850 msb
= GEN_INT ((unsigned HOST_WIDE_INT
) 1
11851 << (GET_MODE_BITSIZE (mode
) - 1));
11853 msb
= immed_double_const (0, (unsigned HOST_WIDE_INT
) 1
11854 << (GET_MODE_BITSIZE (mode
)
11855 - HOST_BITS_PER_WIDE_INT
- 1), mode
);
11856 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
11857 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
11858 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
11859 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
11861 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
11862 VAR_INIT_STATUS_INITIALIZED
);
11865 add_loc_descr (&ret
, tmp
);
11866 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
11867 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11868 add_loc_descr (&ret
, l3jump
);
11869 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11870 VAR_INIT_STATUS_INITIALIZED
);
11873 add_loc_descr (&ret
, tmp
);
11874 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
11875 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
11876 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11877 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
11878 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11879 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11880 add_loc_descr (&ret
, l2jump
);
11881 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
11882 add_loc_descr (&ret
, l3label
);
11883 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
11884 add_loc_descr (&ret
, l4label
);
11885 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11886 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
11887 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11888 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
11889 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11890 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
11891 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11892 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
11896 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
11897 const1 is DW_OP_lit1 or corresponding typed constant):
11899 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
11900 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
11904 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
11905 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
11908 static dw_loc_descr_ref
11909 popcount_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11910 enum machine_mode mem_mode
)
11912 dw_loc_descr_ref op0
, ret
, tmp
;
11913 dw_loc_descr_ref l1jump
, l1label
;
11914 dw_loc_descr_ref l2jump
, l2label
;
11916 if (GET_MODE_CLASS (mode
) != MODE_INT
11917 || GET_MODE (XEXP (rtl
, 0)) != mode
)
11920 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11921 VAR_INIT_STATUS_INITIALIZED
);
11925 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
11926 VAR_INIT_STATUS_INITIALIZED
);
11929 add_loc_descr (&ret
, tmp
);
11930 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11931 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
11932 add_loc_descr (&ret
, l1label
);
11933 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11934 add_loc_descr (&ret
, l2jump
);
11935 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11936 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
11937 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11938 VAR_INIT_STATUS_INITIALIZED
);
11941 add_loc_descr (&ret
, tmp
);
11942 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
11943 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
11944 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
11945 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11946 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11947 VAR_INIT_STATUS_INITIALIZED
);
11948 add_loc_descr (&ret
, tmp
);
11949 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
11950 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11951 add_loc_descr (&ret
, l1jump
);
11952 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
11953 add_loc_descr (&ret
, l2label
);
11954 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11955 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
11956 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11957 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
11961 /* BSWAP (constS is initial shift count, either 56 or 24):
11963 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
11964 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
11965 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
11966 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
11967 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
11969 static dw_loc_descr_ref
11970 bswap_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11971 enum machine_mode mem_mode
)
11973 dw_loc_descr_ref op0
, ret
, tmp
;
11974 dw_loc_descr_ref l1jump
, l1label
;
11975 dw_loc_descr_ref l2jump
, l2label
;
11977 if (GET_MODE_CLASS (mode
) != MODE_INT
11978 || BITS_PER_UNIT
!= 8
11979 || (GET_MODE_BITSIZE (mode
) != 32
11980 && GET_MODE_BITSIZE (mode
) != 64))
11983 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11984 VAR_INIT_STATUS_INITIALIZED
);
11989 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
11991 VAR_INIT_STATUS_INITIALIZED
);
11994 add_loc_descr (&ret
, tmp
);
11995 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
11996 VAR_INIT_STATUS_INITIALIZED
);
11999 add_loc_descr (&ret
, tmp
);
12000 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
12001 add_loc_descr (&ret
, l1label
);
12002 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12004 VAR_INIT_STATUS_INITIALIZED
);
12005 add_loc_descr (&ret
, tmp
);
12006 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
12007 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12008 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12009 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
12010 VAR_INIT_STATUS_INITIALIZED
);
12013 add_loc_descr (&ret
, tmp
);
12014 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12015 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
12016 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12017 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12018 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12019 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12020 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12021 VAR_INIT_STATUS_INITIALIZED
);
12022 add_loc_descr (&ret
, tmp
);
12023 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
12024 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12025 add_loc_descr (&ret
, l2jump
);
12026 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
12027 VAR_INIT_STATUS_INITIALIZED
);
12028 add_loc_descr (&ret
, tmp
);
12029 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12030 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12031 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12032 add_loc_descr (&ret
, l1jump
);
12033 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
12034 add_loc_descr (&ret
, l2label
);
12035 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12036 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
12037 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12038 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12039 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12040 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12044 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
12045 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12046 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
12047 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
12049 ROTATERT is similar:
12050 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
12051 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12052 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
12054 static dw_loc_descr_ref
12055 rotate_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12056 enum machine_mode mem_mode
)
12058 rtx rtlop1
= XEXP (rtl
, 1);
12059 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
12062 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12065 if (GET_MODE (rtlop1
) != VOIDmode
12066 && GET_MODE_BITSIZE (GET_MODE (rtlop1
)) < GET_MODE_BITSIZE (mode
))
12067 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12068 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12069 VAR_INIT_STATUS_INITIALIZED
);
12070 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12071 VAR_INIT_STATUS_INITIALIZED
);
12072 if (op0
== NULL
|| op1
== NULL
)
12074 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
12075 for (i
= 0; i
< 2; i
++)
12077 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
12078 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
12080 VAR_INIT_STATUS_INITIALIZED
);
12081 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12082 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12084 : HOST_BITS_PER_WIDE_INT
== 64
12085 ? DW_OP_const8u
: DW_OP_constu
,
12086 GET_MODE_MASK (mode
), 0);
12089 if (mask
[i
] == NULL
)
12091 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
12094 add_loc_descr (&ret
, op1
);
12095 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12096 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12097 if (GET_CODE (rtl
) == ROTATERT
)
12099 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12100 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12101 GET_MODE_BITSIZE (mode
), 0));
12103 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12104 if (mask
[0] != NULL
)
12105 add_loc_descr (&ret
, mask
[0]);
12106 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
12107 if (mask
[1] != NULL
)
12109 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12110 add_loc_descr (&ret
, mask
[1]);
12111 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12113 if (GET_CODE (rtl
) == ROTATE
)
12115 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12116 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12117 GET_MODE_BITSIZE (mode
), 0));
12119 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12120 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12124 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
12125 for DEBUG_PARAMETER_REF RTL. */
12127 static dw_loc_descr_ref
12128 parameter_ref_descriptor (rtx rtl
)
12130 dw_loc_descr_ref ret
;
12135 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
12136 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
12137 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
12140 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12141 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
12142 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12146 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
12147 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
12152 /* The following routine converts the RTL for a variable or parameter
12153 (resident in memory) into an equivalent Dwarf representation of a
12154 mechanism for getting the address of that same variable onto the top of a
12155 hypothetical "address evaluation" stack.
12157 When creating memory location descriptors, we are effectively transforming
12158 the RTL for a memory-resident object into its Dwarf postfix expression
12159 equivalent. This routine recursively descends an RTL tree, turning
12160 it into Dwarf postfix code as it goes.
12162 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
12164 MEM_MODE is the mode of the memory reference, needed to handle some
12165 autoincrement addressing modes.
12167 Return 0 if we can't represent the location. */
12170 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12171 enum machine_mode mem_mode
,
12172 enum var_init_status initialized
)
12174 dw_loc_descr_ref mem_loc_result
= NULL
;
12175 enum dwarf_location_atom op
;
12176 dw_loc_descr_ref op0
, op1
;
12177 rtx inner
= NULL_RTX
;
12179 if (mode
== VOIDmode
)
12180 mode
= GET_MODE (rtl
);
12182 /* Note that for a dynamically sized array, the location we will generate a
12183 description of here will be the lowest numbered location which is
12184 actually within the array. That's *not* necessarily the same as the
12185 zeroth element of the array. */
12187 rtl
= targetm
.delegitimize_address (rtl
);
12189 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
12192 switch (GET_CODE (rtl
))
12197 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
12200 /* The case of a subreg may arise when we have a local (register)
12201 variable or a formal (register) parameter which doesn't quite fill
12202 up an entire register. For now, just assume that it is
12203 legitimate to make the Dwarf info refer to the whole register which
12204 contains the given subreg. */
12205 if (!subreg_lowpart_p (rtl
))
12207 inner
= SUBREG_REG (rtl
);
12209 if (inner
== NULL_RTX
)
12210 inner
= XEXP (rtl
, 0);
12211 if (GET_MODE_CLASS (mode
) == MODE_INT
12212 && GET_MODE_CLASS (GET_MODE (inner
)) == MODE_INT
12213 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12214 #ifdef POINTERS_EXTEND_UNSIGNED
12215 || (mode
== Pmode
&& mem_mode
!= VOIDmode
)
12218 && GET_MODE_SIZE (GET_MODE (inner
)) <= DWARF2_ADDR_SIZE
)
12220 mem_loc_result
= mem_loc_descriptor (inner
,
12222 mem_mode
, initialized
);
12227 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (inner
)))
12229 if (GET_MODE_SIZE (mode
) != GET_MODE_SIZE (GET_MODE (inner
))
12230 && (GET_MODE_CLASS (mode
) != MODE_INT
12231 || GET_MODE_CLASS (GET_MODE (inner
)) != MODE_INT
))
12235 dw_die_ref type_die
;
12236 dw_loc_descr_ref cvt
;
12238 mem_loc_result
= mem_loc_descriptor (inner
,
12240 mem_mode
, initialized
);
12241 if (mem_loc_result
== NULL
)
12243 type_die
= base_type_for_mode (mode
,
12244 GET_MODE_CLASS (mode
) == MODE_INT
);
12245 if (type_die
== NULL
)
12247 mem_loc_result
= NULL
;
12250 if (GET_MODE_SIZE (mode
)
12251 != GET_MODE_SIZE (GET_MODE (inner
)))
12252 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12254 cvt
= new_loc_descr (DW_OP_GNU_reinterpret
, 0, 0);
12255 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12256 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12257 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12258 add_loc_descr (&mem_loc_result
, cvt
);
12263 if (GET_MODE_CLASS (mode
) != MODE_INT
12264 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12265 && rtl
!= arg_pointer_rtx
12266 && rtl
!= frame_pointer_rtx
12267 #ifdef POINTERS_EXTEND_UNSIGNED
12268 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12272 dw_die_ref type_die
;
12273 unsigned int dbx_regnum
;
12277 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
12279 type_die
= base_type_for_mode (mode
,
12280 GET_MODE_CLASS (mode
) == MODE_INT
);
12281 if (type_die
== NULL
)
12284 dbx_regnum
= dbx_reg_number (rtl
);
12285 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12287 mem_loc_result
= new_loc_descr (DW_OP_GNU_regval_type
,
12289 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12290 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12291 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12294 /* Whenever a register number forms a part of the description of the
12295 method for calculating the (dynamic) address of a memory resident
12296 object, DWARF rules require the register number be referred to as
12297 a "base register". This distinction is not based in any way upon
12298 what category of register the hardware believes the given register
12299 belongs to. This is strictly DWARF terminology we're dealing with
12300 here. Note that in cases where the location of a memory-resident
12301 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12302 OP_CONST (0)) the actual DWARF location descriptor that we generate
12303 may just be OP_BASEREG (basereg). This may look deceptively like
12304 the object in question was allocated to a register (rather than in
12305 memory) so DWARF consumers need to be aware of the subtle
12306 distinction between OP_REG and OP_BASEREG. */
12307 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
12308 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
12309 else if (stack_realign_drap
12311 && crtl
->args
.internal_arg_pointer
== rtl
12312 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
12314 /* If RTL is internal_arg_pointer, which has been optimized
12315 out, use DRAP instead. */
12316 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
12317 VAR_INIT_STATUS_INITIALIZED
);
12323 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12325 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12326 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12329 else if (GET_CODE (rtl
) == ZERO_EXTEND
12330 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12331 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
12332 < HOST_BITS_PER_WIDE_INT
12333 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
12334 to expand zero extend as two shifts instead of
12336 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= 4)
12338 enum machine_mode imode
= GET_MODE (XEXP (rtl
, 0));
12339 mem_loc_result
= op0
;
12340 add_loc_descr (&mem_loc_result
,
12341 int_loc_descriptor (GET_MODE_MASK (imode
)));
12342 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
12344 else if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12346 int shift
= DWARF2_ADDR_SIZE
12347 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
12348 shift
*= BITS_PER_UNIT
;
12349 if (GET_CODE (rtl
) == SIGN_EXTEND
)
12353 mem_loc_result
= op0
;
12354 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12355 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
12356 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12357 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12359 else if (!dwarf_strict
)
12361 dw_die_ref type_die1
, type_die2
;
12362 dw_loc_descr_ref cvt
;
12364 type_die1
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
12365 GET_CODE (rtl
) == ZERO_EXTEND
);
12366 if (type_die1
== NULL
)
12368 type_die2
= base_type_for_mode (mode
, 1);
12369 if (type_die2
== NULL
)
12371 mem_loc_result
= op0
;
12372 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12373 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12374 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
12375 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12376 add_loc_descr (&mem_loc_result
, cvt
);
12377 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12378 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12379 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
12380 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12381 add_loc_descr (&mem_loc_result
, cvt
);
12387 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
12388 if (new_rtl
!= rtl
)
12390 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
12392 if (mem_loc_result
!= NULL
)
12393 return mem_loc_result
;
12396 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
12397 get_address_mode (rtl
), mode
,
12398 VAR_INIT_STATUS_INITIALIZED
);
12399 if (mem_loc_result
== NULL
)
12400 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
12401 if (mem_loc_result
!= NULL
)
12403 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12404 || GET_MODE_CLASS (mode
) != MODE_INT
)
12406 dw_die_ref type_die
;
12407 dw_loc_descr_ref deref
;
12412 = base_type_for_mode (mode
, GET_MODE_CLASS (mode
) == MODE_INT
);
12413 if (type_die
== NULL
)
12415 deref
= new_loc_descr (DW_OP_GNU_deref_type
,
12416 GET_MODE_SIZE (mode
), 0);
12417 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12418 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12419 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12420 add_loc_descr (&mem_loc_result
, deref
);
12422 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
12423 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
12425 add_loc_descr (&mem_loc_result
,
12426 new_loc_descr (DW_OP_deref_size
,
12427 GET_MODE_SIZE (mode
), 0));
12432 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
12435 /* Some ports can transform a symbol ref into a label ref, because
12436 the symbol ref is too far away and has to be dumped into a constant
12440 if (GET_MODE_CLASS (mode
) != MODE_INT
12441 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12442 #ifdef POINTERS_EXTEND_UNSIGNED
12443 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12447 if (GET_CODE (rtl
) == SYMBOL_REF
12448 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
12450 dw_loc_descr_ref temp
;
12452 /* If this is not defined, we have no way to emit the data. */
12453 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
12456 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
12458 mem_loc_result
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
12459 add_loc_descr (&mem_loc_result
, temp
);
12464 if (!const_ok_for_output (rtl
))
12468 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
12469 vec_safe_push (used_rtx_array
, rtl
);
12475 case DEBUG_IMPLICIT_PTR
:
12476 expansion_failed (NULL_TREE
, rtl
,
12477 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
12483 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
12485 if (GET_MODE_CLASS (mode
) != MODE_INT
12486 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12487 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12488 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12491 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
12492 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12494 op0
= one_reg_loc_descriptor (dbx_regnum
,
12495 VAR_INIT_STATUS_INITIALIZED
);
12498 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
12499 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
12501 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12502 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12503 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
12507 gcc_unreachable ();
12510 mem_loc_result
= new_loc_descr (DW_OP_GNU_entry_value
, 0, 0);
12511 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12512 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
12515 case DEBUG_PARAMETER_REF
:
12516 mem_loc_result
= parameter_ref_descriptor (rtl
);
12520 /* Extract the PLUS expression nested inside and fall into
12521 PLUS code below. */
12522 rtl
= XEXP (rtl
, 1);
12527 /* Turn these into a PLUS expression and fall into the PLUS code
12529 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
12530 gen_int_mode (GET_CODE (rtl
) == PRE_INC
12531 ? GET_MODE_UNIT_SIZE (mem_mode
)
12532 : -GET_MODE_UNIT_SIZE (mem_mode
),
12535 /* ... fall through ... */
12539 if (is_based_loc (rtl
)
12540 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12541 || XEXP (rtl
, 0) == arg_pointer_rtx
12542 || XEXP (rtl
, 0) == frame_pointer_rtx
)
12543 && GET_MODE_CLASS (mode
) == MODE_INT
)
12544 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
12545 INTVAL (XEXP (rtl
, 1)),
12546 VAR_INIT_STATUS_INITIALIZED
);
12549 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12550 VAR_INIT_STATUS_INITIALIZED
);
12551 if (mem_loc_result
== 0)
12554 if (CONST_INT_P (XEXP (rtl
, 1))
12555 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12556 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
12559 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12560 VAR_INIT_STATUS_INITIALIZED
);
12563 add_loc_descr (&mem_loc_result
, op1
);
12564 add_loc_descr (&mem_loc_result
,
12565 new_loc_descr (DW_OP_plus
, 0, 0));
12570 /* If a pseudo-reg is optimized away, it is possible for it to
12571 be replaced with a MEM containing a multiply or shift. */
12582 && GET_MODE_CLASS (mode
) == MODE_INT
12583 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12585 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12586 base_type_for_mode (mode
, 0),
12610 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12612 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12613 VAR_INIT_STATUS_INITIALIZED
);
12615 rtx rtlop1
= XEXP (rtl
, 1);
12616 if (GET_MODE (rtlop1
) != VOIDmode
12617 && GET_MODE_BITSIZE (GET_MODE (rtlop1
))
12618 < GET_MODE_BITSIZE (mode
))
12619 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12620 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12621 VAR_INIT_STATUS_INITIALIZED
);
12624 if (op0
== 0 || op1
== 0)
12627 mem_loc_result
= op0
;
12628 add_loc_descr (&mem_loc_result
, op1
);
12629 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12645 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12646 VAR_INIT_STATUS_INITIALIZED
);
12647 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12648 VAR_INIT_STATUS_INITIALIZED
);
12650 if (op0
== 0 || op1
== 0)
12653 mem_loc_result
= op0
;
12654 add_loc_descr (&mem_loc_result
, op1
);
12655 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12659 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
&& !dwarf_strict
)
12661 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
12662 base_type_for_mode (mode
, 0),
12667 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12668 VAR_INIT_STATUS_INITIALIZED
);
12669 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12670 VAR_INIT_STATUS_INITIALIZED
);
12672 if (op0
== 0 || op1
== 0)
12675 mem_loc_result
= op0
;
12676 add_loc_descr (&mem_loc_result
, op1
);
12677 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12678 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12679 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
12680 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
12681 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
12685 if (!dwarf_strict
&& GET_MODE_CLASS (mode
) == MODE_INT
)
12687 if (GET_MODE_CLASS (mode
) > DWARF2_ADDR_SIZE
)
12692 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12693 base_type_for_mode (mode
, 1),
12711 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12712 VAR_INIT_STATUS_INITIALIZED
);
12717 mem_loc_result
= op0
;
12718 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12722 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12723 #ifdef POINTERS_EXTEND_UNSIGNED
12725 && mem_mode
!= VOIDmode
12726 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
12730 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12734 && (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
12735 || GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_DOUBLE_INT
))
12737 dw_die_ref type_die
= base_type_for_mode (mode
, 1);
12738 enum machine_mode amode
;
12739 if (type_die
== NULL
)
12741 amode
= mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
,
12743 if (INTVAL (rtl
) >= 0
12744 && amode
!= BLKmode
12745 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
12746 /* const DW_OP_GNU_convert <XXX> vs.
12747 DW_OP_GNU_const_type <XXX, 1, const>. */
12748 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
12749 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode
))
12751 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12752 op0
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12753 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12754 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12755 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12756 add_loc_descr (&mem_loc_result
, op0
);
12757 return mem_loc_result
;
12759 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0,
12761 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12762 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12763 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12764 if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12765 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
12768 mem_loc_result
->dw_loc_oprnd2
.val_class
12769 = dw_val_class_const_double
;
12770 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12771 = double_int::from_shwi (INTVAL (rtl
));
12779 dw_die_ref type_die
;
12781 /* Note that a CONST_DOUBLE rtx could represent either an integer
12782 or a floating-point constant. A CONST_DOUBLE is used whenever
12783 the constant requires more than one word in order to be
12784 adequately represented. We output CONST_DOUBLEs as blocks. */
12785 if (mode
== VOIDmode
12786 || (GET_MODE (rtl
) == VOIDmode
12787 && GET_MODE_BITSIZE (mode
) != HOST_BITS_PER_DOUBLE_INT
))
12789 type_die
= base_type_for_mode (mode
,
12790 GET_MODE_CLASS (mode
) == MODE_INT
);
12791 if (type_die
== NULL
)
12793 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
12794 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12795 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12796 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12797 if (SCALAR_FLOAT_MODE_P (mode
))
12799 unsigned int length
= GET_MODE_SIZE (mode
);
12800 unsigned char *array
12801 = (unsigned char*) ggc_alloc_atomic (length
);
12803 insert_float (rtl
, array
);
12804 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
12805 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
12806 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
12807 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
12811 mem_loc_result
->dw_loc_oprnd2
.val_class
12812 = dw_val_class_const_double
;
12813 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12814 = rtx_to_double_int (rtl
);
12820 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
12824 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
12828 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
12832 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
12836 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
12840 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
12844 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
12848 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
12852 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
12856 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
12861 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12866 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
12871 if (CONST_INT_P (XEXP (rtl
, 1))
12872 && CONST_INT_P (XEXP (rtl
, 2))
12873 && ((unsigned) INTVAL (XEXP (rtl
, 1))
12874 + (unsigned) INTVAL (XEXP (rtl
, 2))
12875 <= GET_MODE_BITSIZE (mode
))
12876 && GET_MODE_CLASS (mode
) == MODE_INT
12877 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12878 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
12881 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12882 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12885 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
12889 mem_loc_result
= op0
;
12890 size
= INTVAL (XEXP (rtl
, 1));
12891 shift
= INTVAL (XEXP (rtl
, 2));
12892 if (BITS_BIG_ENDIAN
)
12893 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
12895 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
12897 add_loc_descr (&mem_loc_result
,
12898 int_loc_descriptor (DWARF2_ADDR_SIZE
12900 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
12902 if (size
!= (int) DWARF2_ADDR_SIZE
)
12904 add_loc_descr (&mem_loc_result
,
12905 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
12906 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12913 dw_loc_descr_ref op2
, bra_node
, drop_node
;
12914 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
12915 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
12916 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
12917 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12918 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12919 VAR_INIT_STATUS_INITIALIZED
);
12920 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
12921 VAR_INIT_STATUS_INITIALIZED
);
12922 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
12925 mem_loc_result
= op1
;
12926 add_loc_descr (&mem_loc_result
, op2
);
12927 add_loc_descr (&mem_loc_result
, op0
);
12928 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
12929 add_loc_descr (&mem_loc_result
, bra_node
);
12930 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
12931 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
12932 add_loc_descr (&mem_loc_result
, drop_node
);
12933 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12934 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
12939 case FLOAT_TRUNCATE
:
12941 case UNSIGNED_FLOAT
:
12946 dw_die_ref type_die
;
12947 dw_loc_descr_ref cvt
;
12949 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12950 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12953 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl
, 0))) == MODE_INT
12954 && (GET_CODE (rtl
) == FLOAT
12955 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)))
12956 <= DWARF2_ADDR_SIZE
))
12958 type_die
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
12959 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
12960 if (type_die
== NULL
)
12962 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12963 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12964 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12965 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12966 add_loc_descr (&op0
, cvt
);
12968 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
12969 if (type_die
== NULL
)
12971 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12972 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12973 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12974 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12975 add_loc_descr (&op0
, cvt
);
12976 if (GET_MODE_CLASS (mode
) == MODE_INT
12977 && (GET_CODE (rtl
) == FIX
12978 || GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
))
12980 op0
= convert_descriptor_to_mode (mode
, op0
);
12984 mem_loc_result
= op0
;
12991 mem_loc_result
= clz_loc_descriptor (rtl
, mode
, mem_mode
);
12996 mem_loc_result
= popcount_loc_descriptor (rtl
, mode
, mem_mode
);
13000 mem_loc_result
= bswap_loc_descriptor (rtl
, mode
, mem_mode
);
13005 mem_loc_result
= rotate_loc_descriptor (rtl
, mode
, mem_mode
);
13009 /* In theory, we could implement the above. */
13010 /* DWARF cannot represent the unsigned compare operations
13035 case FRACT_CONVERT
:
13036 case UNSIGNED_FRACT_CONVERT
:
13038 case UNSIGNED_SAT_FRACT
:
13044 case VEC_DUPLICATE
:
13048 case STRICT_LOW_PART
:
13053 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13054 can't express it in the debug info. This can happen e.g. with some
13059 resolve_one_addr (&rtl
, NULL
);
13063 #ifdef ENABLE_CHECKING
13064 print_rtl (stderr
, rtl
);
13065 gcc_unreachable ();
13071 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13072 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13074 return mem_loc_result
;
13077 /* Return a descriptor that describes the concatenation of two locations.
13078 This is typically a complex variable. */
13080 static dw_loc_descr_ref
13081 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
13083 dw_loc_descr_ref cc_loc_result
= NULL
;
13084 dw_loc_descr_ref x0_ref
13085 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13086 dw_loc_descr_ref x1_ref
13087 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13089 if (x0_ref
== 0 || x1_ref
== 0)
13092 cc_loc_result
= x0_ref
;
13093 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
13095 add_loc_descr (&cc_loc_result
, x1_ref
);
13096 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
13098 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13099 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13101 return cc_loc_result
;
13104 /* Return a descriptor that describes the concatenation of N
13107 static dw_loc_descr_ref
13108 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
13111 dw_loc_descr_ref cc_loc_result
= NULL
;
13112 unsigned int n
= XVECLEN (concatn
, 0);
13114 for (i
= 0; i
< n
; ++i
)
13116 dw_loc_descr_ref ref
;
13117 rtx x
= XVECEXP (concatn
, 0, i
);
13119 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13123 add_loc_descr (&cc_loc_result
, ref
);
13124 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
13127 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13128 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13130 return cc_loc_result
;
13133 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
13134 for DEBUG_IMPLICIT_PTR RTL. */
13136 static dw_loc_descr_ref
13137 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
13139 dw_loc_descr_ref ret
;
13144 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
13145 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
13146 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
13147 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
13148 ret
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
13149 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13152 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13153 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
13154 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13158 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
13159 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
13164 /* Output a proper Dwarf location descriptor for a variable or parameter
13165 which is either allocated in a register or in a memory location. For a
13166 register, we just generate an OP_REG and the register number. For a
13167 memory location we provide a Dwarf postfix expression describing how to
13168 generate the (dynamic) address of the object onto the address stack.
13170 MODE is mode of the decl if this loc_descriptor is going to be used in
13171 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13172 allowed, VOIDmode otherwise.
13174 If we don't know how to describe it, return 0. */
13176 static dw_loc_descr_ref
13177 loc_descriptor (rtx rtl
, enum machine_mode mode
,
13178 enum var_init_status initialized
)
13180 dw_loc_descr_ref loc_result
= NULL
;
13182 switch (GET_CODE (rtl
))
13185 /* The case of a subreg may arise when we have a local (register)
13186 variable or a formal (register) parameter which doesn't quite fill
13187 up an entire register. For now, just assume that it is
13188 legitimate to make the Dwarf info refer to the whole register which
13189 contains the given subreg. */
13190 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
13191 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
13192 GET_MODE (SUBREG_REG (rtl
)), initialized
);
13198 loc_result
= reg_loc_descriptor (rtl
, initialized
);
13202 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
13203 GET_MODE (rtl
), initialized
);
13204 if (loc_result
== NULL
)
13205 loc_result
= tls_mem_loc_descriptor (rtl
);
13206 if (loc_result
== NULL
)
13208 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
13209 if (new_rtl
!= rtl
)
13210 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
13215 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
13220 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
13225 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
13227 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
13228 if (GET_CODE (loc
) == EXPR_LIST
)
13229 loc
= XEXP (loc
, 0);
13230 loc_result
= loc_descriptor (loc
, mode
, initialized
);
13234 rtl
= XEXP (rtl
, 1);
13239 rtvec par_elems
= XVEC (rtl
, 0);
13240 int num_elem
= GET_NUM_ELEM (par_elems
);
13241 enum machine_mode mode
;
13244 /* Create the first one, so we have something to add to. */
13245 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
13246 VOIDmode
, initialized
);
13247 if (loc_result
== NULL
)
13249 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
13250 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13251 for (i
= 1; i
< num_elem
; i
++)
13253 dw_loc_descr_ref temp
;
13255 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
13256 VOIDmode
, initialized
);
13259 add_loc_descr (&loc_result
, temp
);
13260 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
13261 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13267 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
13268 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
13273 if (mode
== VOIDmode
)
13274 mode
= GET_MODE (rtl
);
13276 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13278 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13280 /* Note that a CONST_DOUBLE rtx could represent either an integer
13281 or a floating-point constant. A CONST_DOUBLE is used whenever
13282 the constant requires more than one word in order to be
13283 adequately represented. We output CONST_DOUBLEs as blocks. */
13284 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13285 GET_MODE_SIZE (mode
), 0);
13286 if (SCALAR_FLOAT_MODE_P (mode
))
13288 unsigned int length
= GET_MODE_SIZE (mode
);
13289 unsigned char *array
13290 = (unsigned char*) ggc_alloc_atomic (length
);
13292 insert_float (rtl
, array
);
13293 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13294 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
13295 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
13296 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13300 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
13301 loc_result
->dw_loc_oprnd2
.v
.val_double
13302 = rtx_to_double_int (rtl
);
13308 if (mode
== VOIDmode
)
13309 mode
= GET_MODE (rtl
);
13311 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13313 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
13314 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
13315 unsigned char *array
= (unsigned char *)
13316 ggc_alloc_atomic (length
* elt_size
);
13320 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13321 switch (GET_MODE_CLASS (mode
))
13323 case MODE_VECTOR_INT
:
13324 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13326 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13327 double_int val
= rtx_to_double_int (elt
);
13329 if (elt_size
<= sizeof (HOST_WIDE_INT
))
13330 insert_int (val
.to_shwi (), elt_size
, p
);
13333 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
13334 insert_double (val
, p
);
13339 case MODE_VECTOR_FLOAT
:
13340 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13342 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13343 insert_float (elt
, p
);
13348 gcc_unreachable ();
13351 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13352 length
* elt_size
, 0);
13353 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13354 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
13355 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
13356 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13361 if (mode
== VOIDmode
13362 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
13363 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
13364 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
13366 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
13371 if (!const_ok_for_output (rtl
))
13374 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
13375 && (dwarf_version
>= 4 || !dwarf_strict
))
13377 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
13378 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13379 vec_safe_push (used_rtx_array
, rtl
);
13383 case DEBUG_IMPLICIT_PTR
:
13384 loc_result
= implicit_ptr_descriptor (rtl
, 0);
13388 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
13389 && CONST_INT_P (XEXP (rtl
, 1)))
13392 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
13398 if ((GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE (rtl
) == mode
13399 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
13400 && dwarf_version
>= 4)
13401 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
13403 /* Value expression. */
13404 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
13406 add_loc_descr (&loc_result
,
13407 new_loc_descr (DW_OP_stack_value
, 0, 0));
13415 /* We need to figure out what section we should use as the base for the
13416 address ranges where a given location is valid.
13417 1. If this particular DECL has a section associated with it, use that.
13418 2. If this function has a section associated with it, use that.
13419 3. Otherwise, use the text section.
13420 XXX: If you split a variable across multiple sections, we won't notice. */
13422 static const char *
13423 secname_for_decl (const_tree decl
)
13425 const char *secname
;
13427 if (VAR_OR_FUNCTION_DECL_P (decl
) && DECL_SECTION_NAME (decl
))
13429 tree sectree
= DECL_SECTION_NAME (decl
);
13430 secname
= TREE_STRING_POINTER (sectree
);
13432 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
13434 tree sectree
= DECL_SECTION_NAME (current_function_decl
);
13435 secname
= TREE_STRING_POINTER (sectree
);
13437 else if (cfun
&& in_cold_section_p
)
13438 secname
= crtl
->subsections
.cold_section_label
;
13440 secname
= text_section_label
;
13445 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13448 decl_by_reference_p (tree decl
)
13450 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
13451 || TREE_CODE (decl
) == VAR_DECL
)
13452 && DECL_BY_REFERENCE (decl
));
13455 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13458 static dw_loc_descr_ref
13459 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
13460 enum var_init_status initialized
)
13462 int have_address
= 0;
13463 dw_loc_descr_ref descr
;
13464 enum machine_mode mode
;
13466 if (want_address
!= 2)
13468 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
13470 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13472 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13473 if (GET_CODE (varloc
) == EXPR_LIST
)
13474 varloc
= XEXP (varloc
, 0);
13475 mode
= GET_MODE (varloc
);
13476 if (MEM_P (varloc
))
13478 rtx addr
= XEXP (varloc
, 0);
13479 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
13480 mode
, initialized
);
13485 rtx x
= avoid_constant_pool_reference (varloc
);
13487 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
13492 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
13499 if (GET_CODE (varloc
) == VAR_LOCATION
)
13500 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
13502 mode
= DECL_MODE (loc
);
13503 descr
= loc_descriptor (varloc
, mode
, initialized
);
13510 if (want_address
== 2 && !have_address
13511 && (dwarf_version
>= 4 || !dwarf_strict
))
13513 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
13515 expansion_failed (loc
, NULL_RTX
,
13516 "DWARF address size mismatch");
13519 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13522 /* Show if we can't fill the request for an address. */
13523 if (want_address
&& !have_address
)
13525 expansion_failed (loc
, NULL_RTX
,
13526 "Want address and only have value");
13530 /* If we've got an address and don't want one, dereference. */
13531 if (!want_address
&& have_address
)
13533 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
13534 enum dwarf_location_atom op
;
13536 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
13538 expansion_failed (loc
, NULL_RTX
,
13539 "DWARF address size mismatch");
13542 else if (size
== DWARF2_ADDR_SIZE
)
13545 op
= DW_OP_deref_size
;
13547 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
13553 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
13554 if it is not possible. */
13556 static dw_loc_descr_ref
13557 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
13559 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
13560 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
13561 else if (dwarf_version
>= 3 || !dwarf_strict
)
13562 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
13567 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13568 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
13570 static dw_loc_descr_ref
13571 dw_sra_loc_expr (tree decl
, rtx loc
)
13574 unsigned int padsize
= 0;
13575 dw_loc_descr_ref descr
, *descr_tail
;
13576 unsigned HOST_WIDE_INT decl_size
;
13578 enum var_init_status initialized
;
13580 if (DECL_SIZE (decl
) == NULL
13581 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
13584 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
13586 descr_tail
= &descr
;
13588 for (p
= loc
; p
; p
= XEXP (p
, 1))
13590 unsigned int bitsize
= decl_piece_bitsize (p
);
13591 rtx loc_note
= *decl_piece_varloc_ptr (p
);
13592 dw_loc_descr_ref cur_descr
;
13593 dw_loc_descr_ref
*tail
, last
= NULL
;
13594 unsigned int opsize
= 0;
13596 if (loc_note
== NULL_RTX
13597 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
13599 padsize
+= bitsize
;
13602 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
13603 varloc
= NOTE_VAR_LOCATION (loc_note
);
13604 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
13605 if (cur_descr
== NULL
)
13607 padsize
+= bitsize
;
13611 /* Check that cur_descr either doesn't use
13612 DW_OP_*piece operations, or their sum is equal
13613 to bitsize. Otherwise we can't embed it. */
13614 for (tail
= &cur_descr
; *tail
!= NULL
;
13615 tail
= &(*tail
)->dw_loc_next
)
13616 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
13618 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
13622 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
13624 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
13628 if (last
!= NULL
&& opsize
!= bitsize
)
13630 padsize
+= bitsize
;
13631 /* Discard the current piece of the descriptor and release any
13632 addr_table entries it uses. */
13633 remove_loc_list_addr_table_entries (cur_descr
);
13637 /* If there is a hole, add DW_OP_*piece after empty DWARF
13638 expression, which means that those bits are optimized out. */
13641 if (padsize
> decl_size
)
13643 remove_loc_list_addr_table_entries (cur_descr
);
13644 goto discard_descr
;
13646 decl_size
-= padsize
;
13647 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
13648 if (*descr_tail
== NULL
)
13650 remove_loc_list_addr_table_entries (cur_descr
);
13651 goto discard_descr
;
13653 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13656 *descr_tail
= cur_descr
;
13658 if (bitsize
> decl_size
)
13659 goto discard_descr
;
13660 decl_size
-= bitsize
;
13663 HOST_WIDE_INT offset
= 0;
13664 if (GET_CODE (varloc
) == VAR_LOCATION
13665 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13667 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13668 if (GET_CODE (varloc
) == EXPR_LIST
)
13669 varloc
= XEXP (varloc
, 0);
13673 if (GET_CODE (varloc
) == CONST
13674 || GET_CODE (varloc
) == SIGN_EXTEND
13675 || GET_CODE (varloc
) == ZERO_EXTEND
)
13676 varloc
= XEXP (varloc
, 0);
13677 else if (GET_CODE (varloc
) == SUBREG
)
13678 varloc
= SUBREG_REG (varloc
);
13683 /* DW_OP_bit_size offset should be zero for register
13684 or implicit location descriptions and empty location
13685 descriptions, but for memory addresses needs big endian
13687 if (MEM_P (varloc
))
13689 unsigned HOST_WIDE_INT memsize
13690 = MEM_SIZE (varloc
) * BITS_PER_UNIT
;
13691 if (memsize
!= bitsize
)
13693 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
13694 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
13695 goto discard_descr
;
13696 if (memsize
< bitsize
)
13697 goto discard_descr
;
13698 if (BITS_BIG_ENDIAN
)
13699 offset
= memsize
- bitsize
;
13703 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
13704 if (*descr_tail
== NULL
)
13705 goto discard_descr
;
13706 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13710 /* If there were any non-empty expressions, add padding till the end of
13712 if (descr
!= NULL
&& decl_size
!= 0)
13714 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
13715 if (*descr_tail
== NULL
)
13716 goto discard_descr
;
13721 /* Discard the descriptor and release any addr_table entries it uses. */
13722 remove_loc_list_addr_table_entries (descr
);
13726 /* Return the dwarf representation of the location list LOC_LIST of
13727 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
13730 static dw_loc_list_ref
13731 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
13733 const char *endname
, *secname
;
13735 enum var_init_status initialized
;
13736 struct var_loc_node
*node
;
13737 dw_loc_descr_ref descr
;
13738 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
13739 dw_loc_list_ref list
= NULL
;
13740 dw_loc_list_ref
*listp
= &list
;
13742 /* Now that we know what section we are using for a base,
13743 actually construct the list of locations.
13744 The first location information is what is passed to the
13745 function that creates the location list, and the remaining
13746 locations just get added on to that list.
13747 Note that we only know the start address for a location
13748 (IE location changes), so to build the range, we use
13749 the range [current location start, next location start].
13750 This means we have to special case the last node, and generate
13751 a range of [last location start, end of function label]. */
13753 secname
= secname_for_decl (decl
);
13755 for (node
= loc_list
->first
; node
; node
= node
->next
)
13756 if (GET_CODE (node
->loc
) == EXPR_LIST
13757 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
13759 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13761 /* This requires DW_OP_{,bit_}piece, which is not usable
13762 inside DWARF expressions. */
13763 if (want_address
!= 2)
13765 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13771 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13772 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13773 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
13777 bool range_across_switch
= false;
13778 /* If section switch happens in between node->label
13779 and node->next->label (or end of function) and
13780 we can't emit it as a single entry list,
13781 emit two ranges, first one ending at the end
13782 of first partition and second one starting at the
13783 beginning of second partition. */
13784 if (node
== loc_list
->last_before_switch
13785 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
13786 && current_function_decl
)
13788 endname
= cfun
->fde
->dw_fde_end
;
13789 range_across_switch
= true;
13791 /* The variable has a location between NODE->LABEL and
13792 NODE->NEXT->LABEL. */
13793 else if (node
->next
)
13794 endname
= node
->next
->label
;
13795 /* If the variable has a location at the last label
13796 it keeps its location until the end of function. */
13797 else if (!current_function_decl
)
13798 endname
= text_end_label
;
13801 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
13802 current_function_funcdef_no
);
13803 endname
= ggc_strdup (label_id
);
13806 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
13807 if (TREE_CODE (decl
) == PARM_DECL
13808 && node
== loc_list
->first
13809 && NOTE_P (node
->loc
)
13810 && strcmp (node
->label
, endname
) == 0)
13811 (*listp
)->force
= true;
13812 listp
= &(*listp
)->dw_loc_next
;
13814 if (range_across_switch
)
13816 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13817 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13820 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13821 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13822 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
13825 gcc_assert (descr
);
13826 /* The variable has a location between NODE->LABEL and
13827 NODE->NEXT->LABEL. */
13829 endname
= node
->next
->label
;
13831 endname
= cfun
->fde
->dw_fde_second_end
;
13832 *listp
= new_loc_list (descr
,
13833 cfun
->fde
->dw_fde_second_begin
,
13835 listp
= &(*listp
)->dw_loc_next
;
13840 /* Try to avoid the overhead of a location list emitting a location
13841 expression instead, but only if we didn't have more than one
13842 location entry in the first place. If some entries were not
13843 representable, we don't want to pretend a single entry that was
13844 applies to the entire scope in which the variable is
13846 if (list
&& loc_list
->first
->next
)
13852 /* Return if the loc_list has only single element and thus can be represented
13853 as location description. */
13856 single_element_loc_list_p (dw_loc_list_ref list
)
13858 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
13859 return !list
->ll_symbol
;
13862 /* To each location in list LIST add loc descr REF. */
13865 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
13867 dw_loc_descr_ref copy
;
13868 add_loc_descr (&list
->expr
, ref
);
13869 list
= list
->dw_loc_next
;
13872 copy
= ggc_alloc_dw_loc_descr_node ();
13873 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
13874 add_loc_descr (&list
->expr
, copy
);
13875 while (copy
->dw_loc_next
)
13877 dw_loc_descr_ref new_copy
= ggc_alloc_dw_loc_descr_node ();
13878 memcpy (new_copy
, copy
->dw_loc_next
, sizeof (dw_loc_descr_node
));
13879 copy
->dw_loc_next
= new_copy
;
13882 list
= list
->dw_loc_next
;
13886 /* Given two lists RET and LIST
13887 produce location list that is result of adding expression in LIST
13888 to expression in RET on each position in program.
13889 Might be destructive on both RET and LIST.
13891 TODO: We handle only simple cases of RET or LIST having at most one
13892 element. General case would inolve sorting the lists in program order
13893 and merging them that will need some additional work.
13894 Adding that will improve quality of debug info especially for SRA-ed
13898 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
13907 if (!list
->dw_loc_next
)
13909 add_loc_descr_to_each (*ret
, list
->expr
);
13912 if (!(*ret
)->dw_loc_next
)
13914 add_loc_descr_to_each (list
, (*ret
)->expr
);
13918 expansion_failed (NULL_TREE
, NULL_RTX
,
13919 "Don't know how to merge two non-trivial"
13920 " location lists.\n");
13925 /* LOC is constant expression. Try a luck, look it up in constant
13926 pool and return its loc_descr of its address. */
13928 static dw_loc_descr_ref
13929 cst_pool_loc_descr (tree loc
)
13931 /* Get an RTL for this, if something has been emitted. */
13932 rtx rtl
= lookup_constant_def (loc
);
13934 if (!rtl
|| !MEM_P (rtl
))
13939 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
13941 /* TODO: We might get more coverage if we was actually delaying expansion
13942 of all expressions till end of compilation when constant pools are fully
13944 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
13946 expansion_failed (loc
, NULL_RTX
,
13947 "CST value in contant pool but not marked.");
13950 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
13951 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
13954 /* Return dw_loc_list representing address of addr_expr LOC
13955 by looking for inner INDIRECT_REF expression and turning
13956 it into simple arithmetics. */
13958 static dw_loc_list_ref
13959 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
)
13962 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
13963 enum machine_mode mode
;
13964 int unsignedp
, volatilep
= 0;
13965 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
13967 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
13968 &bitsize
, &bitpos
, &offset
, &mode
,
13969 &unsignedp
, &volatilep
, false);
13971 if (bitpos
% BITS_PER_UNIT
)
13973 expansion_failed (loc
, NULL_RTX
, "bitfield access");
13976 if (!INDIRECT_REF_P (obj
))
13978 expansion_failed (obj
,
13979 NULL_RTX
, "no indirect ref in inner refrence");
13982 if (!offset
&& !bitpos
)
13983 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1);
13985 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
13986 && (dwarf_version
>= 4 || !dwarf_strict
))
13988 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0);
13993 /* Variable offset. */
13994 list_ret1
= loc_list_from_tree (offset
, 0);
13995 if (list_ret1
== 0)
13997 add_loc_list (&list_ret
, list_ret1
);
14000 add_loc_descr_to_each (list_ret
,
14001 new_loc_descr (DW_OP_plus
, 0, 0));
14003 bytepos
= bitpos
/ BITS_PER_UNIT
;
14005 add_loc_descr_to_each (list_ret
,
14006 new_loc_descr (DW_OP_plus_uconst
,
14008 else if (bytepos
< 0)
14009 loc_list_plus_const (list_ret
, bytepos
);
14010 add_loc_descr_to_each (list_ret
,
14011 new_loc_descr (DW_OP_stack_value
, 0, 0));
14017 /* Generate Dwarf location list representing LOC.
14018 If WANT_ADDRESS is false, expression computing LOC will be computed
14019 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14020 if WANT_ADDRESS is 2, expression computing address useable in location
14021 will be returned (i.e. DW_OP_reg can be used
14022 to refer to register values). */
14024 static dw_loc_list_ref
14025 loc_list_from_tree (tree loc
, int want_address
)
14027 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
14028 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14029 int have_address
= 0;
14030 enum dwarf_location_atom op
;
14032 /* ??? Most of the time we do not take proper care for sign/zero
14033 extending the values properly. Hopefully this won't be a real
14036 switch (TREE_CODE (loc
))
14039 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
14042 case PLACEHOLDER_EXPR
:
14043 /* This case involves extracting fields from an object to determine the
14044 position of other fields. We don't try to encode this here. The
14045 only user of this is Ada, which encodes the needed information using
14046 the names of types. */
14047 expansion_failed (loc
, NULL_RTX
, "PLACEHOLDER_EXPR");
14051 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
14052 /* There are no opcodes for these operations. */
14055 case PREINCREMENT_EXPR
:
14056 case PREDECREMENT_EXPR
:
14057 case POSTINCREMENT_EXPR
:
14058 case POSTDECREMENT_EXPR
:
14059 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
14060 /* There are no opcodes for these operations. */
14064 /* If we already want an address, see if there is INDIRECT_REF inside
14065 e.g. for &this->field. */
14068 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
14069 (loc
, want_address
== 2);
14072 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
14073 && (ret
= cst_pool_loc_descr (loc
)))
14076 /* Otherwise, process the argument and look for the address. */
14077 if (!list_ret
&& !ret
)
14078 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 1);
14082 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
14088 if (DECL_THREAD_LOCAL_P (loc
))
14091 enum dwarf_location_atom tls_op
;
14092 enum dtprel_bool dtprel
= dtprel_false
;
14094 if (targetm
.have_tls
)
14096 /* If this is not defined, we have no way to emit the
14098 if (!targetm
.asm_out
.output_dwarf_dtprel
)
14101 /* The way DW_OP_GNU_push_tls_address is specified, we
14102 can only look up addresses of objects in the current
14103 module. We used DW_OP_addr as first op, but that's
14104 wrong, because DW_OP_addr is relocated by the debug
14105 info consumer, while DW_OP_GNU_push_tls_address
14106 operand shouldn't be. */
14107 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
14109 dtprel
= dtprel_true
;
14110 tls_op
= DW_OP_GNU_push_tls_address
;
14114 if (!targetm
.emutls
.debug_form_tls_address
14115 || !(dwarf_version
>= 3 || !dwarf_strict
))
14117 /* We stuffed the control variable into the DECL_VALUE_EXPR
14118 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
14119 no longer appear in gimple code. We used the control
14120 variable in specific so that we could pick it up here. */
14121 loc
= DECL_VALUE_EXPR (loc
);
14122 tls_op
= DW_OP_form_tls_address
;
14125 rtl
= rtl_for_decl_location (loc
);
14126 if (rtl
== NULL_RTX
)
14131 rtl
= XEXP (rtl
, 0);
14132 if (! CONSTANT_P (rtl
))
14135 ret
= new_addr_loc_descr (rtl
, dtprel
);
14136 ret1
= new_loc_descr (tls_op
, 0, 0);
14137 add_loc_descr (&ret
, ret1
);
14146 if (DECL_HAS_VALUE_EXPR_P (loc
))
14147 return loc_list_from_tree (DECL_VALUE_EXPR (loc
),
14151 case FUNCTION_DECL
:
14154 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
14156 if (loc_list
&& loc_list
->first
)
14158 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
14159 have_address
= want_address
!= 0;
14162 rtl
= rtl_for_decl_location (loc
);
14163 if (rtl
== NULL_RTX
)
14165 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
14168 else if (CONST_INT_P (rtl
))
14170 HOST_WIDE_INT val
= INTVAL (rtl
);
14171 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14172 val
&= GET_MODE_MASK (DECL_MODE (loc
));
14173 ret
= int_loc_descriptor (val
);
14175 else if (GET_CODE (rtl
) == CONST_STRING
)
14177 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
14180 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
14181 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
14184 enum machine_mode mode
, mem_mode
;
14186 /* Certain constructs can only be represented at top-level. */
14187 if (want_address
== 2)
14189 ret
= loc_descriptor (rtl
, VOIDmode
,
14190 VAR_INIT_STATUS_INITIALIZED
);
14195 mode
= GET_MODE (rtl
);
14196 mem_mode
= VOIDmode
;
14200 mode
= get_address_mode (rtl
);
14201 rtl
= XEXP (rtl
, 0);
14204 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
14205 VAR_INIT_STATUS_INITIALIZED
);
14208 expansion_failed (loc
, rtl
,
14209 "failed to produce loc descriptor for rtl");
14216 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
14220 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14224 case COMPOUND_EXPR
:
14225 return loc_list_from_tree (TREE_OPERAND (loc
, 1), want_address
);
14228 case VIEW_CONVERT_EXPR
:
14231 return loc_list_from_tree (TREE_OPERAND (loc
, 0), want_address
);
14233 case COMPONENT_REF
:
14234 case BIT_FIELD_REF
:
14236 case ARRAY_RANGE_REF
:
14237 case REALPART_EXPR
:
14238 case IMAGPART_EXPR
:
14241 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14242 enum machine_mode mode
;
14243 int unsignedp
, volatilep
= 0;
14245 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
14246 &unsignedp
, &volatilep
, false);
14248 gcc_assert (obj
!= loc
);
14250 list_ret
= loc_list_from_tree (obj
,
14252 && !bitpos
&& !offset
? 2 : 1);
14253 /* TODO: We can extract value of the small expression via shifting even
14254 for nonzero bitpos. */
14257 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
14259 expansion_failed (loc
, NULL_RTX
,
14260 "bitfield access");
14264 if (offset
!= NULL_TREE
)
14266 /* Variable offset. */
14267 list_ret1
= loc_list_from_tree (offset
, 0);
14268 if (list_ret1
== 0)
14270 add_loc_list (&list_ret
, list_ret1
);
14273 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
14276 bytepos
= bitpos
/ BITS_PER_UNIT
;
14278 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
14279 else if (bytepos
< 0)
14280 loc_list_plus_const (list_ret
, bytepos
);
14287 if ((want_address
|| !tree_fits_shwi_p (loc
))
14288 && (ret
= cst_pool_loc_descr (loc
)))
14290 else if (want_address
== 2
14291 && tree_fits_shwi_p (loc
)
14292 && (ret
= address_of_int_loc_descriptor
14293 (int_size_in_bytes (TREE_TYPE (loc
)),
14294 tree_to_shwi (loc
))))
14296 else if (tree_fits_shwi_p (loc
))
14297 ret
= int_loc_descriptor (tree_to_shwi (loc
));
14300 expansion_failed (loc
, NULL_RTX
,
14301 "Integer operand is not host integer");
14310 if ((ret
= cst_pool_loc_descr (loc
)))
14313 /* We can construct small constants here using int_loc_descriptor. */
14314 expansion_failed (loc
, NULL_RTX
,
14315 "constructor or constant not in constant pool");
14318 case TRUTH_AND_EXPR
:
14319 case TRUTH_ANDIF_EXPR
:
14324 case TRUTH_XOR_EXPR
:
14329 case TRUTH_OR_EXPR
:
14330 case TRUTH_ORIF_EXPR
:
14335 case FLOOR_DIV_EXPR
:
14336 case CEIL_DIV_EXPR
:
14337 case ROUND_DIV_EXPR
:
14338 case TRUNC_DIV_EXPR
:
14339 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14348 case FLOOR_MOD_EXPR
:
14349 case CEIL_MOD_EXPR
:
14350 case ROUND_MOD_EXPR
:
14351 case TRUNC_MOD_EXPR
:
14352 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14357 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14358 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14359 if (list_ret
== 0 || list_ret1
== 0)
14362 add_loc_list (&list_ret
, list_ret1
);
14365 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14366 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14367 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
14368 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14369 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14381 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
14384 case POINTER_PLUS_EXPR
:
14386 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
14388 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14392 loc_list_plus_const (list_ret
, tree_to_shwi (TREE_OPERAND (loc
, 1)));
14400 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14407 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14414 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14421 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14436 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14437 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14438 if (list_ret
== 0 || list_ret1
== 0)
14441 add_loc_list (&list_ret
, list_ret1
);
14444 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14447 case TRUTH_NOT_EXPR
:
14461 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14465 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14471 const enum tree_code code
=
14472 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
14474 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
14475 build2 (code
, integer_type_node
,
14476 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
14477 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
14480 /* ... fall through ... */
14484 dw_loc_descr_ref lhs
14485 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
14486 dw_loc_list_ref rhs
14487 = loc_list_from_tree (TREE_OPERAND (loc
, 2), 0);
14488 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
14490 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14491 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
14494 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14495 add_loc_descr_to_each (list_ret
, bra_node
);
14497 add_loc_list (&list_ret
, rhs
);
14498 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14499 add_loc_descr_to_each (list_ret
, jump_node
);
14501 add_loc_descr_to_each (list_ret
, lhs
);
14502 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14503 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
14505 /* ??? Need a node to point the skip at. Use a nop. */
14506 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14507 add_loc_descr_to_each (list_ret
, tmp
);
14508 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14509 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14513 case FIX_TRUNC_EXPR
:
14517 /* Leave front-end specific codes as simply unknown. This comes
14518 up, for instance, with the C STMT_EXPR. */
14519 if ((unsigned int) TREE_CODE (loc
)
14520 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
14522 expansion_failed (loc
, NULL_RTX
,
14523 "language specific tree node");
14527 #ifdef ENABLE_CHECKING
14528 /* Otherwise this is a generic code; we should just lists all of
14529 these explicitly. We forgot one. */
14530 gcc_unreachable ();
14532 /* In a release build, we want to degrade gracefully: better to
14533 generate incomplete debugging information than to crash. */
14538 if (!ret
&& !list_ret
)
14541 if (want_address
== 2 && !have_address
14542 && (dwarf_version
>= 4 || !dwarf_strict
))
14544 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
14546 expansion_failed (loc
, NULL_RTX
,
14547 "DWARF address size mismatch");
14551 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14553 add_loc_descr_to_each (list_ret
,
14554 new_loc_descr (DW_OP_stack_value
, 0, 0));
14557 /* Show if we can't fill the request for an address. */
14558 if (want_address
&& !have_address
)
14560 expansion_failed (loc
, NULL_RTX
,
14561 "Want address and only have value");
14565 gcc_assert (!ret
|| !list_ret
);
14567 /* If we've got an address and don't want one, dereference. */
14568 if (!want_address
&& have_address
)
14570 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
14572 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
14574 expansion_failed (loc
, NULL_RTX
,
14575 "DWARF address size mismatch");
14578 else if (size
== DWARF2_ADDR_SIZE
)
14581 op
= DW_OP_deref_size
;
14584 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
14586 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
14589 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
14594 /* Same as above but return only single location expression. */
14595 static dw_loc_descr_ref
14596 loc_descriptor_from_tree (tree loc
, int want_address
)
14598 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
);
14601 if (ret
->dw_loc_next
)
14603 expansion_failed (loc
, NULL_RTX
,
14604 "Location list where only loc descriptor needed");
14610 /* Given a value, round it up to the lowest multiple of `boundary'
14611 which is not less than the value itself. */
14613 static inline HOST_WIDE_INT
14614 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
14616 return (((value
+ boundary
- 1) / boundary
) * boundary
);
14619 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
14620 pointer to the declared type for the relevant field variable, or return
14621 `integer_type_node' if the given node turns out to be an
14622 ERROR_MARK node. */
14625 field_type (const_tree decl
)
14629 if (TREE_CODE (decl
) == ERROR_MARK
)
14630 return integer_type_node
;
14632 type
= DECL_BIT_FIELD_TYPE (decl
);
14633 if (type
== NULL_TREE
)
14634 type
= TREE_TYPE (decl
);
14639 /* Given a pointer to a tree node, return the alignment in bits for
14640 it, or else return BITS_PER_WORD if the node actually turns out to
14641 be an ERROR_MARK node. */
14643 static inline unsigned
14644 simple_type_align_in_bits (const_tree type
)
14646 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
14649 static inline unsigned
14650 simple_decl_align_in_bits (const_tree decl
)
14652 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
14655 /* Return the result of rounding T up to ALIGN. */
14657 static inline double_int
14658 round_up_to_align (double_int t
, unsigned int align
)
14660 double_int alignd
= double_int::from_uhwi (align
);
14662 t
+= double_int_minus_one
;
14663 t
= t
.div (alignd
, true, TRUNC_DIV_EXPR
);
14668 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
14669 lowest addressed byte of the "containing object" for the given FIELD_DECL,
14670 or return 0 if we are unable to determine what that offset is, either
14671 because the argument turns out to be a pointer to an ERROR_MARK node, or
14672 because the offset is actually variable. (We can't handle the latter case
14675 static HOST_WIDE_INT
14676 field_byte_offset (const_tree decl
)
14678 double_int object_offset_in_bits
;
14679 double_int object_offset_in_bytes
;
14680 double_int bitpos_int
;
14682 if (TREE_CODE (decl
) == ERROR_MARK
)
14685 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
14687 /* We cannot yet cope with fields whose positions are variable, so
14688 for now, when we see such things, we simply return 0. Someday, we may
14689 be able to handle such cases, but it will be damn difficult. */
14690 if (TREE_CODE (bit_position (decl
)) != INTEGER_CST
)
14693 bitpos_int
= tree_to_double_int (bit_position (decl
));
14695 #ifdef PCC_BITFIELD_TYPE_MATTERS
14696 if (PCC_BITFIELD_TYPE_MATTERS
)
14699 tree field_size_tree
;
14700 double_int deepest_bitpos
;
14701 double_int field_size_in_bits
;
14702 unsigned int type_align_in_bits
;
14703 unsigned int decl_align_in_bits
;
14704 double_int type_size_in_bits
;
14706 type
= field_type (decl
);
14707 type_size_in_bits
= double_int_type_size_in_bits (type
);
14708 type_align_in_bits
= simple_type_align_in_bits (type
);
14710 field_size_tree
= DECL_SIZE (decl
);
14712 /* The size could be unspecified if there was an error, or for
14713 a flexible array member. */
14714 if (!field_size_tree
)
14715 field_size_tree
= bitsize_zero_node
;
14717 /* If the size of the field is not constant, use the type size. */
14718 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
14719 field_size_in_bits
= tree_to_double_int (field_size_tree
);
14721 field_size_in_bits
= type_size_in_bits
;
14723 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
14725 /* The GCC front-end doesn't make any attempt to keep track of the
14726 starting bit offset (relative to the start of the containing
14727 structure type) of the hypothetical "containing object" for a
14728 bit-field. Thus, when computing the byte offset value for the
14729 start of the "containing object" of a bit-field, we must deduce
14730 this information on our own. This can be rather tricky to do in
14731 some cases. For example, handling the following structure type
14732 definition when compiling for an i386/i486 target (which only
14733 aligns long long's to 32-bit boundaries) can be very tricky:
14735 struct S { int field1; long long field2:31; };
14737 Fortunately, there is a simple rule-of-thumb which can be used
14738 in such cases. When compiling for an i386/i486, GCC will
14739 allocate 8 bytes for the structure shown above. It decides to
14740 do this based upon one simple rule for bit-field allocation.
14741 GCC allocates each "containing object" for each bit-field at
14742 the first (i.e. lowest addressed) legitimate alignment boundary
14743 (based upon the required minimum alignment for the declared
14744 type of the field) which it can possibly use, subject to the
14745 condition that there is still enough available space remaining
14746 in the containing object (when allocated at the selected point)
14747 to fully accommodate all of the bits of the bit-field itself.
14749 This simple rule makes it obvious why GCC allocates 8 bytes for
14750 each object of the structure type shown above. When looking
14751 for a place to allocate the "containing object" for `field2',
14752 the compiler simply tries to allocate a 64-bit "containing
14753 object" at each successive 32-bit boundary (starting at zero)
14754 until it finds a place to allocate that 64- bit field such that
14755 at least 31 contiguous (and previously unallocated) bits remain
14756 within that selected 64 bit field. (As it turns out, for the
14757 example above, the compiler finds it is OK to allocate the
14758 "containing object" 64-bit field at bit-offset zero within the
14761 Here we attempt to work backwards from the limited set of facts
14762 we're given, and we try to deduce from those facts, where GCC
14763 must have believed that the containing object started (within
14764 the structure type). The value we deduce is then used (by the
14765 callers of this routine) to generate DW_AT_location and
14766 DW_AT_bit_offset attributes for fields (both bit-fields and, in
14767 the case of DW_AT_location, regular fields as well). */
14769 /* Figure out the bit-distance from the start of the structure to
14770 the "deepest" bit of the bit-field. */
14771 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
14773 /* This is the tricky part. Use some fancy footwork to deduce
14774 where the lowest addressed bit of the containing object must
14776 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14778 /* Round up to type_align by default. This works best for
14780 object_offset_in_bits
14781 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
14783 if (object_offset_in_bits
.ugt (bitpos_int
))
14785 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14787 /* Round up to decl_align instead. */
14788 object_offset_in_bits
14789 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
14793 #endif /* PCC_BITFIELD_TYPE_MATTERS */
14794 object_offset_in_bits
= bitpos_int
;
14796 object_offset_in_bytes
14797 = object_offset_in_bits
.div (double_int::from_uhwi (BITS_PER_UNIT
),
14798 true, TRUNC_DIV_EXPR
);
14799 return object_offset_in_bytes
.to_shwi ();
14802 /* The following routines define various Dwarf attributes and any data
14803 associated with them. */
14805 /* Add a location description attribute value to a DIE.
14807 This emits location attributes suitable for whole variables and
14808 whole parameters. Note that the location attributes for struct fields are
14809 generated by the routine `data_member_location_attribute' below. */
14812 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
14813 dw_loc_list_ref descr
)
14817 if (single_element_loc_list_p (descr
))
14818 add_AT_loc (die
, attr_kind
, descr
->expr
);
14820 add_AT_loc_list (die
, attr_kind
, descr
);
14823 /* Add DW_AT_accessibility attribute to DIE if needed. */
14826 add_accessibility_attribute (dw_die_ref die
, tree decl
)
14828 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
14829 children, otherwise the default is DW_ACCESS_public. In DWARF2
14830 the default has always been DW_ACCESS_public. */
14831 if (TREE_PROTECTED (decl
))
14832 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
14833 else if (TREE_PRIVATE (decl
))
14835 if (dwarf_version
== 2
14836 || die
->die_parent
== NULL
14837 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
14838 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
14840 else if (dwarf_version
> 2
14842 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
14843 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
14846 /* Attach the specialized form of location attribute used for data members of
14847 struct and union types. In the special case of a FIELD_DECL node which
14848 represents a bit-field, the "offset" part of this special location
14849 descriptor must indicate the distance in bytes from the lowest-addressed
14850 byte of the containing struct or union type to the lowest-addressed byte of
14851 the "containing object" for the bit-field. (See the `field_byte_offset'
14854 For any given bit-field, the "containing object" is a hypothetical object
14855 (of some integral or enum type) within which the given bit-field lives. The
14856 type of this hypothetical "containing object" is always the same as the
14857 declared type of the individual bit-field itself (for GCC anyway... the
14858 DWARF spec doesn't actually mandate this). Note that it is the size (in
14859 bytes) of the hypothetical "containing object" which will be given in the
14860 DW_AT_byte_size attribute for this bit-field. (See the
14861 `byte_size_attribute' function below.) It is also used when calculating the
14862 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
14863 function below.) */
14866 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
14868 HOST_WIDE_INT offset
;
14869 dw_loc_descr_ref loc_descr
= 0;
14871 if (TREE_CODE (decl
) == TREE_BINFO
)
14873 /* We're working on the TAG_inheritance for a base class. */
14874 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
14876 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
14877 aren't at a fixed offset from all (sub)objects of the same
14878 type. We need to extract the appropriate offset from our
14879 vtable. The following dwarf expression means
14881 BaseAddr = ObAddr + *((*ObAddr) - Offset)
14883 This is specific to the V3 ABI, of course. */
14885 dw_loc_descr_ref tmp
;
14887 /* Make a copy of the object address. */
14888 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
14889 add_loc_descr (&loc_descr
, tmp
);
14891 /* Extract the vtable address. */
14892 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
14893 add_loc_descr (&loc_descr
, tmp
);
14895 /* Calculate the address of the offset. */
14896 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
14897 gcc_assert (offset
< 0);
14899 tmp
= int_loc_descriptor (-offset
);
14900 add_loc_descr (&loc_descr
, tmp
);
14901 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
14902 add_loc_descr (&loc_descr
, tmp
);
14904 /* Extract the offset. */
14905 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
14906 add_loc_descr (&loc_descr
, tmp
);
14908 /* Add it to the object address. */
14909 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
14910 add_loc_descr (&loc_descr
, tmp
);
14913 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
14916 offset
= field_byte_offset (decl
);
14920 if (dwarf_version
> 2)
14922 /* Don't need to output a location expression, just the constant. */
14924 add_AT_int (die
, DW_AT_data_member_location
, offset
);
14926 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
14931 enum dwarf_location_atom op
;
14933 /* The DWARF2 standard says that we should assume that the structure
14934 address is already on the stack, so we can specify a structure
14935 field address by using DW_OP_plus_uconst. */
14936 op
= DW_OP_plus_uconst
;
14937 loc_descr
= new_loc_descr (op
, offset
, 0);
14941 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
14944 /* Writes integer values to dw_vec_const array. */
14947 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
14951 *dest
++ = val
& 0xff;
14957 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
14959 static HOST_WIDE_INT
14960 extract_int (const unsigned char *src
, unsigned int size
)
14962 HOST_WIDE_INT val
= 0;
14968 val
|= *--src
& 0xff;
14974 /* Writes double_int values to dw_vec_const array. */
14977 insert_double (double_int val
, unsigned char *dest
)
14979 unsigned char *p0
= dest
;
14980 unsigned char *p1
= dest
+ sizeof (HOST_WIDE_INT
);
14982 if (WORDS_BIG_ENDIAN
)
14988 insert_int ((HOST_WIDE_INT
) val
.low
, sizeof (HOST_WIDE_INT
), p0
);
14989 insert_int ((HOST_WIDE_INT
) val
.high
, sizeof (HOST_WIDE_INT
), p1
);
14992 /* Writes floating point values to dw_vec_const array. */
14995 insert_float (const_rtx rtl
, unsigned char *array
)
14997 REAL_VALUE_TYPE rv
;
15001 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
15002 real_to_target (val
, &rv
, GET_MODE (rtl
));
15004 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15005 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
15007 insert_int (val
[i
], 4, array
);
15012 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15013 does not have a "location" either in memory or in a register. These
15014 things can arise in GNU C when a constant is passed as an actual parameter
15015 to an inlined function. They can also arise in C++ where declared
15016 constants do not necessarily get memory "homes". */
15019 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
15021 switch (GET_CODE (rtl
))
15025 HOST_WIDE_INT val
= INTVAL (rtl
);
15028 add_AT_int (die
, DW_AT_const_value
, val
);
15030 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
15035 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15036 floating-point constant. A CONST_DOUBLE is used whenever the
15037 constant requires more than one word in order to be adequately
15040 enum machine_mode mode
= GET_MODE (rtl
);
15042 if (SCALAR_FLOAT_MODE_P (mode
))
15044 unsigned int length
= GET_MODE_SIZE (mode
);
15045 unsigned char *array
= (unsigned char *) ggc_alloc_atomic (length
);
15047 insert_float (rtl
, array
);
15048 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
15051 add_AT_double (die
, DW_AT_const_value
,
15052 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
15058 enum machine_mode mode
= GET_MODE (rtl
);
15059 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
15060 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
15061 unsigned char *array
= (unsigned char *) ggc_alloc_atomic
15062 (length
* elt_size
);
15066 switch (GET_MODE_CLASS (mode
))
15068 case MODE_VECTOR_INT
:
15069 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15071 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15072 double_int val
= rtx_to_double_int (elt
);
15074 if (elt_size
<= sizeof (HOST_WIDE_INT
))
15075 insert_int (val
.to_shwi (), elt_size
, p
);
15078 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
15079 insert_double (val
, p
);
15084 case MODE_VECTOR_FLOAT
:
15085 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15087 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15088 insert_float (elt
, p
);
15093 gcc_unreachable ();
15096 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
15101 if (dwarf_version
>= 4 || !dwarf_strict
)
15103 dw_loc_descr_ref loc_result
;
15104 resolve_one_addr (&rtl
, NULL
);
15106 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15107 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
15108 add_AT_loc (die
, DW_AT_location
, loc_result
);
15109 vec_safe_push (used_rtx_array
, rtl
);
15115 if (CONSTANT_P (XEXP (rtl
, 0)))
15116 return add_const_value_attribute (die
, XEXP (rtl
, 0));
15119 if (!const_ok_for_output (rtl
))
15122 if (dwarf_version
>= 4 || !dwarf_strict
)
15127 /* In cases where an inlined instance of an inline function is passed
15128 the address of an `auto' variable (which is local to the caller) we
15129 can get a situation where the DECL_RTL of the artificial local
15130 variable (for the inlining) which acts as a stand-in for the
15131 corresponding formal parameter (of the inline function) will look
15132 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15133 exactly a compile-time constant expression, but it isn't the address
15134 of the (artificial) local variable either. Rather, it represents the
15135 *value* which the artificial local variable always has during its
15136 lifetime. We currently have no way to represent such quasi-constant
15137 values in Dwarf, so for now we just punt and generate nothing. */
15145 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
15146 && MEM_READONLY_P (rtl
)
15147 && GET_MODE (rtl
) == BLKmode
)
15149 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
15155 /* No other kinds of rtx should be possible here. */
15156 gcc_unreachable ();
15161 /* Determine whether the evaluation of EXPR references any variables
15162 or functions which aren't otherwise used (and therefore may not be
15165 reference_to_unused (tree
* tp
, int * walk_subtrees
,
15166 void * data ATTRIBUTE_UNUSED
)
15168 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
15169 *walk_subtrees
= 0;
15171 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
15172 && ! TREE_ASM_WRITTEN (*tp
))
15174 /* ??? The C++ FE emits debug information for using decls, so
15175 putting gcc_unreachable here falls over. See PR31899. For now
15176 be conservative. */
15177 else if (!cgraph_global_info_ready
15178 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
15180 else if (TREE_CODE (*tp
) == VAR_DECL
)
15182 varpool_node
*node
= varpool_get_node (*tp
);
15183 if (!node
|| !node
->definition
)
15186 else if (TREE_CODE (*tp
) == FUNCTION_DECL
15187 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
15189 /* The call graph machinery must have finished analyzing,
15190 optimizing and gimplifying the CU by now.
15191 So if *TP has no call graph node associated
15192 to it, it means *TP will not be emitted. */
15193 if (!cgraph_get_node (*tp
))
15196 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
15202 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15203 for use in a later add_const_value_attribute call. */
15206 rtl_for_decl_init (tree init
, tree type
)
15208 rtx rtl
= NULL_RTX
;
15212 /* If a variable is initialized with a string constant without embedded
15213 zeros, build CONST_STRING. */
15214 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
15216 tree enttype
= TREE_TYPE (type
);
15217 tree domain
= TYPE_DOMAIN (type
);
15218 enum machine_mode mode
= TYPE_MODE (enttype
);
15220 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
15222 && integer_zerop (TYPE_MIN_VALUE (domain
))
15223 && compare_tree_int (TYPE_MAX_VALUE (domain
),
15224 TREE_STRING_LENGTH (init
) - 1) == 0
15225 && ((size_t) TREE_STRING_LENGTH (init
)
15226 == strlen (TREE_STRING_POINTER (init
)) + 1))
15228 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
15229 ggc_strdup (TREE_STRING_POINTER (init
)));
15230 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
15231 MEM_READONLY_P (rtl
) = 1;
15234 /* Other aggregates, and complex values, could be represented using
15236 else if (AGGREGATE_TYPE_P (type
)
15237 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
15238 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
15239 || TREE_CODE (type
) == COMPLEX_TYPE
)
15241 /* Vectors only work if their mode is supported by the target.
15242 FIXME: generic vectors ought to work too. */
15243 else if (TREE_CODE (type
) == VECTOR_TYPE
15244 && !VECTOR_MODE_P (TYPE_MODE (type
)))
15246 /* If the initializer is something that we know will expand into an
15247 immediate RTL constant, expand it now. We must be careful not to
15248 reference variables which won't be output. */
15249 else if (initializer_constant_valid_p (init
, type
)
15250 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
15252 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15254 if (TREE_CODE (type
) == VECTOR_TYPE
)
15255 switch (TREE_CODE (init
))
15260 if (TREE_CONSTANT (init
))
15262 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
15263 bool constant_p
= true;
15265 unsigned HOST_WIDE_INT ix
;
15267 /* Even when ctor is constant, it might contain non-*_CST
15268 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15269 belong into VECTOR_CST nodes. */
15270 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
15271 if (!CONSTANT_CLASS_P (value
))
15273 constant_p
= false;
15279 init
= build_vector_from_ctor (type
, elts
);
15289 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
15291 /* If expand_expr returns a MEM, it wasn't immediate. */
15292 gcc_assert (!rtl
|| !MEM_P (rtl
));
15298 /* Generate RTL for the variable DECL to represent its location. */
15301 rtl_for_decl_location (tree decl
)
15305 /* Here we have to decide where we are going to say the parameter "lives"
15306 (as far as the debugger is concerned). We only have a couple of
15307 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15309 DECL_RTL normally indicates where the parameter lives during most of the
15310 activation of the function. If optimization is enabled however, this
15311 could be either NULL or else a pseudo-reg. Both of those cases indicate
15312 that the parameter doesn't really live anywhere (as far as the code
15313 generation parts of GCC are concerned) during most of the function's
15314 activation. That will happen (for example) if the parameter is never
15315 referenced within the function.
15317 We could just generate a location descriptor here for all non-NULL
15318 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15319 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15320 where DECL_RTL is NULL or is a pseudo-reg.
15322 Note however that we can only get away with using DECL_INCOMING_RTL as
15323 a backup substitute for DECL_RTL in certain limited cases. In cases
15324 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15325 we can be sure that the parameter was passed using the same type as it is
15326 declared to have within the function, and that its DECL_INCOMING_RTL
15327 points us to a place where a value of that type is passed.
15329 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15330 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15331 because in these cases DECL_INCOMING_RTL points us to a value of some
15332 type which is *different* from the type of the parameter itself. Thus,
15333 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15334 such cases, the debugger would end up (for example) trying to fetch a
15335 `float' from a place which actually contains the first part of a
15336 `double'. That would lead to really incorrect and confusing
15337 output at debug-time.
15339 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15340 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15341 are a couple of exceptions however. On little-endian machines we can
15342 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15343 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15344 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15345 when (on a little-endian machine) a non-prototyped function has a
15346 parameter declared to be of type `short' or `char'. In such cases,
15347 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15348 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15349 passed `int' value. If the debugger then uses that address to fetch
15350 a `short' or a `char' (on a little-endian machine) the result will be
15351 the correct data, so we allow for such exceptional cases below.
15353 Note that our goal here is to describe the place where the given formal
15354 parameter lives during most of the function's activation (i.e. between the
15355 end of the prologue and the start of the epilogue). We'll do that as best
15356 as we can. Note however that if the given formal parameter is modified
15357 sometime during the execution of the function, then a stack backtrace (at
15358 debug-time) will show the function as having been called with the *new*
15359 value rather than the value which was originally passed in. This happens
15360 rarely enough that it is not a major problem, but it *is* a problem, and
15361 I'd like to fix it.
15363 A future version of dwarf2out.c may generate two additional attributes for
15364 any given DW_TAG_formal_parameter DIE which will describe the "passed
15365 type" and the "passed location" for the given formal parameter in addition
15366 to the attributes we now generate to indicate the "declared type" and the
15367 "active location" for each parameter. This additional set of attributes
15368 could be used by debuggers for stack backtraces. Separately, note that
15369 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15370 This happens (for example) for inlined-instances of inline function formal
15371 parameters which are never referenced. This really shouldn't be
15372 happening. All PARM_DECL nodes should get valid non-NULL
15373 DECL_INCOMING_RTL values. FIXME. */
15375 /* Use DECL_RTL as the "location" unless we find something better. */
15376 rtl
= DECL_RTL_IF_SET (decl
);
15378 /* When generating abstract instances, ignore everything except
15379 constants, symbols living in memory, and symbols living in
15380 fixed registers. */
15381 if (! reload_completed
)
15384 && (CONSTANT_P (rtl
)
15386 && CONSTANT_P (XEXP (rtl
, 0)))
15388 && TREE_CODE (decl
) == VAR_DECL
15389 && TREE_STATIC (decl
))))
15391 rtl
= targetm
.delegitimize_address (rtl
);
15396 else if (TREE_CODE (decl
) == PARM_DECL
)
15398 if (rtl
== NULL_RTX
15399 || is_pseudo_reg (rtl
)
15401 && is_pseudo_reg (XEXP (rtl
, 0))
15402 && DECL_INCOMING_RTL (decl
)
15403 && MEM_P (DECL_INCOMING_RTL (decl
))
15404 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
15406 tree declared_type
= TREE_TYPE (decl
);
15407 tree passed_type
= DECL_ARG_TYPE (decl
);
15408 enum machine_mode dmode
= TYPE_MODE (declared_type
);
15409 enum machine_mode pmode
= TYPE_MODE (passed_type
);
15411 /* This decl represents a formal parameter which was optimized out.
15412 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15413 all cases where (rtl == NULL_RTX) just below. */
15414 if (dmode
== pmode
)
15415 rtl
= DECL_INCOMING_RTL (decl
);
15416 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
15417 && SCALAR_INT_MODE_P (dmode
)
15418 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
15419 && DECL_INCOMING_RTL (decl
))
15421 rtx inc
= DECL_INCOMING_RTL (decl
);
15424 else if (MEM_P (inc
))
15426 if (BYTES_BIG_ENDIAN
)
15427 rtl
= adjust_address_nv (inc
, dmode
,
15428 GET_MODE_SIZE (pmode
)
15429 - GET_MODE_SIZE (dmode
));
15436 /* If the parm was passed in registers, but lives on the stack, then
15437 make a big endian correction if the mode of the type of the
15438 parameter is not the same as the mode of the rtl. */
15439 /* ??? This is the same series of checks that are made in dbxout.c before
15440 we reach the big endian correction code there. It isn't clear if all
15441 of these checks are necessary here, but keeping them all is the safe
15443 else if (MEM_P (rtl
)
15444 && XEXP (rtl
, 0) != const0_rtx
15445 && ! CONSTANT_P (XEXP (rtl
, 0))
15446 /* Not passed in memory. */
15447 && !MEM_P (DECL_INCOMING_RTL (decl
))
15448 /* Not passed by invisible reference. */
15449 && (!REG_P (XEXP (rtl
, 0))
15450 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
15451 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
15452 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
15453 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
15456 /* Big endian correction check. */
15457 && BYTES_BIG_ENDIAN
15458 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
15459 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
15462 enum machine_mode addr_mode
= get_address_mode (rtl
);
15463 int offset
= (UNITS_PER_WORD
15464 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
15466 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15467 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
15470 else if (TREE_CODE (decl
) == VAR_DECL
15473 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
15474 && BYTES_BIG_ENDIAN
)
15476 enum machine_mode addr_mode
= get_address_mode (rtl
);
15477 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
15478 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
15480 /* If a variable is declared "register" yet is smaller than
15481 a register, then if we store the variable to memory, it
15482 looks like we're storing a register-sized value, when in
15483 fact we are not. We need to adjust the offset of the
15484 storage location to reflect the actual value's bytes,
15485 else gdb will not be able to display it. */
15487 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15488 plus_constant (addr_mode
, XEXP (rtl
, 0),
15492 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15493 and will have been substituted directly into all expressions that use it.
15494 C does not have such a concept, but C++ and other languages do. */
15495 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
15496 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
15499 rtl
= targetm
.delegitimize_address (rtl
);
15501 /* If we don't look past the constant pool, we risk emitting a
15502 reference to a constant pool entry that isn't referenced from
15503 code, and thus is not emitted. */
15505 rtl
= avoid_constant_pool_reference (rtl
);
15507 /* Try harder to get a rtl. If this symbol ends up not being emitted
15508 in the current CU, resolve_addr will remove the expression referencing
15510 if (rtl
== NULL_RTX
15511 && TREE_CODE (decl
) == VAR_DECL
15512 && !DECL_EXTERNAL (decl
)
15513 && TREE_STATIC (decl
)
15514 && DECL_NAME (decl
)
15515 && !DECL_HARD_REGISTER (decl
)
15516 && DECL_MODE (decl
) != VOIDmode
)
15518 rtl
= make_decl_rtl_for_debug (decl
);
15520 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
15521 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
15528 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15529 returned. If so, the decl for the COMMON block is returned, and the
15530 value is the offset into the common block for the symbol. */
15533 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
15535 tree val_expr
, cvar
;
15536 enum machine_mode mode
;
15537 HOST_WIDE_INT bitsize
, bitpos
;
15539 int unsignedp
, volatilep
= 0;
15541 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15542 it does not have a value (the offset into the common area), or if it
15543 is thread local (as opposed to global) then it isn't common, and shouldn't
15544 be handled as such. */
15545 if (TREE_CODE (decl
) != VAR_DECL
15546 || !TREE_STATIC (decl
)
15547 || !DECL_HAS_VALUE_EXPR_P (decl
)
15551 val_expr
= DECL_VALUE_EXPR (decl
);
15552 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
15555 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
,
15556 &mode
, &unsignedp
, &volatilep
, true);
15558 if (cvar
== NULL_TREE
15559 || TREE_CODE (cvar
) != VAR_DECL
15560 || DECL_ARTIFICIAL (cvar
)
15561 || !TREE_PUBLIC (cvar
))
15565 if (offset
!= NULL
)
15567 if (!tree_fits_shwi_p (offset
))
15569 *value
= tree_to_shwi (offset
);
15572 *value
+= bitpos
/ BITS_PER_UNIT
;
15577 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
15578 data attribute for a variable or a parameter. We generate the
15579 DW_AT_const_value attribute only in those cases where the given variable
15580 or parameter does not have a true "location" either in memory or in a
15581 register. This can happen (for example) when a constant is passed as an
15582 actual argument in a call to an inline function. (It's possible that
15583 these things can crop up in other ways also.) Note that one type of
15584 constant value which can be passed into an inlined function is a constant
15585 pointer. This can happen for example if an actual argument in an inlined
15586 function call evaluates to a compile-time constant address.
15588 CACHE_P is true if it is worth caching the location list for DECL,
15589 so that future calls can reuse it rather than regenerate it from scratch.
15590 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
15591 since we will need to refer to them each time the function is inlined. */
15594 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
,
15595 enum dwarf_attribute attr
)
15598 dw_loc_list_ref list
;
15599 var_loc_list
*loc_list
;
15600 cached_dw_loc_list
*cache
;
15603 if (TREE_CODE (decl
) == ERROR_MARK
)
15606 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
15607 || TREE_CODE (decl
) == RESULT_DECL
);
15609 /* Try to get some constant RTL for this decl, and use that as the value of
15612 rtl
= rtl_for_decl_location (decl
);
15613 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15614 && add_const_value_attribute (die
, rtl
))
15617 /* See if we have single element location list that is equivalent to
15618 a constant value. That way we are better to use add_const_value_attribute
15619 rather than expanding constant value equivalent. */
15620 loc_list
= lookup_decl_loc (decl
);
15623 && loc_list
->first
->next
== NULL
15624 && NOTE_P (loc_list
->first
->loc
)
15625 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
15626 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
15628 struct var_loc_node
*node
;
15630 node
= loc_list
->first
;
15631 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
15632 if (GET_CODE (rtl
) == EXPR_LIST
)
15633 rtl
= XEXP (rtl
, 0);
15634 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15635 && add_const_value_attribute (die
, rtl
))
15638 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
15639 list several times. See if we've already cached the contents. */
15641 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
15645 cache
= (cached_dw_loc_list
*)
15646 htab_find_with_hash (cached_dw_loc_list_table
, decl
, DECL_UID (decl
));
15648 list
= cache
->loc_list
;
15652 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2);
15653 /* It is usually worth caching this result if the decl is from
15654 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
15655 if (cache_p
&& list
&& list
->dw_loc_next
)
15657 slot
= htab_find_slot_with_hash (cached_dw_loc_list_table
, decl
,
15658 DECL_UID (decl
), INSERT
);
15659 cache
= ggc_alloc_cleared_cached_dw_loc_list ();
15660 cache
->decl_id
= DECL_UID (decl
);
15661 cache
->loc_list
= list
;
15667 add_AT_location_description (die
, attr
, list
);
15670 /* None of that worked, so it must not really have a location;
15671 try adding a constant value attribute from the DECL_INITIAL. */
15672 return tree_add_const_value_attribute_for_decl (die
, decl
);
15675 /* Add VARIABLE and DIE into deferred locations list. */
15678 defer_location (tree variable
, dw_die_ref die
)
15680 deferred_locations entry
;
15681 entry
.variable
= variable
;
15683 vec_safe_push (deferred_locations_list
, entry
);
15686 /* Helper function for tree_add_const_value_attribute. Natively encode
15687 initializer INIT into an array. Return true if successful. */
15690 native_encode_initializer (tree init
, unsigned char *array
, int size
)
15694 if (init
== NULL_TREE
)
15698 switch (TREE_CODE (init
))
15701 type
= TREE_TYPE (init
);
15702 if (TREE_CODE (type
) == ARRAY_TYPE
)
15704 tree enttype
= TREE_TYPE (type
);
15705 enum machine_mode mode
= TYPE_MODE (enttype
);
15707 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
15709 if (int_size_in_bytes (type
) != size
)
15711 if (size
> TREE_STRING_LENGTH (init
))
15713 memcpy (array
, TREE_STRING_POINTER (init
),
15714 TREE_STRING_LENGTH (init
));
15715 memset (array
+ TREE_STRING_LENGTH (init
),
15716 '\0', size
- TREE_STRING_LENGTH (init
));
15719 memcpy (array
, TREE_STRING_POINTER (init
), size
);
15724 type
= TREE_TYPE (init
);
15725 if (int_size_in_bytes (type
) != size
)
15727 if (TREE_CODE (type
) == ARRAY_TYPE
)
15729 HOST_WIDE_INT min_index
;
15730 unsigned HOST_WIDE_INT cnt
;
15731 int curpos
= 0, fieldsize
;
15732 constructor_elt
*ce
;
15734 if (TYPE_DOMAIN (type
) == NULL_TREE
15735 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
15738 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
15739 if (fieldsize
<= 0)
15742 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
15743 memset (array
, '\0', size
);
15744 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15746 tree val
= ce
->value
;
15747 tree index
= ce
->index
;
15749 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15750 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
15753 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
15758 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
15761 curpos
= pos
+ fieldsize
;
15762 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15764 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
15765 - tree_to_shwi (TREE_OPERAND (index
, 0));
15766 while (count
-- > 0)
15769 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
15770 curpos
+= fieldsize
;
15773 gcc_assert (curpos
<= size
);
15777 else if (TREE_CODE (type
) == RECORD_TYPE
15778 || TREE_CODE (type
) == UNION_TYPE
)
15780 tree field
= NULL_TREE
;
15781 unsigned HOST_WIDE_INT cnt
;
15782 constructor_elt
*ce
;
15784 if (int_size_in_bytes (type
) != size
)
15787 if (TREE_CODE (type
) == RECORD_TYPE
)
15788 field
= TYPE_FIELDS (type
);
15790 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15792 tree val
= ce
->value
;
15793 int pos
, fieldsize
;
15795 if (ce
->index
!= 0)
15801 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
15804 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
15805 && TYPE_DOMAIN (TREE_TYPE (field
))
15806 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
15808 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
15809 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
15811 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
15812 pos
= int_byte_position (field
);
15813 gcc_assert (pos
+ fieldsize
<= size
);
15815 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
15821 case VIEW_CONVERT_EXPR
:
15822 case NON_LVALUE_EXPR
:
15823 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
15825 return native_encode_expr (init
, array
, size
) == size
;
15829 /* Attach a DW_AT_const_value attribute to DIE. The value of the
15830 attribute is the const value T. */
15833 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
15836 tree type
= TREE_TYPE (t
);
15839 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
15843 gcc_assert (!DECL_P (init
));
15845 rtl
= rtl_for_decl_init (init
, type
);
15847 return add_const_value_attribute (die
, rtl
);
15848 /* If the host and target are sane, try harder. */
15849 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
15850 && initializer_constant_valid_p (init
, type
))
15852 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
15853 if (size
> 0 && (int) size
== size
)
15855 unsigned char *array
= (unsigned char *)
15856 ggc_alloc_cleared_atomic (size
);
15858 if (native_encode_initializer (init
, array
, size
))
15860 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
15869 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
15870 attribute is the const value of T, where T is an integral constant
15871 variable with static storage duration
15872 (so it can't be a PARM_DECL or a RESULT_DECL). */
15875 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
15879 || (TREE_CODE (decl
) != VAR_DECL
15880 && TREE_CODE (decl
) != CONST_DECL
)
15881 || (TREE_CODE (decl
) == VAR_DECL
15882 && !TREE_STATIC (decl
)))
15885 if (TREE_READONLY (decl
)
15886 && ! TREE_THIS_VOLATILE (decl
)
15887 && DECL_INITIAL (decl
))
15892 /* Don't add DW_AT_const_value if abstract origin already has one. */
15893 if (get_AT (var_die
, DW_AT_const_value
))
15896 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
15899 /* Convert the CFI instructions for the current function into a
15900 location list. This is used for DW_AT_frame_base when we targeting
15901 a dwarf2 consumer that does not support the dwarf3
15902 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
15905 static dw_loc_list_ref
15906 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
15910 dw_loc_list_ref list
, *list_tail
;
15912 dw_cfa_location last_cfa
, next_cfa
;
15913 const char *start_label
, *last_label
, *section
;
15914 dw_cfa_location remember
;
15917 gcc_assert (fde
!= NULL
);
15919 section
= secname_for_decl (current_function_decl
);
15923 memset (&next_cfa
, 0, sizeof (next_cfa
));
15924 next_cfa
.reg
= INVALID_REGNUM
;
15925 remember
= next_cfa
;
15927 start_label
= fde
->dw_fde_begin
;
15929 /* ??? Bald assumption that the CIE opcode list does not contain
15930 advance opcodes. */
15931 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
15932 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
15934 last_cfa
= next_cfa
;
15935 last_label
= start_label
;
15937 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
15939 /* If the first partition contained no CFI adjustments, the
15940 CIE opcodes apply to the whole first partition. */
15941 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15942 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
15943 list_tail
=&(*list_tail
)->dw_loc_next
;
15944 start_label
= last_label
= fde
->dw_fde_second_begin
;
15947 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
15949 switch (cfi
->dw_cfi_opc
)
15951 case DW_CFA_set_loc
:
15952 case DW_CFA_advance_loc1
:
15953 case DW_CFA_advance_loc2
:
15954 case DW_CFA_advance_loc4
:
15955 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
15957 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15958 start_label
, last_label
, section
);
15960 list_tail
= &(*list_tail
)->dw_loc_next
;
15961 last_cfa
= next_cfa
;
15962 start_label
= last_label
;
15964 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
15967 case DW_CFA_advance_loc
:
15968 /* The encoding is complex enough that we should never emit this. */
15969 gcc_unreachable ();
15972 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
15975 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
15977 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
15979 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15980 start_label
, last_label
, section
);
15982 list_tail
= &(*list_tail
)->dw_loc_next
;
15983 last_cfa
= next_cfa
;
15984 start_label
= last_label
;
15986 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15987 start_label
, fde
->dw_fde_end
, section
);
15988 list_tail
= &(*list_tail
)->dw_loc_next
;
15989 start_label
= last_label
= fde
->dw_fde_second_begin
;
15993 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
15995 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15996 start_label
, last_label
, section
);
15997 list_tail
= &(*list_tail
)->dw_loc_next
;
15998 start_label
= last_label
;
16001 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
16003 fde
->dw_fde_second_begin
16004 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
16007 if (list
&& list
->dw_loc_next
)
16013 /* Compute a displacement from the "steady-state frame pointer" to the
16014 frame base (often the same as the CFA), and store it in
16015 frame_pointer_fb_offset. OFFSET is added to the displacement
16016 before the latter is negated. */
16019 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
16023 #ifdef FRAME_POINTER_CFA_OFFSET
16024 reg
= frame_pointer_rtx
;
16025 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
16027 reg
= arg_pointer_rtx
;
16028 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
16031 elim
= (ira_use_lra_p
16032 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
16033 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
16034 if (GET_CODE (elim
) == PLUS
)
16036 offset
+= INTVAL (XEXP (elim
, 1));
16037 elim
= XEXP (elim
, 0);
16040 frame_pointer_fb_offset
= -offset
;
16042 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
16043 in which to eliminate. This is because it's stack pointer isn't
16044 directly accessible as a register within the ISA. To work around
16045 this, assume that while we cannot provide a proper value for
16046 frame_pointer_fb_offset, we won't need one either. */
16047 frame_pointer_fb_offset_valid
16048 = ((SUPPORTS_STACK_ALIGNMENT
16049 && (elim
== hard_frame_pointer_rtx
16050 || elim
== stack_pointer_rtx
))
16051 || elim
== (frame_pointer_needed
16052 ? hard_frame_pointer_rtx
16053 : stack_pointer_rtx
));
16056 /* Generate a DW_AT_name attribute given some string value to be included as
16057 the value of the attribute. */
16060 add_name_attribute (dw_die_ref die
, const char *name_string
)
16062 if (name_string
!= NULL
&& *name_string
!= 0)
16064 if (demangle_name_func
)
16065 name_string
= (*demangle_name_func
) (name_string
);
16067 add_AT_string (die
, DW_AT_name
, name_string
);
16071 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
16072 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
16073 of TYPE accordingly.
16075 ??? This is a temporary measure until after we're able to generate
16076 regular DWARF for the complex Ada type system. */
16079 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
16080 dw_die_ref context_die
)
16083 dw_die_ref dtype_die
;
16085 if (!lang_hooks
.types
.descriptive_type
)
16088 dtype
= lang_hooks
.types
.descriptive_type (type
);
16092 dtype_die
= lookup_type_die (dtype
);
16095 gen_type_die (dtype
, context_die
);
16096 dtype_die
= lookup_type_die (dtype
);
16097 gcc_assert (dtype_die
);
16100 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
16103 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
16105 static const char *
16106 comp_dir_string (void)
16110 static const char *cached_wd
= NULL
;
16112 if (cached_wd
!= NULL
)
16115 wd
= get_src_pwd ();
16119 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
16123 wdlen
= strlen (wd
);
16124 wd1
= (char *) ggc_alloc_atomic (wdlen
+ 2);
16126 wd1
[wdlen
] = DIR_SEPARATOR
;
16127 wd1
[wdlen
+ 1] = 0;
16131 cached_wd
= remap_debug_filename (wd
);
16135 /* Generate a DW_AT_comp_dir attribute for DIE. */
16138 add_comp_dir_attribute (dw_die_ref die
)
16140 const char * wd
= comp_dir_string ();
16142 add_AT_string (die
, DW_AT_comp_dir
, wd
);
16145 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16149 lower_bound_default (void)
16151 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
16156 case DW_LANG_C_plus_plus
:
16158 case DW_LANG_ObjC_plus_plus
:
16161 case DW_LANG_Fortran77
:
16162 case DW_LANG_Fortran90
:
16163 case DW_LANG_Fortran95
:
16167 case DW_LANG_Python
:
16168 return dwarf_version
>= 4 ? 0 : -1;
16169 case DW_LANG_Ada95
:
16170 case DW_LANG_Ada83
:
16171 case DW_LANG_Cobol74
:
16172 case DW_LANG_Cobol85
:
16173 case DW_LANG_Pascal83
:
16174 case DW_LANG_Modula2
:
16176 return dwarf_version
>= 4 ? 1 : -1;
16182 /* Given a tree node describing an array bound (either lower or upper) output
16183 a representation for that bound. */
16186 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
16188 switch (TREE_CODE (bound
))
16193 /* All fixed-bounds are represented by INTEGER_CST nodes. */
16196 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (bound
));
16199 /* Use the default if possible. */
16200 if (bound_attr
== DW_AT_lower_bound
16201 && tree_fits_shwi_p (bound
)
16202 && (dflt
= lower_bound_default ()) != -1
16203 && tree_to_shwi (bound
) == dflt
)
16206 /* Otherwise represent the bound as an unsigned value with the
16207 precision of its type. The precision and signedness of the
16208 type will be necessary to re-interpret it unambiguously. */
16209 else if (prec
< HOST_BITS_PER_WIDE_INT
)
16211 unsigned HOST_WIDE_INT mask
16212 = ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
16213 add_AT_unsigned (subrange_die
, bound_attr
,
16214 TREE_INT_CST_LOW (bound
) & mask
);
16216 else if (prec
== HOST_BITS_PER_WIDE_INT
16217 || TREE_INT_CST_HIGH (bound
) == 0)
16218 add_AT_unsigned (subrange_die
, bound_attr
,
16219 TREE_INT_CST_LOW (bound
));
16221 add_AT_double (subrange_die
, bound_attr
, TREE_INT_CST_HIGH (bound
),
16222 TREE_INT_CST_LOW (bound
));
16227 case VIEW_CONVERT_EXPR
:
16228 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
16238 dw_die_ref decl_die
= lookup_decl_die (bound
);
16240 /* ??? Can this happen, or should the variable have been bound
16241 first? Probably it can, since I imagine that we try to create
16242 the types of parameters in the order in which they exist in
16243 the list, and won't have created a forward reference to a
16244 later parameter. */
16245 if (decl_die
!= NULL
)
16247 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16255 /* Otherwise try to create a stack operation procedure to
16256 evaluate the value of the array bound. */
16258 dw_die_ref ctx
, decl_die
;
16259 dw_loc_list_ref list
;
16261 list
= loc_list_from_tree (bound
, 2);
16262 if (list
== NULL
|| single_element_loc_list_p (list
))
16264 /* If DW_AT_*bound is not a reference nor constant, it is
16265 a DWARF expression rather than location description.
16266 For that loc_list_from_tree (bound, 0) is needed.
16267 If that fails to give a single element list,
16268 fall back to outputting this as a reference anyway. */
16269 dw_loc_list_ref list2
= loc_list_from_tree (bound
, 0);
16270 if (list2
&& single_element_loc_list_p (list2
))
16272 add_AT_loc (subrange_die
, bound_attr
, list2
->expr
);
16279 if (current_function_decl
== 0)
16280 ctx
= comp_unit_die ();
16282 ctx
= lookup_decl_die (current_function_decl
);
16284 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
16285 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
16286 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
16287 add_AT_location_description (decl_die
, DW_AT_location
, list
);
16288 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16294 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16295 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16296 Note that the block of subscript information for an array type also
16297 includes information about the element type of the given array type. */
16300 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
16302 unsigned dimension_number
;
16304 dw_die_ref subrange_die
;
16306 for (dimension_number
= 0;
16307 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
16308 type
= TREE_TYPE (type
), dimension_number
++)
16310 tree domain
= TYPE_DOMAIN (type
);
16312 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
16315 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16316 and (in GNU C only) variable bounds. Handle all three forms
16318 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
16321 /* We have an array type with specified bounds. */
16322 lower
= TYPE_MIN_VALUE (domain
);
16323 upper
= TYPE_MAX_VALUE (domain
);
16325 /* Define the index type. */
16326 if (TREE_TYPE (domain
))
16328 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16329 TREE_TYPE field. We can't emit debug info for this
16330 because it is an unnamed integral type. */
16331 if (TREE_CODE (domain
) == INTEGER_TYPE
16332 && TYPE_NAME (domain
) == NULL_TREE
16333 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
16334 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
16337 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
16341 /* ??? If upper is NULL, the array has unspecified length,
16342 but it does have a lower bound. This happens with Fortran
16344 Since the debugger is definitely going to need to know N
16345 to produce useful results, go ahead and output the lower
16346 bound solo, and hope the debugger can cope. */
16348 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
16350 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
16353 /* Otherwise we have an array type with an unspecified length. The
16354 DWARF-2 spec does not say how to handle this; let's just leave out the
16359 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
16362 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
16364 dw_die_ref decl_die
;
16365 HOST_WIDE_INT size
;
16367 switch (TREE_CODE (tree_node
))
16372 case ENUMERAL_TYPE
:
16375 case QUAL_UNION_TYPE
:
16376 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
16377 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
16379 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
16382 size
= int_size_in_bytes (tree_node
);
16385 /* For a data member of a struct or union, the DW_AT_byte_size is
16386 generally given as the number of bytes normally allocated for an
16387 object of the *declared* type of the member itself. This is true
16388 even for bit-fields. */
16389 size
= int_size_in_bytes (field_type (tree_node
));
16392 gcc_unreachable ();
16395 /* Note that `size' might be -1 when we get to this point. If it is, that
16396 indicates that the byte size of the entity in question is variable. We
16397 have no good way of expressing this fact in Dwarf at the present time,
16398 when location description was not used by the caller code instead. */
16400 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
16403 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16404 which specifies the distance in bits from the highest order bit of the
16405 "containing object" for the bit-field to the highest order bit of the
16408 For any given bit-field, the "containing object" is a hypothetical object
16409 (of some integral or enum type) within which the given bit-field lives. The
16410 type of this hypothetical "containing object" is always the same as the
16411 declared type of the individual bit-field itself. The determination of the
16412 exact location of the "containing object" for a bit-field is rather
16413 complicated. It's handled by the `field_byte_offset' function (above).
16415 Note that it is the size (in bytes) of the hypothetical "containing object"
16416 which will be given in the DW_AT_byte_size attribute for this bit-field.
16417 (See `byte_size_attribute' above). */
16420 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
16422 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
16423 tree type
= DECL_BIT_FIELD_TYPE (decl
);
16424 HOST_WIDE_INT bitpos_int
;
16425 HOST_WIDE_INT highest_order_object_bit_offset
;
16426 HOST_WIDE_INT highest_order_field_bit_offset
;
16427 HOST_WIDE_INT bit_offset
;
16429 /* Must be a field and a bit field. */
16430 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
16432 /* We can't yet handle bit-fields whose offsets are variable, so if we
16433 encounter such things, just return without generating any attribute
16434 whatsoever. Likewise for variable or too large size. */
16435 if (! tree_fits_shwi_p (bit_position (decl
))
16436 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
16439 bitpos_int
= int_bit_position (decl
);
16441 /* Note that the bit offset is always the distance (in bits) from the
16442 highest-order bit of the "containing object" to the highest-order bit of
16443 the bit-field itself. Since the "high-order end" of any object or field
16444 is different on big-endian and little-endian machines, the computation
16445 below must take account of these differences. */
16446 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
16447 highest_order_field_bit_offset
= bitpos_int
;
16449 if (! BYTES_BIG_ENDIAN
)
16451 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
16452 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
16456 = (! BYTES_BIG_ENDIAN
16457 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
16458 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
16460 if (bit_offset
< 0)
16461 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
16463 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
16466 /* For a FIELD_DECL node which represents a bit field, output an attribute
16467 which specifies the length in bits of the given field. */
16470 add_bit_size_attribute (dw_die_ref die
, tree decl
)
16472 /* Must be a field and a bit field. */
16473 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
16474 && DECL_BIT_FIELD_TYPE (decl
));
16476 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
16477 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
16480 /* If the compiled language is ANSI C, then add a 'prototyped'
16481 attribute, if arg types are given for the parameters of a function. */
16484 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
16486 if (get_AT_unsigned (comp_unit_die (), DW_AT_language
) == DW_LANG_C89
16487 && prototype_p (func_type
))
16488 add_AT_flag (die
, DW_AT_prototyped
, 1);
16491 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
16492 by looking in either the type declaration or object declaration
16495 static inline dw_die_ref
16496 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
16498 dw_die_ref origin_die
= NULL
;
16500 if (TREE_CODE (origin
) != FUNCTION_DECL
)
16502 /* We may have gotten separated from the block for the inlined
16503 function, if we're in an exception handler or some such; make
16504 sure that the abstract function has been written out.
16506 Doing this for nested functions is wrong, however; functions are
16507 distinct units, and our context might not even be inline. */
16511 fn
= TYPE_STUB_DECL (fn
);
16513 fn
= decl_function_context (fn
);
16515 dwarf2out_abstract_function (fn
);
16518 if (DECL_P (origin
))
16519 origin_die
= lookup_decl_die (origin
);
16520 else if (TYPE_P (origin
))
16521 origin_die
= lookup_type_die (origin
);
16523 /* XXX: Functions that are never lowered don't always have correct block
16524 trees (in the case of java, they simply have no block tree, in some other
16525 languages). For these functions, there is nothing we can really do to
16526 output correct debug info for inlined functions in all cases. Rather
16527 than die, we'll just produce deficient debug info now, in that we will
16528 have variables without a proper abstract origin. In the future, when all
16529 functions are lowered, we should re-add a gcc_assert (origin_die)
16533 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
16537 /* We do not currently support the pure_virtual attribute. */
16540 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
16542 if (DECL_VINDEX (func_decl
))
16544 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
16546 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
16547 add_AT_loc (die
, DW_AT_vtable_elem_location
,
16548 new_loc_descr (DW_OP_constu
,
16549 tree_to_shwi (DECL_VINDEX (func_decl
)),
16552 /* GNU extension: Record what type this method came from originally. */
16553 if (debug_info_level
> DINFO_LEVEL_TERSE
16554 && DECL_CONTEXT (func_decl
))
16555 add_AT_die_ref (die
, DW_AT_containing_type
,
16556 lookup_type_die (DECL_CONTEXT (func_decl
)));
16560 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
16561 given decl. This used to be a vendor extension until after DWARF 4
16562 standardized it. */
16565 add_linkage_attr (dw_die_ref die
, tree decl
)
16567 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
16569 /* Mimic what assemble_name_raw does with a leading '*'. */
16570 if (name
[0] == '*')
16573 if (dwarf_version
>= 4)
16574 add_AT_string (die
, DW_AT_linkage_name
, name
);
16576 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
16579 /* Add source coordinate attributes for the given decl. */
16582 add_src_coords_attributes (dw_die_ref die
, tree decl
)
16584 expanded_location s
;
16586 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
16588 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
16589 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
16590 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
16593 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
16596 add_linkage_name (dw_die_ref die
, tree decl
)
16598 if (debug_info_level
> DINFO_LEVEL_TERSE
16599 && (TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
16600 && TREE_PUBLIC (decl
)
16601 && !DECL_ABSTRACT (decl
)
16602 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
16603 && die
->die_tag
!= DW_TAG_member
)
16605 /* Defer until we have an assembler name set. */
16606 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
16608 limbo_die_node
*asm_name
;
16610 asm_name
= ggc_alloc_cleared_limbo_die_node ();
16611 asm_name
->die
= die
;
16612 asm_name
->created_for
= decl
;
16613 asm_name
->next
= deferred_asm_name
;
16614 deferred_asm_name
= asm_name
;
16616 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
16617 add_linkage_attr (die
, decl
);
16621 /* Add a DW_AT_name attribute and source coordinate attribute for the
16622 given decl, but only if it actually has a name. */
16625 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
16629 decl_name
= DECL_NAME (decl
);
16630 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
16632 const char *name
= dwarf2_name (decl
, 0);
16634 add_name_attribute (die
, name
);
16635 if (! DECL_ARTIFICIAL (decl
))
16636 add_src_coords_attributes (die
, decl
);
16638 add_linkage_name (die
, decl
);
16641 #ifdef VMS_DEBUGGING_INFO
16642 /* Get the function's name, as described by its RTL. This may be different
16643 from the DECL_NAME name used in the source file. */
16644 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
16646 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
16647 XEXP (DECL_RTL (decl
), 0), false);
16648 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
16650 #endif /* VMS_DEBUGGING_INFO */
16653 #ifdef VMS_DEBUGGING_INFO
16654 /* Output the debug main pointer die for VMS */
16657 dwarf2out_vms_debug_main_pointer (void)
16659 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
16662 /* Allocate the VMS debug main subprogram die. */
16663 die
= ggc_alloc_cleared_die_node ();
16664 die
->die_tag
= DW_TAG_subprogram
;
16665 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
16666 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
16667 current_function_funcdef_no
);
16668 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
16670 /* Make it the first child of comp_unit_die (). */
16671 die
->die_parent
= comp_unit_die ();
16672 if (comp_unit_die ()->die_child
)
16674 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
16675 comp_unit_die ()->die_child
->die_sib
= die
;
16679 die
->die_sib
= die
;
16680 comp_unit_die ()->die_child
= die
;
16683 #endif /* VMS_DEBUGGING_INFO */
16685 /* Push a new declaration scope. */
16688 push_decl_scope (tree scope
)
16690 vec_safe_push (decl_scope_table
, scope
);
16693 /* Pop a declaration scope. */
16696 pop_decl_scope (void)
16698 decl_scope_table
->pop ();
16701 /* walk_tree helper function for uses_local_type, below. */
16704 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
16707 *walk_subtrees
= 0;
16710 tree name
= TYPE_NAME (*tp
);
16711 if (name
&& DECL_P (name
) && decl_function_context (name
))
16717 /* If TYPE involves a function-local type (including a local typedef to a
16718 non-local type), returns that type; otherwise returns NULL_TREE. */
16721 uses_local_type (tree type
)
16723 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
16727 /* Return the DIE for the scope that immediately contains this type.
16728 Non-named types that do not involve a function-local type get global
16729 scope. Named types nested in namespaces or other types get their
16730 containing scope. All other types (i.e. function-local named types) get
16731 the current active scope. */
16734 scope_die_for (tree t
, dw_die_ref context_die
)
16736 dw_die_ref scope_die
= NULL
;
16737 tree containing_scope
;
16739 /* Non-types always go in the current scope. */
16740 gcc_assert (TYPE_P (t
));
16742 /* Use the scope of the typedef, rather than the scope of the type
16744 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
16745 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
16747 containing_scope
= TYPE_CONTEXT (t
);
16749 /* Use the containing namespace if there is one. */
16750 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
16752 if (context_die
== lookup_decl_die (containing_scope
))
16754 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
16755 context_die
= get_context_die (containing_scope
);
16757 containing_scope
= NULL_TREE
;
16760 /* Ignore function type "scopes" from the C frontend. They mean that
16761 a tagged type is local to a parmlist of a function declarator, but
16762 that isn't useful to DWARF. */
16763 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
16764 containing_scope
= NULL_TREE
;
16766 if (SCOPE_FILE_SCOPE_P (containing_scope
))
16768 /* If T uses a local type keep it local as well, to avoid references
16769 to function-local DIEs from outside the function. */
16770 if (current_function_decl
&& uses_local_type (t
))
16771 scope_die
= context_die
;
16773 scope_die
= comp_unit_die ();
16775 else if (TYPE_P (containing_scope
))
16777 /* For types, we can just look up the appropriate DIE. */
16778 if (debug_info_level
> DINFO_LEVEL_TERSE
)
16779 scope_die
= get_context_die (containing_scope
);
16782 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
16783 if (scope_die
== NULL
)
16784 scope_die
= comp_unit_die ();
16788 scope_die
= context_die
;
16793 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
16796 local_scope_p (dw_die_ref context_die
)
16798 for (; context_die
; context_die
= context_die
->die_parent
)
16799 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
16800 || context_die
->die_tag
== DW_TAG_subprogram
)
16806 /* Returns nonzero if CONTEXT_DIE is a class. */
16809 class_scope_p (dw_die_ref context_die
)
16811 return (context_die
16812 && (context_die
->die_tag
== DW_TAG_structure_type
16813 || context_die
->die_tag
== DW_TAG_class_type
16814 || context_die
->die_tag
== DW_TAG_interface_type
16815 || context_die
->die_tag
== DW_TAG_union_type
));
16818 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
16819 whether or not to treat a DIE in this context as a declaration. */
16822 class_or_namespace_scope_p (dw_die_ref context_die
)
16824 return (class_scope_p (context_die
)
16825 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
16828 /* Many forms of DIEs require a "type description" attribute. This
16829 routine locates the proper "type descriptor" die for the type given
16830 by 'type', and adds a DW_AT_type attribute below the given die. */
16833 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
16834 int decl_volatile
, dw_die_ref context_die
)
16836 enum tree_code code
= TREE_CODE (type
);
16837 dw_die_ref type_die
= NULL
;
16839 /* ??? If this type is an unnamed subrange type of an integral, floating-point
16840 or fixed-point type, use the inner type. This is because we have no
16841 support for unnamed types in base_type_die. This can happen if this is
16842 an Ada subrange type. Correct solution is emit a subrange type die. */
16843 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
16844 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
16845 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
16847 if (code
== ERROR_MARK
16848 /* Handle a special case. For functions whose return type is void, we
16849 generate *no* type attribute. (Note that no object may have type
16850 `void', so this only applies to function return types). */
16851 || code
== VOID_TYPE
)
16854 type_die
= modified_type_die (type
,
16855 decl_const
|| TYPE_READONLY (type
),
16856 decl_volatile
|| TYPE_VOLATILE (type
),
16859 if (type_die
!= NULL
)
16860 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
16863 /* Given an object die, add the calling convention attribute for the
16864 function call type. */
16866 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
16868 enum dwarf_calling_convention value
= DW_CC_normal
;
16870 value
= ((enum dwarf_calling_convention
)
16871 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
16874 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
16876 /* DWARF 2 doesn't provide a way to identify a program's source-level
16877 entry point. DW_AT_calling_convention attributes are only meant
16878 to describe functions' calling conventions. However, lacking a
16879 better way to signal the Fortran main program, we used this for
16880 a long time, following existing custom. Now, DWARF 4 has
16881 DW_AT_main_subprogram, which we add below, but some tools still
16882 rely on the old way, which we thus keep. */
16883 value
= DW_CC_program
;
16885 if (dwarf_version
>= 4 || !dwarf_strict
)
16886 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
16889 /* Only add the attribute if the backend requests it, and
16890 is not DW_CC_normal. */
16891 if (value
&& (value
!= DW_CC_normal
))
16892 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
16895 /* Given a tree pointer to a struct, class, union, or enum type node, return
16896 a pointer to the (string) tag name for the given type, or zero if the type
16897 was declared without a tag. */
16899 static const char *
16900 type_tag (const_tree type
)
16902 const char *name
= 0;
16904 if (TYPE_NAME (type
) != 0)
16908 /* Find the IDENTIFIER_NODE for the type name. */
16909 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
16910 && !TYPE_NAMELESS (type
))
16911 t
= TYPE_NAME (type
);
16913 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
16914 a TYPE_DECL node, regardless of whether or not a `typedef' was
16916 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
16917 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
16919 /* We want to be extra verbose. Don't call dwarf_name if
16920 DECL_NAME isn't set. The default hook for decl_printable_name
16921 doesn't like that, and in this context it's correct to return
16922 0, instead of "<anonymous>" or the like. */
16923 if (DECL_NAME (TYPE_NAME (type
))
16924 && !DECL_NAMELESS (TYPE_NAME (type
)))
16925 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
16928 /* Now get the name as a string, or invent one. */
16929 if (!name
&& t
!= 0)
16930 name
= IDENTIFIER_POINTER (t
);
16933 return (name
== 0 || *name
== '\0') ? 0 : name
;
16936 /* Return the type associated with a data member, make a special check
16937 for bit field types. */
16940 member_declared_type (const_tree member
)
16942 return (DECL_BIT_FIELD_TYPE (member
)
16943 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
16946 /* Get the decl's label, as described by its RTL. This may be different
16947 from the DECL_NAME name used in the source file. */
16950 static const char *
16951 decl_start_label (tree decl
)
16954 const char *fnname
;
16956 x
= DECL_RTL (decl
);
16957 gcc_assert (MEM_P (x
));
16960 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
16962 fnname
= XSTR (x
, 0);
16967 /* These routines generate the internal representation of the DIE's for
16968 the compilation unit. Debugging information is collected by walking
16969 the declaration trees passed in from dwarf2out_decl(). */
16972 gen_array_type_die (tree type
, dw_die_ref context_die
)
16974 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
16975 dw_die_ref array_die
;
16977 /* GNU compilers represent multidimensional array types as sequences of one
16978 dimensional array types whose element types are themselves array types.
16979 We sometimes squish that down to a single array_type DIE with multiple
16980 subscripts in the Dwarf debugging info. The draft Dwarf specification
16981 say that we are allowed to do this kind of compression in C, because
16982 there is no difference between an array of arrays and a multidimensional
16983 array. We don't do this for Ada to remain as close as possible to the
16984 actual representation, which is especially important against the language
16985 flexibilty wrt arrays of variable size. */
16987 bool collapse_nested_arrays
= !is_ada ();
16990 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
16991 DW_TAG_string_type doesn't have DW_AT_type attribute). */
16992 if (TYPE_STRING_FLAG (type
)
16993 && TREE_CODE (type
) == ARRAY_TYPE
16995 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
16997 HOST_WIDE_INT size
;
16999 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
17000 add_name_attribute (array_die
, type_tag (type
));
17001 equate_type_number_to_die (type
, array_die
);
17002 size
= int_size_in_bytes (type
);
17004 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17005 else if (TYPE_DOMAIN (type
) != NULL_TREE
17006 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
17007 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
17009 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
17010 dw_loc_list_ref loc
= loc_list_from_tree (szdecl
, 2);
17012 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
17013 if (loc
&& size
> 0)
17015 add_AT_location_description (array_die
, DW_AT_string_length
, loc
);
17016 if (size
!= DWARF2_ADDR_SIZE
)
17017 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17023 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17024 add_name_attribute (array_die
, type_tag (type
));
17025 equate_type_number_to_die (type
, array_die
);
17027 if (TREE_CODE (type
) == VECTOR_TYPE
)
17028 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
17030 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17032 && TREE_CODE (type
) == ARRAY_TYPE
17033 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
17034 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
17035 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17038 /* We default the array ordering. SDB will probably do
17039 the right things even if DW_AT_ordering is not present. It's not even
17040 an issue until we start to get into multidimensional arrays anyway. If
17041 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17042 then we'll have to put the DW_AT_ordering attribute back in. (But if
17043 and when we find out that we need to put these in, we will only do so
17044 for multidimensional arrays. */
17045 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
17048 if (TREE_CODE (type
) == VECTOR_TYPE
)
17050 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
17051 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17052 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
);
17053 add_bound_info (subrange_die
, DW_AT_upper_bound
,
17054 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
17057 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
17059 /* Add representation of the type of the elements of this array type and
17060 emit the corresponding DIE if we haven't done it already. */
17061 element_type
= TREE_TYPE (type
);
17062 if (collapse_nested_arrays
)
17063 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
17065 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
17067 element_type
= TREE_TYPE (element_type
);
17070 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
17072 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
17073 if (TYPE_ARTIFICIAL (type
))
17074 add_AT_flag (array_die
, DW_AT_artificial
, 1);
17076 if (get_AT (array_die
, DW_AT_name
))
17077 add_pubtype (type
, array_die
);
17080 static dw_loc_descr_ref
17081 descr_info_loc (tree val
, tree base_decl
)
17083 HOST_WIDE_INT size
;
17084 dw_loc_descr_ref loc
, loc2
;
17085 enum dwarf_location_atom op
;
17087 if (val
== base_decl
)
17088 return new_loc_descr (DW_OP_push_object_address
, 0, 0);
17090 switch (TREE_CODE (val
))
17093 return descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17095 return loc_descriptor_from_tree (val
, 0);
17097 if (tree_fits_shwi_p (val
))
17098 return int_loc_descriptor (tree_to_shwi (val
));
17101 size
= int_size_in_bytes (TREE_TYPE (val
));
17104 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17107 if (size
== DWARF2_ADDR_SIZE
)
17108 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref
, 0, 0));
17110 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref_size
, size
, 0));
17112 case POINTER_PLUS_EXPR
:
17114 if (tree_fits_uhwi_p (TREE_OPERAND (val
, 1))
17115 && tree_to_uhwi (TREE_OPERAND (val
, 1)) < 16384)
17117 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17120 loc_descr_plus_const (&loc
, tree_to_shwi (TREE_OPERAND (val
, 1)));
17126 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17129 loc2
= descr_info_loc (TREE_OPERAND (val
, 1), base_decl
);
17132 add_loc_descr (&loc
, loc2
);
17133 add_loc_descr (&loc2
, new_loc_descr (op
, 0, 0));
17155 add_descr_info_field (dw_die_ref die
, enum dwarf_attribute attr
,
17156 tree val
, tree base_decl
)
17158 dw_loc_descr_ref loc
;
17160 if (tree_fits_shwi_p (val
))
17162 add_AT_unsigned (die
, attr
, tree_to_shwi (val
));
17166 loc
= descr_info_loc (val
, base_decl
);
17170 add_AT_loc (die
, attr
, loc
);
17173 /* This routine generates DIE for array with hidden descriptor, details
17174 are filled into *info by a langhook. */
17177 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
17178 dw_die_ref context_die
)
17180 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17181 dw_die_ref array_die
;
17184 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17185 add_name_attribute (array_die
, type_tag (type
));
17186 equate_type_number_to_die (type
, array_die
);
17188 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17190 && info
->ndimensions
>= 2)
17191 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17193 if (info
->data_location
)
17194 add_descr_info_field (array_die
, DW_AT_data_location
, info
->data_location
,
17196 if (info
->associated
)
17197 add_descr_info_field (array_die
, DW_AT_associated
, info
->associated
,
17199 if (info
->allocated
)
17200 add_descr_info_field (array_die
, DW_AT_allocated
, info
->allocated
,
17203 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
17205 dw_die_ref subrange_die
17206 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17208 if (info
->dimen
[dim
].lower_bound
)
17210 /* If it is the default value, omit it. */
17213 if (tree_fits_shwi_p (info
->dimen
[dim
].lower_bound
)
17214 && (dflt
= lower_bound_default ()) != -1
17215 && tree_to_shwi (info
->dimen
[dim
].lower_bound
) == dflt
)
17218 add_descr_info_field (subrange_die
, DW_AT_lower_bound
,
17219 info
->dimen
[dim
].lower_bound
,
17222 if (info
->dimen
[dim
].upper_bound
)
17223 add_descr_info_field (subrange_die
, DW_AT_upper_bound
,
17224 info
->dimen
[dim
].upper_bound
,
17226 if (info
->dimen
[dim
].stride
)
17227 add_descr_info_field (subrange_die
, DW_AT_byte_stride
,
17228 info
->dimen
[dim
].stride
,
17232 gen_type_die (info
->element_type
, context_die
);
17233 add_type_attribute (array_die
, info
->element_type
, 0, 0, context_die
);
17235 if (get_AT (array_die
, DW_AT_name
))
17236 add_pubtype (type
, array_die
);
17241 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
17243 tree origin
= decl_ultimate_origin (decl
);
17244 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
17246 if (origin
!= NULL
)
17247 add_abstract_origin_attribute (decl_die
, origin
);
17250 add_name_and_src_coords_attributes (decl_die
, decl
);
17251 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
17252 0, 0, context_die
);
17255 if (DECL_ABSTRACT (decl
))
17256 equate_decl_number_to_die (decl
, decl_die
);
17258 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
17262 /* Walk through the list of incomplete types again, trying once more to
17263 emit full debugging info for them. */
17266 retry_incomplete_types (void)
17270 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
17271 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
17272 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
17275 /* Determine what tag to use for a record type. */
17277 static enum dwarf_tag
17278 record_type_tag (tree type
)
17280 if (! lang_hooks
.types
.classify_record
)
17281 return DW_TAG_structure_type
;
17283 switch (lang_hooks
.types
.classify_record (type
))
17285 case RECORD_IS_STRUCT
:
17286 return DW_TAG_structure_type
;
17288 case RECORD_IS_CLASS
:
17289 return DW_TAG_class_type
;
17291 case RECORD_IS_INTERFACE
:
17292 if (dwarf_version
>= 3 || !dwarf_strict
)
17293 return DW_TAG_interface_type
;
17294 return DW_TAG_structure_type
;
17297 gcc_unreachable ();
17301 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17302 include all of the information about the enumeration values also. Each
17303 enumerated type name/value is listed as a child of the enumerated type
17307 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
17309 dw_die_ref type_die
= lookup_type_die (type
);
17311 if (type_die
== NULL
)
17313 type_die
= new_die (DW_TAG_enumeration_type
,
17314 scope_die_for (type
, context_die
), type
);
17315 equate_type_number_to_die (type
, type_die
);
17316 add_name_attribute (type_die
, type_tag (type
));
17317 if (dwarf_version
>= 4 || !dwarf_strict
)
17319 if (ENUM_IS_SCOPED (type
))
17320 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
17321 if (ENUM_IS_OPAQUE (type
))
17322 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17325 else if (! TYPE_SIZE (type
))
17328 remove_AT (type_die
, DW_AT_declaration
);
17330 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17331 given enum type is incomplete, do not generate the DW_AT_byte_size
17332 attribute or the DW_AT_element_list attribute. */
17333 if (TYPE_SIZE (type
))
17337 TREE_ASM_WRITTEN (type
) = 1;
17338 add_byte_size_attribute (type_die
, type
);
17339 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
17341 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
17342 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
17345 /* If the first reference to this type was as the return type of an
17346 inline function, then it may not have a parent. Fix this now. */
17347 if (type_die
->die_parent
== NULL
)
17348 add_child_die (scope_die_for (type
, context_die
), type_die
);
17350 for (link
= TYPE_VALUES (type
);
17351 link
!= NULL
; link
= TREE_CHAIN (link
))
17353 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
17354 tree value
= TREE_VALUE (link
);
17356 add_name_attribute (enum_die
,
17357 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
17359 if (TREE_CODE (value
) == CONST_DECL
)
17360 value
= DECL_INITIAL (value
);
17362 if (simple_type_size_in_bits (TREE_TYPE (value
))
17363 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
17365 /* For constant forms created by add_AT_unsigned DWARF
17366 consumers (GDB, elfutils, etc.) always zero extend
17367 the value. Only when the actual value is negative
17368 do we need to use add_AT_int to generate a constant
17369 form that can represent negative values. */
17370 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
17371 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
17372 add_AT_unsigned (enum_die
, DW_AT_const_value
,
17373 (unsigned HOST_WIDE_INT
) val
);
17375 add_AT_int (enum_die
, DW_AT_const_value
, val
);
17378 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
17379 that here. TODO: This should be re-worked to use correct
17380 signed/unsigned double tags for all cases. */
17381 add_AT_double (enum_die
, DW_AT_const_value
,
17382 TREE_INT_CST_HIGH (value
), TREE_INT_CST_LOW (value
));
17385 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
17386 if (TYPE_ARTIFICIAL (type
))
17387 add_AT_flag (type_die
, DW_AT_artificial
, 1);
17390 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17392 add_pubtype (type
, type_die
);
17397 /* Generate a DIE to represent either a real live formal parameter decl or to
17398 represent just the type of some formal parameter position in some function
17401 Note that this routine is a bit unusual because its argument may be a
17402 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17403 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17404 node. If it's the former then this function is being called to output a
17405 DIE to represent a formal parameter object (or some inlining thereof). If
17406 it's the latter, then this function is only being called to output a
17407 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17408 argument type of some subprogram type.
17409 If EMIT_NAME_P is true, name and source coordinate attributes
17413 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
17414 dw_die_ref context_die
)
17416 tree node_or_origin
= node
? node
: origin
;
17417 tree ultimate_origin
;
17418 dw_die_ref parm_die
17419 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
17421 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
17423 case tcc_declaration
:
17424 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
17425 if (node
|| ultimate_origin
)
17426 origin
= ultimate_origin
;
17427 if (origin
!= NULL
)
17428 add_abstract_origin_attribute (parm_die
, origin
);
17429 else if (emit_name_p
)
17430 add_name_and_src_coords_attributes (parm_die
, node
);
17432 || (! DECL_ABSTRACT (node_or_origin
)
17433 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
17434 decl_function_context
17435 (node_or_origin
))))
17437 tree type
= TREE_TYPE (node_or_origin
);
17438 if (decl_by_reference_p (node_or_origin
))
17439 add_type_attribute (parm_die
, TREE_TYPE (type
), 0, 0,
17442 add_type_attribute (parm_die
, type
,
17443 TREE_READONLY (node_or_origin
),
17444 TREE_THIS_VOLATILE (node_or_origin
),
17447 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
17448 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17450 if (node
&& node
!= origin
)
17451 equate_decl_number_to_die (node
, parm_die
);
17452 if (! DECL_ABSTRACT (node_or_origin
))
17453 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
17454 node
== NULL
, DW_AT_location
);
17459 /* We were called with some kind of a ..._TYPE node. */
17460 add_type_attribute (parm_die
, node_or_origin
, 0, 0, context_die
);
17464 gcc_unreachable ();
17470 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17471 children DW_TAG_formal_parameter DIEs representing the arguments of the
17474 PARM_PACK must be a function parameter pack.
17475 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17476 must point to the subsequent arguments of the function PACK_ARG belongs to.
17477 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17478 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17479 following the last one for which a DIE was generated. */
17482 gen_formal_parameter_pack_die (tree parm_pack
,
17484 dw_die_ref subr_die
,
17488 dw_die_ref parm_pack_die
;
17490 gcc_assert (parm_pack
17491 && lang_hooks
.function_parameter_pack_p (parm_pack
)
17494 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
17495 add_src_coords_attributes (parm_pack_die
, parm_pack
);
17497 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
17499 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
17502 gen_formal_parameter_die (arg
, NULL
,
17503 false /* Don't emit name attribute. */,
17508 return parm_pack_die
;
17511 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17512 at the end of an (ANSI prototyped) formal parameters list. */
17515 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
17517 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
17520 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17521 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17522 parameters as specified in some function type specification (except for
17523 those which appear as part of a function *definition*). */
17526 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
17529 tree formal_type
= NULL
;
17530 tree first_parm_type
;
17533 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
17535 arg
= DECL_ARGUMENTS (function_or_method_type
);
17536 function_or_method_type
= TREE_TYPE (function_or_method_type
);
17541 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
17543 /* Make our first pass over the list of formal parameter types and output a
17544 DW_TAG_formal_parameter DIE for each one. */
17545 for (link
= first_parm_type
; link
; )
17547 dw_die_ref parm_die
;
17549 formal_type
= TREE_VALUE (link
);
17550 if (formal_type
== void_type_node
)
17553 /* Output a (nameless) DIE to represent the formal parameter itself. */
17554 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
17555 true /* Emit name attribute. */,
17557 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
17558 && link
== first_parm_type
)
17560 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17561 if (dwarf_version
>= 3 || !dwarf_strict
)
17562 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
17564 else if (arg
&& DECL_ARTIFICIAL (arg
))
17565 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17567 link
= TREE_CHAIN (link
);
17569 arg
= DECL_CHAIN (arg
);
17572 /* If this function type has an ellipsis, add a
17573 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
17574 if (formal_type
!= void_type_node
)
17575 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
17577 /* Make our second (and final) pass over the list of formal parameter types
17578 and output DIEs to represent those types (as necessary). */
17579 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
17580 link
&& TREE_VALUE (link
);
17581 link
= TREE_CHAIN (link
))
17582 gen_type_die (TREE_VALUE (link
), context_die
);
17585 /* We want to generate the DIE for TYPE so that we can generate the
17586 die for MEMBER, which has been defined; we will need to refer back
17587 to the member declaration nested within TYPE. If we're trying to
17588 generate minimal debug info for TYPE, processing TYPE won't do the
17589 trick; we need to attach the member declaration by hand. */
17592 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
17594 gen_type_die (type
, context_die
);
17596 /* If we're trying to avoid duplicate debug info, we may not have
17597 emitted the member decl for this function. Emit it now. */
17598 if (TYPE_STUB_DECL (type
)
17599 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
17600 && ! lookup_decl_die (member
))
17602 dw_die_ref type_die
;
17603 gcc_assert (!decl_ultimate_origin (member
));
17605 push_decl_scope (type
);
17606 type_die
= lookup_type_die_strip_naming_typedef (type
);
17607 if (TREE_CODE (member
) == FUNCTION_DECL
)
17608 gen_subprogram_die (member
, type_die
);
17609 else if (TREE_CODE (member
) == FIELD_DECL
)
17611 /* Ignore the nameless fields that are used to skip bits but handle
17612 C++ anonymous unions and structs. */
17613 if (DECL_NAME (member
) != NULL_TREE
17614 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
17615 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
17617 gen_type_die (member_declared_type (member
), type_die
);
17618 gen_field_die (member
, type_die
);
17622 gen_variable_die (member
, NULL_TREE
, type_die
);
17628 /* Forward declare these functions, because they are mutually recursive
17629 with their set_block_* pairing functions. */
17630 static void set_decl_origin_self (tree
);
17631 static void set_decl_abstract_flags (tree
, int);
17633 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
17634 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
17635 that it points to the node itself, thus indicating that the node is its
17636 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
17637 the given node is NULL, recursively descend the decl/block tree which
17638 it is the root of, and for each other ..._DECL or BLOCK node contained
17639 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
17640 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
17641 values to point to themselves. */
17644 set_block_origin_self (tree stmt
)
17646 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
17648 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
17653 for (local_decl
= BLOCK_VARS (stmt
);
17654 local_decl
!= NULL_TREE
;
17655 local_decl
= DECL_CHAIN (local_decl
))
17656 if (! DECL_EXTERNAL (local_decl
))
17657 set_decl_origin_self (local_decl
); /* Potential recursion. */
17663 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17664 subblock
!= NULL_TREE
;
17665 subblock
= BLOCK_CHAIN (subblock
))
17666 set_block_origin_self (subblock
); /* Recurse. */
17671 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
17672 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
17673 node to so that it points to the node itself, thus indicating that the
17674 node represents its own (abstract) origin. Additionally, if the
17675 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
17676 the decl/block tree of which the given node is the root of, and for
17677 each other ..._DECL or BLOCK node contained therein whose
17678 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
17679 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
17680 point to themselves. */
17683 set_decl_origin_self (tree decl
)
17685 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
17687 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
17688 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17692 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17693 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
17694 if (DECL_INITIAL (decl
) != NULL_TREE
17695 && DECL_INITIAL (decl
) != error_mark_node
)
17696 set_block_origin_self (DECL_INITIAL (decl
));
17701 /* Given a pointer to some BLOCK node, and a boolean value to set the
17702 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
17703 the given block, and for all local decls and all local sub-blocks
17704 (recursively) which are contained therein. */
17707 set_block_abstract_flags (tree stmt
, int setting
)
17713 BLOCK_ABSTRACT (stmt
) = setting
;
17715 for (local_decl
= BLOCK_VARS (stmt
);
17716 local_decl
!= NULL_TREE
;
17717 local_decl
= DECL_CHAIN (local_decl
))
17718 if (! DECL_EXTERNAL (local_decl
))
17719 set_decl_abstract_flags (local_decl
, setting
);
17721 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
17723 local_decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
17724 if ((TREE_CODE (local_decl
) == VAR_DECL
&& !TREE_STATIC (local_decl
))
17725 || TREE_CODE (local_decl
) == PARM_DECL
)
17726 set_decl_abstract_flags (local_decl
, setting
);
17729 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17730 subblock
!= NULL_TREE
;
17731 subblock
= BLOCK_CHAIN (subblock
))
17732 set_block_abstract_flags (subblock
, setting
);
17735 /* Given a pointer to some ..._DECL node, and a boolean value to set the
17736 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
17737 given decl, and (in the case where the decl is a FUNCTION_DECL) also
17738 set the abstract flags for all of the parameters, local vars, local
17739 blocks and sub-blocks (recursively) to the same setting. */
17742 set_decl_abstract_flags (tree decl
, int setting
)
17744 DECL_ABSTRACT (decl
) = setting
;
17745 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17749 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17750 DECL_ABSTRACT (arg
) = setting
;
17751 if (DECL_INITIAL (decl
) != NULL_TREE
17752 && DECL_INITIAL (decl
) != error_mark_node
)
17753 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
17757 /* Generate the DWARF2 info for the "abstract" instance of a function which we
17758 may later generate inlined and/or out-of-line instances of. */
17761 dwarf2out_abstract_function (tree decl
)
17763 dw_die_ref old_die
;
17767 htab_t old_decl_loc_table
;
17768 htab_t old_cached_dw_loc_list_table
;
17769 int old_call_site_count
, old_tail_call_site_count
;
17770 struct call_arg_loc_node
*old_call_arg_locations
;
17772 /* Make sure we have the actual abstract inline, not a clone. */
17773 decl
= DECL_ORIGIN (decl
);
17775 old_die
= lookup_decl_die (decl
);
17776 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
17777 /* We've already generated the abstract instance. */
17780 /* We can be called while recursively when seeing block defining inlined subroutine
17781 DIE. Be sure to not clobber the outer location table nor use it or we would
17782 get locations in abstract instantces. */
17783 old_decl_loc_table
= decl_loc_table
;
17784 decl_loc_table
= NULL
;
17785 old_cached_dw_loc_list_table
= cached_dw_loc_list_table
;
17786 cached_dw_loc_list_table
= NULL
;
17787 old_call_arg_locations
= call_arg_locations
;
17788 call_arg_locations
= NULL
;
17789 old_call_site_count
= call_site_count
;
17790 call_site_count
= -1;
17791 old_tail_call_site_count
= tail_call_site_count
;
17792 tail_call_site_count
= -1;
17794 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
17795 we don't get confused by DECL_ABSTRACT. */
17796 if (debug_info_level
> DINFO_LEVEL_TERSE
)
17798 context
= decl_class_context (decl
);
17800 gen_type_die_for_member
17801 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die ());
17804 /* Pretend we've just finished compiling this function. */
17805 save_fn
= current_function_decl
;
17806 current_function_decl
= decl
;
17808 was_abstract
= DECL_ABSTRACT (decl
);
17809 set_decl_abstract_flags (decl
, 1);
17810 dwarf2out_decl (decl
);
17811 if (! was_abstract
)
17812 set_decl_abstract_flags (decl
, 0);
17814 current_function_decl
= save_fn
;
17815 decl_loc_table
= old_decl_loc_table
;
17816 cached_dw_loc_list_table
= old_cached_dw_loc_list_table
;
17817 call_arg_locations
= old_call_arg_locations
;
17818 call_site_count
= old_call_site_count
;
17819 tail_call_site_count
= old_tail_call_site_count
;
17822 /* Helper function of premark_used_types() which gets called through
17825 Marks the DIE of a given type in *SLOT as perennial, so it never gets
17826 marked as unused by prune_unused_types. */
17829 premark_used_types_helper (void **slot
, void *data ATTRIBUTE_UNUSED
)
17834 type
= (tree
) *slot
;
17835 die
= lookup_type_die (type
);
17837 die
->die_perennial_p
= 1;
17841 /* Helper function of premark_types_used_by_global_vars which gets called
17842 through htab_traverse.
17844 Marks the DIE of a given type in *SLOT as perennial, so it never gets
17845 marked as unused by prune_unused_types. The DIE of the type is marked
17846 only if the global variable using the type will actually be emitted. */
17849 premark_types_used_by_global_vars_helper (void **slot
,
17850 void *data ATTRIBUTE_UNUSED
)
17852 struct types_used_by_vars_entry
*entry
;
17855 entry
= (struct types_used_by_vars_entry
*) *slot
;
17856 gcc_assert (entry
->type
!= NULL
17857 && entry
->var_decl
!= NULL
);
17858 die
= lookup_type_die (entry
->type
);
17861 /* Ask cgraph if the global variable really is to be emitted.
17862 If yes, then we'll keep the DIE of ENTRY->TYPE. */
17863 varpool_node
*node
= varpool_get_node (entry
->var_decl
);
17864 if (node
&& node
->definition
)
17866 die
->die_perennial_p
= 1;
17867 /* Keep the parent DIEs as well. */
17868 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
17869 die
->die_perennial_p
= 1;
17875 /* Mark all members of used_types_hash as perennial. */
17878 premark_used_types (struct function
*fun
)
17880 if (fun
&& fun
->used_types_hash
)
17881 htab_traverse (fun
->used_types_hash
, premark_used_types_helper
, NULL
);
17884 /* Mark all members of types_used_by_vars_entry as perennial. */
17887 premark_types_used_by_global_vars (void)
17889 if (types_used_by_vars_hash
)
17890 htab_traverse (types_used_by_vars_hash
,
17891 premark_types_used_by_global_vars_helper
, NULL
);
17894 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
17895 for CA_LOC call arg loc node. */
17898 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
17899 struct call_arg_loc_node
*ca_loc
)
17901 dw_die_ref stmt_die
= NULL
, die
;
17902 tree block
= ca_loc
->block
;
17905 && block
!= DECL_INITIAL (decl
)
17906 && TREE_CODE (block
) == BLOCK
)
17908 if (block_map
.length () > BLOCK_NUMBER (block
))
17909 stmt_die
= block_map
[BLOCK_NUMBER (block
)];
17912 block
= BLOCK_SUPERCONTEXT (block
);
17914 if (stmt_die
== NULL
)
17915 stmt_die
= subr_die
;
17916 die
= new_die (DW_TAG_GNU_call_site
, stmt_die
, NULL_TREE
);
17917 add_AT_lbl_id (die
, DW_AT_low_pc
, ca_loc
->label
);
17918 if (ca_loc
->tail_call_p
)
17919 add_AT_flag (die
, DW_AT_GNU_tail_call
, 1);
17920 if (ca_loc
->symbol_ref
)
17922 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
17924 add_AT_die_ref (die
, DW_AT_abstract_origin
, tdie
);
17926 add_AT_addr (die
, DW_AT_abstract_origin
, ca_loc
->symbol_ref
, false);
17931 /* Generate a DIE to represent a declared function (either file-scope or
17935 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
17937 tree origin
= decl_ultimate_origin (decl
);
17938 dw_die_ref subr_die
;
17940 dw_die_ref old_die
= lookup_decl_die (decl
);
17941 int declaration
= (current_function_decl
!= decl
17942 || class_or_namespace_scope_p (context_die
));
17944 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
17946 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
17947 started to generate the abstract instance of an inline, decided to output
17948 its containing class, and proceeded to emit the declaration of the inline
17949 from the member list for the class. If so, DECLARATION takes priority;
17950 we'll get back to the abstract instance when done with the class. */
17952 /* The class-scope declaration DIE must be the primary DIE. */
17953 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
17956 gcc_assert (!old_die
);
17959 /* Now that the C++ front end lazily declares artificial member fns, we
17960 might need to retrofit the declaration into its class. */
17961 if (!declaration
&& !origin
&& !old_die
17962 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
17963 && !class_or_namespace_scope_p (context_die
)
17964 && debug_info_level
> DINFO_LEVEL_TERSE
)
17965 old_die
= force_decl_die (decl
);
17967 if (origin
!= NULL
)
17969 gcc_assert (!declaration
|| local_scope_p (context_die
));
17971 /* Fixup die_parent for the abstract instance of a nested
17972 inline function. */
17973 if (old_die
&& old_die
->die_parent
== NULL
)
17974 add_child_die (context_die
, old_die
);
17976 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
17977 add_abstract_origin_attribute (subr_die
, origin
);
17978 /* This is where the actual code for a cloned function is.
17979 Let's emit linkage name attribute for it. This helps
17980 debuggers to e.g, set breakpoints into
17981 constructors/destructors when the user asks "break
17983 add_linkage_name (subr_die
, decl
);
17987 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
17988 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
17990 if (!get_AT_flag (old_die
, DW_AT_declaration
)
17991 /* We can have a normal definition following an inline one in the
17992 case of redefinition of GNU C extern inlines.
17993 It seems reasonable to use AT_specification in this case. */
17994 && !get_AT (old_die
, DW_AT_inline
))
17996 /* Detect and ignore this case, where we are trying to output
17997 something we have already output. */
18001 /* If the definition comes from the same place as the declaration,
18002 maybe use the old DIE. We always want the DIE for this function
18003 that has the *_pc attributes to be under comp_unit_die so the
18004 debugger can find it. We also need to do this for abstract
18005 instances of inlines, since the spec requires the out-of-line copy
18006 to have the same parent. For local class methods, this doesn't
18007 apply; we just use the old DIE. */
18008 if ((is_cu_die (old_die
->die_parent
) || context_die
== NULL
)
18009 && (DECL_ARTIFICIAL (decl
)
18010 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
18011 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
18012 == (unsigned) s
.line
))))
18014 subr_die
= old_die
;
18016 /* Clear out the declaration attribute and the formal parameters.
18017 Do not remove all children, because it is possible that this
18018 declaration die was forced using force_decl_die(). In such
18019 cases die that forced declaration die (e.g. TAG_imported_module)
18020 is one of the children that we do not want to remove. */
18021 remove_AT (subr_die
, DW_AT_declaration
);
18022 remove_AT (subr_die
, DW_AT_object_pointer
);
18023 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
18027 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18028 add_AT_specification (subr_die
, old_die
);
18029 add_pubname (decl
, subr_die
);
18030 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18031 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
18032 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18033 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
18035 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
18036 emit the real type on the definition die. */
18037 if (is_cxx() && debug_info_level
> DINFO_LEVEL_TERSE
)
18039 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
18040 if (die
== auto_die
|| die
== decltype_auto_die
)
18041 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18042 0, 0, context_die
);
18048 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18050 if (TREE_PUBLIC (decl
))
18051 add_AT_flag (subr_die
, DW_AT_external
, 1);
18053 add_name_and_src_coords_attributes (subr_die
, decl
);
18054 add_pubname (decl
, subr_die
);
18055 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18057 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
18058 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18059 0, 0, context_die
);
18062 add_pure_or_virtual_attribute (subr_die
, decl
);
18063 if (DECL_ARTIFICIAL (decl
))
18064 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18066 add_accessibility_attribute (subr_die
, decl
);
18071 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18073 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
18075 /* If this is an explicit function declaration then generate
18076 a DW_AT_explicit attribute. */
18077 if (lang_hooks
.decls
.function_decl_explicit_p (decl
)
18078 && (dwarf_version
>= 3 || !dwarf_strict
))
18079 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
18081 /* The first time we see a member function, it is in the context of
18082 the class to which it belongs. We make sure of this by emitting
18083 the class first. The next time is the definition, which is
18084 handled above. The two may come from the same source text.
18086 Note that force_decl_die() forces function declaration die. It is
18087 later reused to represent definition. */
18088 equate_decl_number_to_die (decl
, subr_die
);
18091 else if (DECL_ABSTRACT (decl
))
18093 if (DECL_DECLARED_INLINE_P (decl
))
18095 if (cgraph_function_possibly_inlined_p (decl
))
18096 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
18098 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
18102 if (cgraph_function_possibly_inlined_p (decl
))
18103 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
18105 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
18108 if (DECL_DECLARED_INLINE_P (decl
)
18109 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
18110 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18112 equate_decl_number_to_die (decl
, subr_die
);
18114 else if (!DECL_EXTERNAL (decl
))
18116 HOST_WIDE_INT cfa_fb_offset
;
18117 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
18119 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18120 equate_decl_number_to_die (decl
, subr_die
);
18122 gcc_checking_assert (fun
);
18123 if (!flag_reorder_blocks_and_partition
)
18125 dw_fde_ref fde
= fun
->fde
;
18126 if (fde
->dw_fde_begin
)
18128 /* We have already generated the labels. */
18129 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18130 fde
->dw_fde_end
, false);
18134 /* Create start/end labels and add the range. */
18135 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
18136 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
18137 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
18138 current_function_funcdef_no
);
18139 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
18140 current_function_funcdef_no
);
18141 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
18145 #if VMS_DEBUGGING_INFO
18146 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18147 Section 2.3 Prologue and Epilogue Attributes:
18148 When a breakpoint is set on entry to a function, it is generally
18149 desirable for execution to be suspended, not on the very first
18150 instruction of the function, but rather at a point after the
18151 function's frame has been set up, after any language defined local
18152 declaration processing has been completed, and before execution of
18153 the first statement of the function begins. Debuggers generally
18154 cannot properly determine where this point is. Similarly for a
18155 breakpoint set on exit from a function. The prologue and epilogue
18156 attributes allow a compiler to communicate the location(s) to use. */
18159 if (fde
->dw_fde_vms_end_prologue
)
18160 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
18161 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
18163 if (fde
->dw_fde_vms_begin_epilogue
)
18164 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
18165 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
18172 /* Generate pubnames entries for the split function code ranges. */
18173 dw_fde_ref fde
= fun
->fde
;
18175 if (fde
->dw_fde_second_begin
)
18177 if (dwarf_version
>= 3 || !dwarf_strict
)
18179 /* We should use ranges for non-contiguous code section
18180 addresses. Use the actual code range for the initial
18181 section, since the HOT/COLD labels might precede an
18182 alignment offset. */
18183 bool range_list_added
= false;
18184 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
18185 fde
->dw_fde_end
, &range_list_added
,
18187 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
18188 fde
->dw_fde_second_end
,
18189 &range_list_added
, false);
18190 if (range_list_added
)
18195 /* There is no real support in DW2 for this .. so we make
18196 a work-around. First, emit the pub name for the segment
18197 containing the function label. Then make and emit a
18198 simplified subprogram DIE for the second segment with the
18199 name pre-fixed by __hot/cold_sect_of_. We use the same
18200 linkage name for the second die so that gdb will find both
18201 sections when given "b foo". */
18202 const char *name
= NULL
;
18203 tree decl_name
= DECL_NAME (decl
);
18204 dw_die_ref seg_die
;
18206 /* Do the 'primary' section. */
18207 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18208 fde
->dw_fde_end
, false);
18210 /* Build a minimal DIE for the secondary section. */
18211 seg_die
= new_die (DW_TAG_subprogram
,
18212 subr_die
->die_parent
, decl
);
18214 if (TREE_PUBLIC (decl
))
18215 add_AT_flag (seg_die
, DW_AT_external
, 1);
18217 if (decl_name
!= NULL
18218 && IDENTIFIER_POINTER (decl_name
) != NULL
)
18220 name
= dwarf2_name (decl
, 1);
18221 if (! DECL_ARTIFICIAL (decl
))
18222 add_src_coords_attributes (seg_die
, decl
);
18224 add_linkage_name (seg_die
, decl
);
18226 gcc_assert (name
!= NULL
);
18227 add_pure_or_virtual_attribute (seg_die
, decl
);
18228 if (DECL_ARTIFICIAL (decl
))
18229 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
18231 name
= concat ("__second_sect_of_", name
, NULL
);
18232 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
18233 fde
->dw_fde_second_end
, false);
18234 add_name_attribute (seg_die
, name
);
18235 if (want_pubnames ())
18236 add_pubname_string (name
, seg_die
);
18240 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
18244 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
18246 /* We define the "frame base" as the function's CFA. This is more
18247 convenient for several reasons: (1) It's stable across the prologue
18248 and epilogue, which makes it better than just a frame pointer,
18249 (2) With dwarf3, there exists a one-byte encoding that allows us
18250 to reference the .debug_frame data by proxy, but failing that,
18251 (3) We can at least reuse the code inspection and interpretation
18252 code that determines the CFA position at various points in the
18254 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
18256 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
18257 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
18261 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
18262 if (list
->dw_loc_next
)
18263 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
18265 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
18268 /* Compute a displacement from the "steady-state frame pointer" to
18269 the CFA. The former is what all stack slots and argument slots
18270 will reference in the rtl; the latter is what we've told the
18271 debugger about. We'll need to adjust all frame_base references
18272 by this displacement. */
18273 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
18275 if (fun
->static_chain_decl
)
18276 add_AT_location_description (subr_die
, DW_AT_static_link
,
18277 loc_list_from_tree (fun
->static_chain_decl
, 2));
18280 /* Generate child dies for template paramaters. */
18281 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18282 gen_generic_params_dies (decl
);
18284 /* Now output descriptions of the arguments for this function. This gets
18285 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18286 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18287 `...' at the end of the formal parameter list. In order to find out if
18288 there was a trailing ellipsis or not, we must instead look at the type
18289 associated with the FUNCTION_DECL. This will be a node of type
18290 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18291 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18292 an ellipsis at the end. */
18294 /* In the case where we are describing a mere function declaration, all we
18295 need to do here (and all we *can* do here) is to describe the *types* of
18296 its formal parameters. */
18297 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
18299 else if (declaration
)
18300 gen_formal_types_die (decl
, subr_die
);
18303 /* Generate DIEs to represent all known formal parameters. */
18304 tree parm
= DECL_ARGUMENTS (decl
);
18305 tree generic_decl
= lang_hooks
.decls
.get_generic_function_decl (decl
);
18306 tree generic_decl_parm
= generic_decl
18307 ? DECL_ARGUMENTS (generic_decl
)
18310 /* Now we want to walk the list of parameters of the function and
18311 emit their relevant DIEs.
18313 We consider the case of DECL being an instance of a generic function
18314 as well as it being a normal function.
18316 If DECL is an instance of a generic function we walk the
18317 parameters of the generic function declaration _and_ the parameters of
18318 DECL itself. This is useful because we want to emit specific DIEs for
18319 function parameter packs and those are declared as part of the
18320 generic function declaration. In that particular case,
18321 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18322 That DIE has children DIEs representing the set of arguments
18323 of the pack. Note that the set of pack arguments can be empty.
18324 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18327 Otherwise, we just consider the parameters of DECL. */
18328 while (generic_decl_parm
|| parm
)
18330 if (generic_decl_parm
18331 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
18332 gen_formal_parameter_pack_die (generic_decl_parm
,
18337 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, subr_die
);
18339 if (parm
== DECL_ARGUMENTS (decl
)
18340 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
18342 && (dwarf_version
>= 3 || !dwarf_strict
))
18343 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
18345 parm
= DECL_CHAIN (parm
);
18348 if (generic_decl_parm
)
18349 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
18352 /* Decide whether we need an unspecified_parameters DIE at the end.
18353 There are 2 more cases to do this for: 1) the ansi ... declaration -
18354 this is detectable when the end of the arg list is not a
18355 void_type_node 2) an unprototyped function declaration (not a
18356 definition). This just means that we have no info about the
18357 parameters at all. */
18358 if (prototype_p (TREE_TYPE (decl
)))
18360 /* This is the prototyped case, check for.... */
18361 if (stdarg_p (TREE_TYPE (decl
)))
18362 gen_unspecified_parameters_die (decl
, subr_die
);
18364 else if (DECL_INITIAL (decl
) == NULL_TREE
)
18365 gen_unspecified_parameters_die (decl
, subr_die
);
18368 /* Output Dwarf info for all of the stuff within the body of the function
18369 (if it has one - it may be just a declaration). */
18370 outer_scope
= DECL_INITIAL (decl
);
18372 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18373 a function. This BLOCK actually represents the outermost binding contour
18374 for the function, i.e. the contour in which the function's formal
18375 parameters and labels get declared. Curiously, it appears that the front
18376 end doesn't actually put the PARM_DECL nodes for the current function onto
18377 the BLOCK_VARS list for this outer scope, but are strung off of the
18378 DECL_ARGUMENTS list for the function instead.
18380 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18381 the LABEL_DECL nodes for the function however, and we output DWARF info
18382 for those in decls_for_scope. Just within the `outer_scope' there will be
18383 a BLOCK node representing the function's outermost pair of curly braces,
18384 and any blocks used for the base and member initializers of a C++
18385 constructor function. */
18386 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
18388 int call_site_note_count
= 0;
18389 int tail_call_site_note_count
= 0;
18391 /* Emit a DW_TAG_variable DIE for a named return value. */
18392 if (DECL_NAME (DECL_RESULT (decl
)))
18393 gen_decl_die (DECL_RESULT (decl
), NULL
, subr_die
);
18395 current_function_has_inlines
= 0;
18396 decls_for_scope (outer_scope
, subr_die
, 0);
18398 if (call_arg_locations
&& !dwarf_strict
)
18400 struct call_arg_loc_node
*ca_loc
;
18401 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
18403 dw_die_ref die
= NULL
;
18404 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
18407 for (arg
= NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
);
18408 arg
; arg
= next_arg
)
18410 dw_loc_descr_ref reg
, val
;
18411 enum machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
18412 dw_die_ref cdie
, tdie
= NULL
;
18414 next_arg
= XEXP (arg
, 1);
18415 if (REG_P (XEXP (XEXP (arg
, 0), 0))
18417 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
18418 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
18419 && REGNO (XEXP (XEXP (arg
, 0), 0))
18420 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
18421 next_arg
= XEXP (next_arg
, 1);
18422 if (mode
== VOIDmode
)
18424 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
18425 if (mode
== VOIDmode
)
18426 mode
= GET_MODE (XEXP (arg
, 0));
18428 if (mode
== VOIDmode
|| mode
== BLKmode
)
18430 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
18432 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18433 tloc
= XEXP (XEXP (arg
, 0), 1);
18436 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
18437 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
18439 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18440 tlocc
= XEXP (XEXP (arg
, 0), 1);
18444 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
18445 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
18446 VAR_INIT_STATUS_INITIALIZED
);
18447 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
18449 rtx mem
= XEXP (XEXP (arg
, 0), 0);
18450 reg
= mem_loc_descriptor (XEXP (mem
, 0),
18451 get_address_mode (mem
),
18453 VAR_INIT_STATUS_INITIALIZED
);
18455 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
18456 == DEBUG_PARAMETER_REF
)
18459 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
18460 tdie
= lookup_decl_die (tdecl
);
18467 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
18468 != DEBUG_PARAMETER_REF
)
18470 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
18472 VAR_INIT_STATUS_INITIALIZED
);
18476 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18477 cdie
= new_die (DW_TAG_GNU_call_site_parameter
, die
,
18480 add_AT_loc (cdie
, DW_AT_location
, reg
);
18481 else if (tdie
!= NULL
)
18482 add_AT_die_ref (cdie
, DW_AT_abstract_origin
, tdie
);
18483 add_AT_loc (cdie
, DW_AT_GNU_call_site_value
, val
);
18484 if (next_arg
!= XEXP (arg
, 1))
18486 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
18487 if (mode
== VOIDmode
)
18488 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
18489 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
18492 VAR_INIT_STATUS_INITIALIZED
);
18494 add_AT_loc (cdie
, DW_AT_GNU_call_site_data_value
, val
);
18498 && (ca_loc
->symbol_ref
|| tloc
))
18499 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18500 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
18502 dw_loc_descr_ref tval
= NULL
;
18504 if (tloc
!= NULL_RTX
)
18505 tval
= mem_loc_descriptor (tloc
,
18506 GET_MODE (tloc
) == VOIDmode
18507 ? Pmode
: GET_MODE (tloc
),
18509 VAR_INIT_STATUS_INITIALIZED
);
18511 add_AT_loc (die
, DW_AT_GNU_call_site_target
, tval
);
18512 else if (tlocc
!= NULL_RTX
)
18514 tval
= mem_loc_descriptor (tlocc
,
18515 GET_MODE (tlocc
) == VOIDmode
18516 ? Pmode
: GET_MODE (tlocc
),
18518 VAR_INIT_STATUS_INITIALIZED
);
18520 add_AT_loc (die
, DW_AT_GNU_call_site_target_clobbered
,
18526 call_site_note_count
++;
18527 if (ca_loc
->tail_call_p
)
18528 tail_call_site_note_count
++;
18532 call_arg_locations
= NULL
;
18533 call_arg_loc_last
= NULL
;
18534 if (tail_call_site_count
>= 0
18535 && tail_call_site_count
== tail_call_site_note_count
18538 if (call_site_count
>= 0
18539 && call_site_count
== call_site_note_count
)
18540 add_AT_flag (subr_die
, DW_AT_GNU_all_call_sites
, 1);
18542 add_AT_flag (subr_die
, DW_AT_GNU_all_tail_call_sites
, 1);
18544 call_site_count
= -1;
18545 tail_call_site_count
= -1;
18548 if (subr_die
!= old_die
)
18549 /* Add the calling convention attribute if requested. */
18550 add_calling_convention_attribute (subr_die
, decl
);
18553 /* Returns a hash value for X (which really is a die_struct). */
18556 common_block_die_table_hash (const void *x
)
18558 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18559 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
18562 /* Return nonzero if decl_id and die_parent of die_struct X is the same
18563 as decl_id and die_parent of die_struct Y. */
18566 common_block_die_table_eq (const void *x
, const void *y
)
18568 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18569 const_dw_die_ref e
= (const_dw_die_ref
) y
;
18570 return d
->decl_id
== e
->decl_id
&& d
->die_parent
== e
->die_parent
;
18573 /* Generate a DIE to represent a declared data object.
18574 Either DECL or ORIGIN must be non-null. */
18577 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
18579 HOST_WIDE_INT off
= 0;
18581 tree decl_or_origin
= decl
? decl
: origin
;
18582 tree ultimate_origin
;
18583 dw_die_ref var_die
;
18584 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
18585 dw_die_ref origin_die
;
18586 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
18587 || class_or_namespace_scope_p (context_die
));
18588 bool specialization_p
= false;
18590 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
18591 if (decl
|| ultimate_origin
)
18592 origin
= ultimate_origin
;
18593 com_decl
= fortran_common (decl_or_origin
, &off
);
18595 /* Symbol in common gets emitted as a child of the common block, in the form
18596 of a data member. */
18599 dw_die_ref com_die
;
18600 dw_loc_list_ref loc
;
18601 die_node com_die_arg
;
18603 var_die
= lookup_decl_die (decl_or_origin
);
18606 if (get_AT (var_die
, DW_AT_location
) == NULL
)
18608 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2);
18613 /* Optimize the common case. */
18614 if (single_element_loc_list_p (loc
)
18615 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18616 && loc
->expr
->dw_loc_next
== NULL
18617 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
18620 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18621 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18622 = plus_constant (GET_MODE (x
), x
, off
);
18625 loc_list_plus_const (loc
, off
);
18627 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18628 remove_AT (var_die
, DW_AT_declaration
);
18634 if (common_block_die_table
== NULL
)
18635 common_block_die_table
18636 = htab_create_ggc (10, common_block_die_table_hash
,
18637 common_block_die_table_eq
, NULL
);
18639 com_die_arg
.decl_id
= DECL_UID (com_decl
);
18640 com_die_arg
.die_parent
= context_die
;
18641 com_die
= (dw_die_ref
) htab_find (common_block_die_table
, &com_die_arg
);
18642 loc
= loc_list_from_tree (com_decl
, 2);
18643 if (com_die
== NULL
)
18646 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
18649 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
18650 add_name_and_src_coords_attributes (com_die
, com_decl
);
18653 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18654 /* Avoid sharing the same loc descriptor between
18655 DW_TAG_common_block and DW_TAG_variable. */
18656 loc
= loc_list_from_tree (com_decl
, 2);
18658 else if (DECL_EXTERNAL (decl
))
18659 add_AT_flag (com_die
, DW_AT_declaration
, 1);
18660 if (want_pubnames ())
18661 add_pubname_string (cnam
, com_die
); /* ??? needed? */
18662 com_die
->decl_id
= DECL_UID (com_decl
);
18663 slot
= htab_find_slot (common_block_die_table
, com_die
, INSERT
);
18664 *slot
= (void *) com_die
;
18666 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
18668 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18669 loc
= loc_list_from_tree (com_decl
, 2);
18670 remove_AT (com_die
, DW_AT_declaration
);
18672 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
18673 add_name_and_src_coords_attributes (var_die
, decl
);
18674 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
18675 TREE_THIS_VOLATILE (decl
), context_die
);
18676 add_AT_flag (var_die
, DW_AT_external
, 1);
18681 /* Optimize the common case. */
18682 if (single_element_loc_list_p (loc
)
18683 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18684 && loc
->expr
->dw_loc_next
== NULL
18685 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
18687 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18688 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18689 = plus_constant (GET_MODE (x
), x
, off
);
18692 loc_list_plus_const (loc
, off
);
18694 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18696 else if (DECL_EXTERNAL (decl
))
18697 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18698 equate_decl_number_to_die (decl
, var_die
);
18702 /* If the compiler emitted a definition for the DECL declaration
18703 and if we already emitted a DIE for it, don't emit a second
18704 DIE for it again. Allow re-declarations of DECLs that are
18705 inside functions, though. */
18706 if (old_die
&& declaration
&& !local_scope_p (context_die
))
18709 /* For static data members, the declaration in the class is supposed
18710 to have DW_TAG_member tag; the specification should still be
18711 DW_TAG_variable referencing the DW_TAG_member DIE. */
18712 if (declaration
&& class_scope_p (context_die
))
18713 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
18715 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
18718 if (origin
!= NULL
)
18719 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
18721 /* Loop unrolling can create multiple blocks that refer to the same
18722 static variable, so we must test for the DW_AT_declaration flag.
18724 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
18725 copy decls and set the DECL_ABSTRACT flag on them instead of
18728 ??? Duplicated blocks have been rewritten to use .debug_ranges.
18730 ??? The declare_in_namespace support causes us to get two DIEs for one
18731 variable, both of which are declarations. We want to avoid considering
18732 one to be a specification, so we must test that this DIE is not a
18734 else if (old_die
&& TREE_STATIC (decl
) && ! declaration
18735 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
18737 /* This is a definition of a C++ class level static. */
18738 add_AT_specification (var_die
, old_die
);
18739 specialization_p
= true;
18740 if (DECL_NAME (decl
))
18742 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18743 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18745 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18746 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
18748 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18749 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
18751 if (old_die
->die_tag
== DW_TAG_member
)
18752 add_linkage_name (var_die
, decl
);
18756 add_name_and_src_coords_attributes (var_die
, decl
);
18758 if ((origin
== NULL
&& !specialization_p
)
18760 && !DECL_ABSTRACT (decl_or_origin
)
18761 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
18762 decl_function_context
18763 (decl_or_origin
))))
18765 tree type
= TREE_TYPE (decl_or_origin
);
18767 if (decl_by_reference_p (decl_or_origin
))
18768 add_type_attribute (var_die
, TREE_TYPE (type
), 0, 0, context_die
);
18770 add_type_attribute (var_die
, type
, TREE_READONLY (decl_or_origin
),
18771 TREE_THIS_VOLATILE (decl_or_origin
), context_die
);
18774 if (origin
== NULL
&& !specialization_p
)
18776 if (TREE_PUBLIC (decl
))
18777 add_AT_flag (var_die
, DW_AT_external
, 1);
18779 if (DECL_ARTIFICIAL (decl
))
18780 add_AT_flag (var_die
, DW_AT_artificial
, 1);
18782 add_accessibility_attribute (var_die
, decl
);
18786 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18788 if (decl
&& (DECL_ABSTRACT (decl
) || declaration
|| old_die
== NULL
))
18789 equate_decl_number_to_die (decl
, var_die
);
18792 && (! DECL_ABSTRACT (decl_or_origin
)
18793 /* Local static vars are shared between all clones/inlines,
18794 so emit DW_AT_location on the abstract DIE if DECL_RTL is
18796 || (TREE_CODE (decl_or_origin
) == VAR_DECL
18797 && TREE_STATIC (decl_or_origin
)
18798 && DECL_RTL_SET_P (decl_or_origin
)))
18799 /* When abstract origin already has DW_AT_location attribute, no need
18800 to add it again. */
18801 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
18803 if (TREE_CODE (decl_or_origin
) == VAR_DECL
&& TREE_STATIC (decl_or_origin
)
18804 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin
)))
18805 defer_location (decl_or_origin
, var_die
);
18807 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
18808 decl
== NULL
, DW_AT_location
);
18809 add_pubname (decl_or_origin
, var_die
);
18812 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
18815 /* Generate a DIE to represent a named constant. */
18818 gen_const_die (tree decl
, dw_die_ref context_die
)
18820 dw_die_ref const_die
;
18821 tree type
= TREE_TYPE (decl
);
18823 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
18824 add_name_and_src_coords_attributes (const_die
, decl
);
18825 add_type_attribute (const_die
, type
, 1, 0, context_die
);
18826 if (TREE_PUBLIC (decl
))
18827 add_AT_flag (const_die
, DW_AT_external
, 1);
18828 if (DECL_ARTIFICIAL (decl
))
18829 add_AT_flag (const_die
, DW_AT_artificial
, 1);
18830 tree_add_const_value_attribute_for_decl (const_die
, decl
);
18833 /* Generate a DIE to represent a label identifier. */
18836 gen_label_die (tree decl
, dw_die_ref context_die
)
18838 tree origin
= decl_ultimate_origin (decl
);
18839 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
18841 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
18843 if (origin
!= NULL
)
18844 add_abstract_origin_attribute (lbl_die
, origin
);
18846 add_name_and_src_coords_attributes (lbl_die
, decl
);
18848 if (DECL_ABSTRACT (decl
))
18849 equate_decl_number_to_die (decl
, lbl_die
);
18852 insn
= DECL_RTL_IF_SET (decl
);
18854 /* Deleted labels are programmer specified labels which have been
18855 eliminated because of various optimizations. We still emit them
18856 here so that it is possible to put breakpoints on them. */
18860 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
18862 /* When optimization is enabled (via -O) some parts of the compiler
18863 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
18864 represent source-level labels which were explicitly declared by
18865 the user. This really shouldn't be happening though, so catch
18866 it if it ever does happen. */
18867 gcc_assert (!INSN_DELETED_P (insn
));
18869 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
18870 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
18874 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
18875 && CODE_LABEL_NUMBER (insn
) != -1)
18877 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
18878 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
18883 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
18884 attributes to the DIE for a block STMT, to describe where the inlined
18885 function was called from. This is similar to add_src_coords_attributes. */
18888 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
18890 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
18892 if (dwarf_version
>= 3 || !dwarf_strict
)
18894 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
18895 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
18900 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
18901 Add low_pc and high_pc attributes to the DIE for a block STMT. */
18904 add_high_low_attributes (tree stmt
, dw_die_ref die
)
18906 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
18908 if (BLOCK_FRAGMENT_CHAIN (stmt
)
18909 && (dwarf_version
>= 3 || !dwarf_strict
))
18911 tree chain
, superblock
= NULL_TREE
;
18913 dw_attr_ref attr
= NULL
;
18915 if (inlined_function_outer_scope_p (stmt
))
18917 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
18918 BLOCK_NUMBER (stmt
));
18919 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
18922 /* Optimize duplicate .debug_ranges lists or even tails of
18923 lists. If this BLOCK has same ranges as its supercontext,
18924 lookup DW_AT_ranges attribute in the supercontext (and
18925 recursively so), verify that the ranges_table contains the
18926 right values and use it instead of adding a new .debug_range. */
18927 for (chain
= stmt
, pdie
= die
;
18928 BLOCK_SAME_RANGE (chain
);
18929 chain
= BLOCK_SUPERCONTEXT (chain
))
18931 dw_attr_ref new_attr
;
18933 pdie
= pdie
->die_parent
;
18936 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
18938 new_attr
= get_AT (pdie
, DW_AT_ranges
);
18939 if (new_attr
== NULL
18940 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
18943 superblock
= BLOCK_SUPERCONTEXT (chain
);
18946 && (ranges_table
[attr
->dw_attr_val
.v
.val_offset
18947 / 2 / DWARF2_ADDR_SIZE
].num
18948 == BLOCK_NUMBER (superblock
))
18949 && BLOCK_FRAGMENT_CHAIN (superblock
))
18951 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
18952 / 2 / DWARF2_ADDR_SIZE
;
18953 unsigned long supercnt
= 0, thiscnt
= 0;
18954 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
18955 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
18958 gcc_checking_assert (ranges_table
[off
+ supercnt
].num
18959 == BLOCK_NUMBER (chain
));
18961 gcc_checking_assert (ranges_table
[off
+ supercnt
+ 1].num
== 0);
18962 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
18963 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
18965 gcc_assert (supercnt
>= thiscnt
);
18966 add_AT_range_list (die
, DW_AT_ranges
,
18967 ((off
+ supercnt
- thiscnt
)
18968 * 2 * DWARF2_ADDR_SIZE
),
18973 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
), false);
18975 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
18978 add_ranges (chain
);
18979 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
18986 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
18987 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
18988 BLOCK_NUMBER (stmt
));
18989 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
18990 BLOCK_NUMBER (stmt
));
18991 add_AT_low_high_pc (die
, label
, label_high
, false);
18995 /* Generate a DIE for a lexical block. */
18998 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19000 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
19002 if (call_arg_locations
)
19004 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19005 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19006 block_map
[BLOCK_NUMBER (stmt
)] = stmt_die
;
19009 if (! BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
19010 add_high_low_attributes (stmt
, stmt_die
);
19012 decls_for_scope (stmt
, stmt_die
, depth
);
19015 /* Generate a DIE for an inlined subprogram. */
19018 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
19022 /* The instance of function that is effectively being inlined shall not
19024 gcc_assert (! BLOCK_ABSTRACT (stmt
));
19026 decl
= block_ultimate_origin (stmt
);
19028 /* Emit info for the abstract instance first, if we haven't yet. We
19029 must emit this even if the block is abstract, otherwise when we
19030 emit the block below (or elsewhere), we may end up trying to emit
19031 a die whose origin die hasn't been emitted, and crashing. */
19032 dwarf2out_abstract_function (decl
);
19034 if (! BLOCK_ABSTRACT (stmt
))
19036 dw_die_ref subr_die
19037 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
19039 if (call_arg_locations
)
19041 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19042 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19043 block_map
[BLOCK_NUMBER (stmt
)] = subr_die
;
19045 add_abstract_origin_attribute (subr_die
, decl
);
19046 if (TREE_ASM_WRITTEN (stmt
))
19047 add_high_low_attributes (stmt
, subr_die
);
19048 add_call_src_coords_attributes (stmt
, subr_die
);
19050 decls_for_scope (stmt
, subr_die
, depth
);
19051 current_function_has_inlines
= 1;
19055 /* Generate a DIE for a field in a record, or structure. */
19058 gen_field_die (tree decl
, dw_die_ref context_die
)
19060 dw_die_ref decl_die
;
19062 if (TREE_TYPE (decl
) == error_mark_node
)
19065 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
19066 add_name_and_src_coords_attributes (decl_die
, decl
);
19067 add_type_attribute (decl_die
, member_declared_type (decl
),
19068 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
19071 if (DECL_BIT_FIELD_TYPE (decl
))
19073 add_byte_size_attribute (decl_die
, decl
);
19074 add_bit_size_attribute (decl_die
, decl
);
19075 add_bit_offset_attribute (decl_die
, decl
);
19078 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
19079 add_data_member_location_attribute (decl_die
, decl
);
19081 if (DECL_ARTIFICIAL (decl
))
19082 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
19084 add_accessibility_attribute (decl_die
, decl
);
19086 /* Equate decl number to die, so that we can look up this decl later on. */
19087 equate_decl_number_to_die (decl
, decl_die
);
19091 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19092 Use modified_type_die instead.
19093 We keep this code here just in case these types of DIEs may be needed to
19094 represent certain things in other languages (e.g. Pascal) someday. */
19097 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
19100 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
19102 equate_type_number_to_die (type
, ptr_die
);
19103 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19104 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19107 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19108 Use modified_type_die instead.
19109 We keep this code here just in case these types of DIEs may be needed to
19110 represent certain things in other languages (e.g. Pascal) someday. */
19113 gen_reference_type_die (tree type
, dw_die_ref context_die
)
19115 dw_die_ref ref_die
, scope_die
= scope_die_for (type
, context_die
);
19117 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
19118 ref_die
= new_die (DW_TAG_rvalue_reference_type
, scope_die
, type
);
19120 ref_die
= new_die (DW_TAG_reference_type
, scope_die
, type
);
19122 equate_type_number_to_die (type
, ref_die
);
19123 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
19124 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19128 /* Generate a DIE for a pointer to a member type. */
19131 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
19134 = new_die (DW_TAG_ptr_to_member_type
,
19135 scope_die_for (type
, context_die
), type
);
19137 equate_type_number_to_die (type
, ptr_die
);
19138 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
19139 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
19140 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19143 typedef const char *dchar_p
; /* For DEF_VEC_P. */
19145 static char *producer_string
;
19147 /* Return a heap allocated producer string including command line options
19148 if -grecord-gcc-switches. */
19151 gen_producer_string (void)
19154 auto_vec
<dchar_p
> switches
;
19155 const char *language_string
= lang_hooks
.name
;
19156 char *producer
, *tail
;
19158 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
19159 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
19161 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
19162 switch (save_decoded_options
[j
].opt_index
)
19169 case OPT_auxbase_strip
:
19178 case OPT_SPECIAL_unknown
:
19179 case OPT_SPECIAL_ignore
:
19180 case OPT_SPECIAL_program_name
:
19181 case OPT_SPECIAL_input_file
:
19182 case OPT_grecord_gcc_switches
:
19183 case OPT_gno_record_gcc_switches
:
19184 case OPT__output_pch_
:
19185 case OPT_fdiagnostics_show_location_
:
19186 case OPT_fdiagnostics_show_option
:
19187 case OPT_fdiagnostics_show_caret
:
19188 case OPT_fdiagnostics_color_
:
19189 case OPT_fverbose_asm
:
19191 case OPT__sysroot_
:
19193 case OPT_nostdinc__
:
19194 /* Ignore these. */
19197 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
19198 & CL_NO_DWARF_RECORD
)
19200 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
19202 switch (save_decoded_options
[j
].canonical_option
[0][1])
19209 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
19216 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
19217 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
19221 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
19223 sprintf (tail
, "%s %s", language_string
, version_string
);
19226 FOR_EACH_VEC_ELT (switches
, j
, p
)
19230 memcpy (tail
+ 1, p
, len
);
19238 /* Generate the DIE for the compilation unit. */
19241 gen_compile_unit_die (const char *filename
)
19244 const char *language_string
= lang_hooks
.name
;
19247 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
19251 add_name_attribute (die
, filename
);
19252 /* Don't add cwd for <built-in>. */
19253 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
19254 add_comp_dir_attribute (die
);
19257 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
19259 /* If our producer is LTO try to figure out a common language to use
19260 from the global list of translation units. */
19261 if (strcmp (language_string
, "GNU GIMPLE") == 0)
19265 const char *common_lang
= NULL
;
19267 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
19269 if (!TRANSLATION_UNIT_LANGUAGE (t
))
19272 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
19273 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
19275 else if (strncmp (common_lang
, "GNU C", 5) == 0
19276 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
19277 /* Mixing C and C++ is ok, use C++ in that case. */
19278 common_lang
= "GNU C++";
19281 /* Fall back to C. */
19282 common_lang
= NULL
;
19288 language_string
= common_lang
;
19291 language
= DW_LANG_C89
;
19292 if (strcmp (language_string
, "GNU C++") == 0)
19293 language
= DW_LANG_C_plus_plus
;
19294 else if (strcmp (language_string
, "GNU F77") == 0)
19295 language
= DW_LANG_Fortran77
;
19296 else if (strcmp (language_string
, "GNU Pascal") == 0)
19297 language
= DW_LANG_Pascal83
;
19298 else if (dwarf_version
>= 3 || !dwarf_strict
)
19300 if (strcmp (language_string
, "GNU Ada") == 0)
19301 language
= DW_LANG_Ada95
;
19302 else if (strcmp (language_string
, "GNU Fortran") == 0)
19303 language
= DW_LANG_Fortran95
;
19304 else if (strcmp (language_string
, "GNU Java") == 0)
19305 language
= DW_LANG_Java
;
19306 else if (strcmp (language_string
, "GNU Objective-C") == 0)
19307 language
= DW_LANG_ObjC
;
19308 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
19309 language
= DW_LANG_ObjC_plus_plus
;
19310 else if (dwarf_version
>= 5 || !dwarf_strict
)
19312 if (strcmp (language_string
, "GNU Go") == 0)
19313 language
= DW_LANG_Go
;
19316 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
19317 else if (strcmp (language_string
, "GNU Fortran") == 0)
19318 language
= DW_LANG_Fortran90
;
19320 add_AT_unsigned (die
, DW_AT_language
, language
);
19324 case DW_LANG_Fortran77
:
19325 case DW_LANG_Fortran90
:
19326 case DW_LANG_Fortran95
:
19327 /* Fortran has case insensitive identifiers and the front-end
19328 lowercases everything. */
19329 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
19332 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19338 /* Generate the DIE for a base class. */
19341 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
19343 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
19345 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
19346 add_data_member_location_attribute (die
, binfo
);
19348 if (BINFO_VIRTUAL_P (binfo
))
19349 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
19351 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19352 children, otherwise the default is DW_ACCESS_public. In DWARF2
19353 the default has always been DW_ACCESS_private. */
19354 if (access
== access_public_node
)
19356 if (dwarf_version
== 2
19357 || context_die
->die_tag
== DW_TAG_class_type
)
19358 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19360 else if (access
== access_protected_node
)
19361 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19362 else if (dwarf_version
> 2
19363 && context_die
->die_tag
!= DW_TAG_class_type
)
19364 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19367 /* Generate a DIE for a class member. */
19370 gen_member_die (tree type
, dw_die_ref context_die
)
19373 tree binfo
= TYPE_BINFO (type
);
19376 /* If this is not an incomplete type, output descriptions of each of its
19377 members. Note that as we output the DIEs necessary to represent the
19378 members of this record or union type, we will also be trying to output
19379 DIEs to represent the *types* of those members. However the `type'
19380 function (above) will specifically avoid generating type DIEs for member
19381 types *within* the list of member DIEs for this (containing) type except
19382 for those types (of members) which are explicitly marked as also being
19383 members of this (containing) type themselves. The g++ front- end can
19384 force any given type to be treated as a member of some other (containing)
19385 type by setting the TYPE_CONTEXT of the given (member) type to point to
19386 the TREE node representing the appropriate (containing) type. */
19388 /* First output info about the base classes. */
19391 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
19395 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
19396 gen_inheritance_die (base
,
19397 (accesses
? (*accesses
)[i
] : access_public_node
),
19401 /* Now output info about the data members and type members. */
19402 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
19404 /* If we thought we were generating minimal debug info for TYPE
19405 and then changed our minds, some of the member declarations
19406 may have already been defined. Don't define them again, but
19407 do put them in the right order. */
19409 child
= lookup_decl_die (member
);
19411 splice_child_die (context_die
, child
);
19413 gen_decl_die (member
, NULL
, context_die
);
19416 /* Now output info about the function members (if any). */
19417 for (member
= TYPE_METHODS (type
); member
; member
= DECL_CHAIN (member
))
19419 /* Don't include clones in the member list. */
19420 if (DECL_ABSTRACT_ORIGIN (member
))
19423 child
= lookup_decl_die (member
);
19425 splice_child_die (context_die
, child
);
19427 gen_decl_die (member
, NULL
, context_die
);
19431 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19432 is set, we pretend that the type was never defined, so we only get the
19433 member DIEs needed by later specification DIEs. */
19436 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
19437 enum debug_info_usage usage
)
19439 dw_die_ref type_die
= lookup_type_die (type
);
19440 dw_die_ref scope_die
= 0;
19442 int complete
= (TYPE_SIZE (type
)
19443 && (! TYPE_STUB_DECL (type
)
19444 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
19445 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
19446 complete
= complete
&& should_emit_struct_debug (type
, usage
);
19448 if (type_die
&& ! complete
)
19451 if (TYPE_CONTEXT (type
) != NULL_TREE
19452 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19453 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
19456 scope_die
= scope_die_for (type
, context_die
);
19458 /* Generate child dies for template paramaters. */
19459 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
19460 schedule_generic_params_dies_gen (type
);
19462 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
19463 /* First occurrence of type or toplevel definition of nested class. */
19465 dw_die_ref old_die
= type_die
;
19467 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
19468 ? record_type_tag (type
) : DW_TAG_union_type
,
19470 equate_type_number_to_die (type
, type_die
);
19472 add_AT_specification (type_die
, old_die
);
19474 add_name_attribute (type_die
, type_tag (type
));
19477 remove_AT (type_die
, DW_AT_declaration
);
19479 /* If this type has been completed, then give it a byte_size attribute and
19480 then give a list of members. */
19481 if (complete
&& !ns_decl
)
19483 /* Prevent infinite recursion in cases where the type of some member of
19484 this type is expressed in terms of this type itself. */
19485 TREE_ASM_WRITTEN (type
) = 1;
19486 add_byte_size_attribute (type_die
, type
);
19487 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
19489 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
19490 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
19493 /* If the first reference to this type was as the return type of an
19494 inline function, then it may not have a parent. Fix this now. */
19495 if (type_die
->die_parent
== NULL
)
19496 add_child_die (scope_die
, type_die
);
19498 push_decl_scope (type
);
19499 gen_member_die (type
, type_die
);
19502 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
19503 if (TYPE_ARTIFICIAL (type
))
19504 add_AT_flag (type_die
, DW_AT_artificial
, 1);
19506 /* GNU extension: Record what type our vtable lives in. */
19507 if (TYPE_VFIELD (type
))
19509 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
19511 gen_type_die (vtype
, context_die
);
19512 add_AT_die_ref (type_die
, DW_AT_containing_type
,
19513 lookup_type_die (vtype
));
19518 add_AT_flag (type_die
, DW_AT_declaration
, 1);
19520 /* We don't need to do this for function-local types. */
19521 if (TYPE_STUB_DECL (type
)
19522 && ! decl_function_context (TYPE_STUB_DECL (type
)))
19523 vec_safe_push (incomplete_types
, type
);
19526 if (get_AT (type_die
, DW_AT_name
))
19527 add_pubtype (type
, type_die
);
19530 /* Generate a DIE for a subroutine _type_. */
19533 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
19535 tree return_type
= TREE_TYPE (type
);
19536 dw_die_ref subr_die
19537 = new_die (DW_TAG_subroutine_type
,
19538 scope_die_for (type
, context_die
), type
);
19540 equate_type_number_to_die (type
, subr_die
);
19541 add_prototyped_attribute (subr_die
, type
);
19542 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
19543 gen_formal_types_die (type
, subr_die
);
19545 if (get_AT (subr_die
, DW_AT_name
))
19546 add_pubtype (type
, subr_die
);
19549 /* Generate a DIE for a type definition. */
19552 gen_typedef_die (tree decl
, dw_die_ref context_die
)
19554 dw_die_ref type_die
;
19557 if (TREE_ASM_WRITTEN (decl
))
19560 TREE_ASM_WRITTEN (decl
) = 1;
19561 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
19562 origin
= decl_ultimate_origin (decl
);
19563 if (origin
!= NULL
)
19564 add_abstract_origin_attribute (type_die
, origin
);
19569 add_name_and_src_coords_attributes (type_die
, decl
);
19570 if (DECL_ORIGINAL_TYPE (decl
))
19572 type
= DECL_ORIGINAL_TYPE (decl
);
19574 gcc_assert (type
!= TREE_TYPE (decl
));
19575 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
19579 type
= TREE_TYPE (decl
);
19581 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19583 /* Here, we are in the case of decl being a typedef naming
19584 an anonymous type, e.g:
19585 typedef struct {...} foo;
19586 In that case TREE_TYPE (decl) is not a typedef variant
19587 type and TYPE_NAME of the anonymous type is set to the
19588 TYPE_DECL of the typedef. This construct is emitted by
19591 TYPE is the anonymous struct named by the typedef
19592 DECL. As we need the DW_AT_type attribute of the
19593 DW_TAG_typedef to point to the DIE of TYPE, let's
19594 generate that DIE right away. add_type_attribute
19595 called below will then pick (via lookup_type_die) that
19596 anonymous struct DIE. */
19597 if (!TREE_ASM_WRITTEN (type
))
19598 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
19600 /* This is a GNU Extension. We are adding a
19601 DW_AT_linkage_name attribute to the DIE of the
19602 anonymous struct TYPE. The value of that attribute
19603 is the name of the typedef decl naming the anonymous
19604 struct. This greatly eases the work of consumers of
19605 this debug info. */
19606 add_linkage_attr (lookup_type_die (type
), decl
);
19610 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
19611 TREE_THIS_VOLATILE (decl
), context_die
);
19613 if (is_naming_typedef_decl (decl
))
19614 /* We want that all subsequent calls to lookup_type_die with
19615 TYPE in argument yield the DW_TAG_typedef we have just
19617 equate_type_number_to_die (type
, type_die
);
19619 add_accessibility_attribute (type_die
, decl
);
19622 if (DECL_ABSTRACT (decl
))
19623 equate_decl_number_to_die (decl
, type_die
);
19625 if (get_AT (type_die
, DW_AT_name
))
19626 add_pubtype (decl
, type_die
);
19629 /* Generate a DIE for a struct, class, enum or union type. */
19632 gen_tagged_type_die (tree type
,
19633 dw_die_ref context_die
,
19634 enum debug_info_usage usage
)
19638 if (type
== NULL_TREE
19639 || !is_tagged_type (type
))
19642 /* If this is a nested type whose containing class hasn't been written
19643 out yet, writing it out will cover this one, too. This does not apply
19644 to instantiations of member class templates; they need to be added to
19645 the containing class as they are generated. FIXME: This hurts the
19646 idea of combining type decls from multiple TUs, since we can't predict
19647 what set of template instantiations we'll get. */
19648 if (TYPE_CONTEXT (type
)
19649 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19650 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
19652 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
19654 if (TREE_ASM_WRITTEN (type
))
19657 /* If that failed, attach ourselves to the stub. */
19658 push_decl_scope (TYPE_CONTEXT (type
));
19659 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
19662 else if (TYPE_CONTEXT (type
) != NULL_TREE
19663 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
19665 /* If this type is local to a function that hasn't been written
19666 out yet, use a NULL context for now; it will be fixed up in
19667 decls_for_scope. */
19668 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
19669 /* A declaration DIE doesn't count; nested types need to go in the
19671 if (context_die
&& is_declaration_die (context_die
))
19672 context_die
= NULL
;
19677 context_die
= declare_in_namespace (type
, context_die
);
19681 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
19683 /* This might have been written out by the call to
19684 declare_in_namespace. */
19685 if (!TREE_ASM_WRITTEN (type
))
19686 gen_enumeration_type_die (type
, context_die
);
19689 gen_struct_or_union_type_die (type
, context_die
, usage
);
19694 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
19695 it up if it is ever completed. gen_*_type_die will set it for us
19696 when appropriate. */
19699 /* Generate a type description DIE. */
19702 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
19703 enum debug_info_usage usage
)
19705 struct array_descr_info info
;
19707 if (type
== NULL_TREE
|| type
== error_mark_node
)
19710 if (TYPE_NAME (type
) != NULL_TREE
19711 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
19712 && is_redundant_typedef (TYPE_NAME (type
))
19713 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
19714 /* The DECL of this type is a typedef we don't want to emit debug
19715 info for but we want debug info for its underlying typedef.
19716 This can happen for e.g, the injected-class-name of a C++
19718 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
19720 /* If TYPE is a typedef type variant, let's generate debug info
19721 for the parent typedef which TYPE is a type of. */
19722 if (typedef_variant_p (type
))
19724 if (TREE_ASM_WRITTEN (type
))
19727 /* Prevent broken recursion; we can't hand off to the same type. */
19728 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
19730 /* Give typedefs the right scope. */
19731 context_die
= scope_die_for (type
, context_die
);
19733 TREE_ASM_WRITTEN (type
) = 1;
19735 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19739 /* If type is an anonymous tagged type named by a typedef, let's
19740 generate debug info for the typedef. */
19741 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19743 /* Use the DIE of the containing namespace as the parent DIE of
19744 the type description DIE we want to generate. */
19745 if (DECL_CONTEXT (TYPE_NAME (type
))
19746 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
19747 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
19749 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19753 /* If this is an array type with hidden descriptor, handle it first. */
19754 if (!TREE_ASM_WRITTEN (type
)
19755 && lang_hooks
.types
.get_array_descr_info
19756 && lang_hooks
.types
.get_array_descr_info (type
, &info
)
19757 && (dwarf_version
>= 3 || !dwarf_strict
))
19759 gen_descr_array_type_die (type
, &info
, context_die
);
19760 TREE_ASM_WRITTEN (type
) = 1;
19764 /* We are going to output a DIE to represent the unqualified version
19765 of this type (i.e. without any const or volatile qualifiers) so
19766 get the main variant (i.e. the unqualified version) of this type
19767 now. (Vectors are special because the debugging info is in the
19768 cloned type itself). */
19769 if (TREE_CODE (type
) != VECTOR_TYPE
)
19770 type
= type_main_variant (type
);
19772 if (TREE_ASM_WRITTEN (type
))
19775 switch (TREE_CODE (type
))
19781 case REFERENCE_TYPE
:
19782 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
19783 ensures that the gen_type_die recursion will terminate even if the
19784 type is recursive. Recursive types are possible in Ada. */
19785 /* ??? We could perhaps do this for all types before the switch
19787 TREE_ASM_WRITTEN (type
) = 1;
19789 /* For these types, all that is required is that we output a DIE (or a
19790 set of DIEs) to represent the "basis" type. */
19791 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19792 DINFO_USAGE_IND_USE
);
19796 /* This code is used for C++ pointer-to-data-member types.
19797 Output a description of the relevant class type. */
19798 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
19799 DINFO_USAGE_IND_USE
);
19801 /* Output a description of the type of the object pointed to. */
19802 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19803 DINFO_USAGE_IND_USE
);
19805 /* Now output a DIE to represent this pointer-to-data-member type
19807 gen_ptr_to_mbr_type_die (type
, context_die
);
19810 case FUNCTION_TYPE
:
19811 /* Force out return type (in case it wasn't forced out already). */
19812 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19813 DINFO_USAGE_DIR_USE
);
19814 gen_subroutine_type_die (type
, context_die
);
19818 /* Force out return type (in case it wasn't forced out already). */
19819 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19820 DINFO_USAGE_DIR_USE
);
19821 gen_subroutine_type_die (type
, context_die
);
19825 gen_array_type_die (type
, context_die
);
19829 gen_array_type_die (type
, context_die
);
19832 case ENUMERAL_TYPE
:
19835 case QUAL_UNION_TYPE
:
19836 gen_tagged_type_die (type
, context_die
, usage
);
19842 case FIXED_POINT_TYPE
:
19845 /* No DIEs needed for fundamental types. */
19850 /* Just use DW_TAG_unspecified_type. */
19852 dw_die_ref type_die
= lookup_type_die (type
);
19853 if (type_die
== NULL
)
19855 tree name
= TYPE_IDENTIFIER (type
);
19856 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
19858 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
19859 equate_type_number_to_die (type
, type_die
);
19865 if (is_cxx_auto (type
))
19867 tree name
= TYPE_IDENTIFIER (type
);
19868 dw_die_ref
*die
= (name
== get_identifier ("auto")
19869 ? &auto_die
: &decltype_auto_die
);
19872 *die
= new_die (DW_TAG_unspecified_type
,
19873 comp_unit_die (), NULL_TREE
);
19874 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
19876 equate_type_number_to_die (type
, *die
);
19879 gcc_unreachable ();
19882 TREE_ASM_WRITTEN (type
) = 1;
19886 gen_type_die (tree type
, dw_die_ref context_die
)
19888 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
19891 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
19892 things which are local to the given block. */
19895 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19897 int must_output_die
= 0;
19900 /* Ignore blocks that are NULL. */
19901 if (stmt
== NULL_TREE
)
19904 inlined_func
= inlined_function_outer_scope_p (stmt
);
19906 /* If the block is one fragment of a non-contiguous block, do not
19907 process the variables, since they will have been done by the
19908 origin block. Do process subblocks. */
19909 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
19913 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
19914 gen_block_die (sub
, context_die
, depth
+ 1);
19919 /* Determine if we need to output any Dwarf DIEs at all to represent this
19922 /* The outer scopes for inlinings *must* always be represented. We
19923 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
19924 must_output_die
= 1;
19927 /* Determine if this block directly contains any "significant"
19928 local declarations which we will need to output DIEs for. */
19929 if (debug_info_level
> DINFO_LEVEL_TERSE
)
19930 /* We are not in terse mode so *any* local declaration counts
19931 as being a "significant" one. */
19932 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
19933 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
19934 && (TREE_USED (stmt
)
19935 || TREE_ASM_WRITTEN (stmt
)
19936 || BLOCK_ABSTRACT (stmt
)));
19937 else if ((TREE_USED (stmt
)
19938 || TREE_ASM_WRITTEN (stmt
)
19939 || BLOCK_ABSTRACT (stmt
))
19940 && !dwarf2out_ignore_block (stmt
))
19941 must_output_die
= 1;
19944 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
19945 DIE for any block which contains no significant local declarations at
19946 all. Rather, in such cases we just call `decls_for_scope' so that any
19947 needed Dwarf info for any sub-blocks will get properly generated. Note
19948 that in terse mode, our definition of what constitutes a "significant"
19949 local declaration gets restricted to include only inlined function
19950 instances and local (nested) function definitions. */
19951 if (must_output_die
)
19955 /* If STMT block is abstract, that means we have been called
19956 indirectly from dwarf2out_abstract_function.
19957 That function rightfully marks the descendent blocks (of
19958 the abstract function it is dealing with) as being abstract,
19959 precisely to prevent us from emitting any
19960 DW_TAG_inlined_subroutine DIE as a descendent
19961 of an abstract function instance. So in that case, we should
19962 not call gen_inlined_subroutine_die.
19964 Later though, when cgraph asks dwarf2out to emit info
19965 for the concrete instance of the function decl into which
19966 the concrete instance of STMT got inlined, the later will lead
19967 to the generation of a DW_TAG_inlined_subroutine DIE. */
19968 if (! BLOCK_ABSTRACT (stmt
))
19969 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
19972 gen_lexical_block_die (stmt
, context_die
, depth
);
19975 decls_for_scope (stmt
, context_die
, depth
);
19978 /* Process variable DECL (or variable with origin ORIGIN) within
19979 block STMT and add it to CONTEXT_DIE. */
19981 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
19984 tree decl_or_origin
= decl
? decl
: origin
;
19986 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
19987 die
= lookup_decl_die (decl_or_origin
);
19988 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
19989 && TYPE_DECL_IS_STUB (decl_or_origin
))
19990 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
19994 if (die
!= NULL
&& die
->die_parent
== NULL
)
19995 add_child_die (context_die
, die
);
19996 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
19997 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
19998 stmt
, context_die
);
20000 gen_decl_die (decl
, origin
, context_die
);
20003 /* Generate all of the decls declared within a given scope and (recursively)
20004 all of its sub-blocks. */
20007 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
20013 /* Ignore NULL blocks. */
20014 if (stmt
== NULL_TREE
)
20017 /* Output the DIEs to represent all of the data objects and typedefs
20018 declared directly within this block but not within any nested
20019 sub-blocks. Also, nested function and tag DIEs have been
20020 generated with a parent of NULL; fix that up now. We don't
20021 have to do this if we're at -g1. */
20022 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20024 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
20025 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
20026 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
20027 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
20031 /* Even if we're at -g1, we need to process the subblocks in order to get
20032 inlined call information. */
20034 /* Output the DIEs to represent all sub-blocks (and the items declared
20035 therein) of this block. */
20036 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
20038 subblocks
= BLOCK_CHAIN (subblocks
))
20039 gen_block_die (subblocks
, context_die
, depth
+ 1);
20042 /* Is this a typedef we can avoid emitting? */
20045 is_redundant_typedef (const_tree decl
)
20047 if (TYPE_DECL_IS_STUB (decl
))
20050 if (DECL_ARTIFICIAL (decl
)
20051 && DECL_CONTEXT (decl
)
20052 && is_tagged_type (DECL_CONTEXT (decl
))
20053 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
20054 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
20055 /* Also ignore the artificial member typedef for the class name. */
20061 /* Return TRUE if TYPE is a typedef that names a type for linkage
20062 purposes. This kind of typedefs is produced by the C++ FE for
20065 typedef struct {...} foo;
20067 In that case, there is no typedef variant type produced for foo.
20068 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20072 is_naming_typedef_decl (const_tree decl
)
20074 if (decl
== NULL_TREE
20075 || TREE_CODE (decl
) != TYPE_DECL
20076 || !is_tagged_type (TREE_TYPE (decl
))
20077 || DECL_IS_BUILTIN (decl
)
20078 || is_redundant_typedef (decl
)
20079 /* It looks like Ada produces TYPE_DECLs that are very similar
20080 to C++ naming typedefs but that have different
20081 semantics. Let's be specific to c++ for now. */
20085 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
20086 && TYPE_NAME (TREE_TYPE (decl
)) == decl
20087 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
20088 != TYPE_NAME (TREE_TYPE (decl
))));
20091 /* Returns the DIE for a context. */
20093 static inline dw_die_ref
20094 get_context_die (tree context
)
20098 /* Find die that represents this context. */
20099 if (TYPE_P (context
))
20101 context
= TYPE_MAIN_VARIANT (context
);
20102 return strip_naming_typedef (context
, force_type_die (context
));
20105 return force_decl_die (context
);
20107 return comp_unit_die ();
20110 /* Returns the DIE for decl. A DIE will always be returned. */
20113 force_decl_die (tree decl
)
20115 dw_die_ref decl_die
;
20116 unsigned saved_external_flag
;
20117 tree save_fn
= NULL_TREE
;
20118 decl_die
= lookup_decl_die (decl
);
20121 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
20123 decl_die
= lookup_decl_die (decl
);
20127 switch (TREE_CODE (decl
))
20129 case FUNCTION_DECL
:
20130 /* Clear current_function_decl, so that gen_subprogram_die thinks
20131 that this is a declaration. At this point, we just want to force
20132 declaration die. */
20133 save_fn
= current_function_decl
;
20134 current_function_decl
= NULL_TREE
;
20135 gen_subprogram_die (decl
, context_die
);
20136 current_function_decl
= save_fn
;
20140 /* Set external flag to force declaration die. Restore it after
20141 gen_decl_die() call. */
20142 saved_external_flag
= DECL_EXTERNAL (decl
);
20143 DECL_EXTERNAL (decl
) = 1;
20144 gen_decl_die (decl
, NULL
, context_die
);
20145 DECL_EXTERNAL (decl
) = saved_external_flag
;
20148 case NAMESPACE_DECL
:
20149 if (dwarf_version
>= 3 || !dwarf_strict
)
20150 dwarf2out_decl (decl
);
20152 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20153 decl_die
= comp_unit_die ();
20156 case TRANSLATION_UNIT_DECL
:
20157 decl_die
= comp_unit_die ();
20161 gcc_unreachable ();
20164 /* We should be able to find the DIE now. */
20166 decl_die
= lookup_decl_die (decl
);
20167 gcc_assert (decl_die
);
20173 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20174 always returned. */
20177 force_type_die (tree type
)
20179 dw_die_ref type_die
;
20181 type_die
= lookup_type_die (type
);
20184 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
20186 type_die
= modified_type_die (type
, TYPE_READONLY (type
),
20187 TYPE_VOLATILE (type
), context_die
);
20188 gcc_assert (type_die
);
20193 /* Force out any required namespaces to be able to output DECL,
20194 and return the new context_die for it, if it's changed. */
20197 setup_namespace_context (tree thing
, dw_die_ref context_die
)
20199 tree context
= (DECL_P (thing
)
20200 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
20201 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
20202 /* Force out the namespace. */
20203 context_die
= force_decl_die (context
);
20205 return context_die
;
20208 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20209 type) within its namespace, if appropriate.
20211 For compatibility with older debuggers, namespace DIEs only contain
20212 declarations; all definitions are emitted at CU scope. */
20215 declare_in_namespace (tree thing
, dw_die_ref context_die
)
20217 dw_die_ref ns_context
;
20219 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20220 return context_die
;
20222 /* If this decl is from an inlined function, then don't try to emit it in its
20223 namespace, as we will get confused. It would have already been emitted
20224 when the abstract instance of the inline function was emitted anyways. */
20225 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
20226 return context_die
;
20228 ns_context
= setup_namespace_context (thing
, context_die
);
20230 if (ns_context
!= context_die
)
20234 if (DECL_P (thing
))
20235 gen_decl_die (thing
, NULL
, ns_context
);
20237 gen_type_die (thing
, ns_context
);
20239 return context_die
;
20242 /* Generate a DIE for a namespace or namespace alias. */
20245 gen_namespace_die (tree decl
, dw_die_ref context_die
)
20247 dw_die_ref namespace_die
;
20249 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20250 they are an alias of. */
20251 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
20253 /* Output a real namespace or module. */
20254 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20255 namespace_die
= new_die (is_fortran ()
20256 ? DW_TAG_module
: DW_TAG_namespace
,
20257 context_die
, decl
);
20258 /* For Fortran modules defined in different CU don't add src coords. */
20259 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
20261 const char *name
= dwarf2_name (decl
, 0);
20263 add_name_attribute (namespace_die
, name
);
20266 add_name_and_src_coords_attributes (namespace_die
, decl
);
20267 if (DECL_EXTERNAL (decl
))
20268 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
20269 equate_decl_number_to_die (decl
, namespace_die
);
20273 /* Output a namespace alias. */
20275 /* Force out the namespace we are an alias of, if necessary. */
20276 dw_die_ref origin_die
20277 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
20279 if (DECL_FILE_SCOPE_P (decl
)
20280 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
20281 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20282 /* Now create the namespace alias DIE. */
20283 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
20284 add_name_and_src_coords_attributes (namespace_die
, decl
);
20285 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
20286 equate_decl_number_to_die (decl
, namespace_die
);
20288 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
20289 if (want_pubnames ())
20290 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
20293 /* Generate Dwarf debug information for a decl described by DECL.
20294 The return value is currently only meaningful for PARM_DECLs,
20295 for all other decls it returns NULL. */
20298 gen_decl_die (tree decl
, tree origin
, dw_die_ref context_die
)
20300 tree decl_or_origin
= decl
? decl
: origin
;
20301 tree class_origin
= NULL
, ultimate_origin
;
20303 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
20306 switch (TREE_CODE (decl_or_origin
))
20312 if (!is_fortran () && !is_ada ())
20314 /* The individual enumerators of an enum type get output when we output
20315 the Dwarf representation of the relevant enum type itself. */
20319 /* Emit its type. */
20320 gen_type_die (TREE_TYPE (decl
), context_die
);
20322 /* And its containing namespace. */
20323 context_die
= declare_in_namespace (decl
, context_die
);
20325 gen_const_die (decl
, context_die
);
20328 case FUNCTION_DECL
:
20329 /* Don't output any DIEs to represent mere function declarations,
20330 unless they are class members or explicit block externs. */
20331 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
20332 && DECL_FILE_SCOPE_P (decl_or_origin
)
20333 && (current_function_decl
== NULL_TREE
20334 || DECL_ARTIFICIAL (decl_or_origin
)))
20339 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20340 on local redeclarations of global functions. That seems broken. */
20341 if (current_function_decl
!= decl
)
20342 /* This is only a declaration. */;
20345 /* If we're emitting a clone, emit info for the abstract instance. */
20346 if (origin
|| DECL_ORIGIN (decl
) != decl
)
20347 dwarf2out_abstract_function (origin
20348 ? DECL_ORIGIN (origin
)
20349 : DECL_ABSTRACT_ORIGIN (decl
));
20351 /* If we're emitting an out-of-line copy of an inline function,
20352 emit info for the abstract instance and set up to refer to it. */
20353 else if (cgraph_function_possibly_inlined_p (decl
)
20354 && ! DECL_ABSTRACT (decl
)
20355 && ! class_or_namespace_scope_p (context_die
)
20356 /* dwarf2out_abstract_function won't emit a die if this is just
20357 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20358 that case, because that works only if we have a die. */
20359 && DECL_INITIAL (decl
) != NULL_TREE
)
20361 dwarf2out_abstract_function (decl
);
20362 set_decl_origin_self (decl
);
20365 /* Otherwise we're emitting the primary DIE for this decl. */
20366 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
20368 /* Before we describe the FUNCTION_DECL itself, make sure that we
20369 have its containing type. */
20371 origin
= decl_class_context (decl
);
20372 if (origin
!= NULL_TREE
)
20373 gen_type_die (origin
, context_die
);
20375 /* And its return type. */
20376 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
20378 /* And its virtual context. */
20379 if (DECL_VINDEX (decl
) != NULL_TREE
)
20380 gen_type_die (DECL_CONTEXT (decl
), context_die
);
20382 /* Make sure we have a member DIE for decl. */
20383 if (origin
!= NULL_TREE
)
20384 gen_type_die_for_member (origin
, decl
, context_die
);
20386 /* And its containing namespace. */
20387 context_die
= declare_in_namespace (decl
, context_die
);
20390 /* Now output a DIE to represent the function itself. */
20392 gen_subprogram_die (decl
, context_die
);
20396 /* If we are in terse mode, don't generate any DIEs to represent any
20397 actual typedefs. */
20398 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20401 /* In the special case of a TYPE_DECL node representing the declaration
20402 of some type tag, if the given TYPE_DECL is marked as having been
20403 instantiated from some other (original) TYPE_DECL node (e.g. one which
20404 was generated within the original definition of an inline function) we
20405 used to generate a special (abbreviated) DW_TAG_structure_type,
20406 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20407 should be actually referencing those DIEs, as variable DIEs with that
20408 type would be emitted already in the abstract origin, so it was always
20409 removed during unused type prunning. Don't add anything in this
20411 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
20414 if (is_redundant_typedef (decl
))
20415 gen_type_die (TREE_TYPE (decl
), context_die
);
20417 /* Output a DIE to represent the typedef itself. */
20418 gen_typedef_die (decl
, context_die
);
20422 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
20423 gen_label_die (decl
, context_die
);
20428 /* If we are in terse mode, don't generate any DIEs to represent any
20429 variable declarations or definitions. */
20430 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20433 /* Output any DIEs that are needed to specify the type of this data
20435 if (decl_by_reference_p (decl_or_origin
))
20436 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20438 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20440 /* And its containing type. */
20441 class_origin
= decl_class_context (decl_or_origin
);
20442 if (class_origin
!= NULL_TREE
)
20443 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
20445 /* And its containing namespace. */
20446 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
20448 /* Now output the DIE to represent the data object itself. This gets
20449 complicated because of the possibility that the VAR_DECL really
20450 represents an inlined instance of a formal parameter for an inline
20452 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
20453 if (ultimate_origin
!= NULL_TREE
20454 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
20455 gen_formal_parameter_die (decl
, origin
,
20456 true /* Emit name attribute. */,
20459 gen_variable_die (decl
, origin
, context_die
);
20463 /* Ignore the nameless fields that are used to skip bits but handle C++
20464 anonymous unions and structs. */
20465 if (DECL_NAME (decl
) != NULL_TREE
20466 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
20467 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
20469 gen_type_die (member_declared_type (decl
), context_die
);
20470 gen_field_die (decl
, context_die
);
20475 if (DECL_BY_REFERENCE (decl_or_origin
))
20476 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20478 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20479 return gen_formal_parameter_die (decl
, origin
,
20480 true /* Emit name attribute. */,
20483 case NAMESPACE_DECL
:
20484 case IMPORTED_DECL
:
20485 if (dwarf_version
>= 3 || !dwarf_strict
)
20486 gen_namespace_die (decl
, context_die
);
20489 case NAMELIST_DECL
:
20490 gen_namelist_decl (DECL_NAME (decl
), context_die
,
20491 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
20495 /* Probably some frontend-internal decl. Assume we don't care. */
20496 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
20503 /* Output debug information for global decl DECL. Called from toplev.c after
20504 compilation proper has finished. */
20507 dwarf2out_global_decl (tree decl
)
20509 /* Output DWARF2 information for file-scope tentative data object
20510 declarations, file-scope (extern) function declarations (which
20511 had no corresponding body) and file-scope tagged type declarations
20512 and definitions which have not yet been forced out. */
20513 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
20514 dwarf2out_decl (decl
);
20517 /* Output debug information for type decl DECL. Called from toplev.c
20518 and from language front ends (to record built-in types). */
20520 dwarf2out_type_decl (tree decl
, int local
)
20523 dwarf2out_decl (decl
);
20526 /* Output debug information for imported module or decl DECL.
20527 NAME is non-NULL name in the lexical block if the decl has been renamed.
20528 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
20529 that DECL belongs to.
20530 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
20532 dwarf2out_imported_module_or_decl_1 (tree decl
,
20534 tree lexical_block
,
20535 dw_die_ref lexical_block_die
)
20537 expanded_location xloc
;
20538 dw_die_ref imported_die
= NULL
;
20539 dw_die_ref at_import_die
;
20541 if (TREE_CODE (decl
) == IMPORTED_DECL
)
20543 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
20544 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
20548 xloc
= expand_location (input_location
);
20550 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
20552 at_import_die
= force_type_die (TREE_TYPE (decl
));
20553 /* For namespace N { typedef void T; } using N::T; base_type_die
20554 returns NULL, but DW_TAG_imported_declaration requires
20555 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
20556 if (!at_import_die
)
20558 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
20559 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
20560 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
20561 gcc_assert (at_import_die
);
20566 at_import_die
= lookup_decl_die (decl
);
20567 if (!at_import_die
)
20569 /* If we're trying to avoid duplicate debug info, we may not have
20570 emitted the member decl for this field. Emit it now. */
20571 if (TREE_CODE (decl
) == FIELD_DECL
)
20573 tree type
= DECL_CONTEXT (decl
);
20575 if (TYPE_CONTEXT (type
)
20576 && TYPE_P (TYPE_CONTEXT (type
))
20577 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
20578 DINFO_USAGE_DIR_USE
))
20580 gen_type_die_for_member (type
, decl
,
20581 get_context_die (TYPE_CONTEXT (type
)));
20583 if (TREE_CODE (decl
) == NAMELIST_DECL
)
20584 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
20585 get_context_die (DECL_CONTEXT (decl
)),
20588 at_import_die
= force_decl_die (decl
);
20592 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
20594 if (dwarf_version
>= 3 || !dwarf_strict
)
20595 imported_die
= new_die (DW_TAG_imported_module
,
20602 imported_die
= new_die (DW_TAG_imported_declaration
,
20606 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
20607 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
20609 add_AT_string (imported_die
, DW_AT_name
,
20610 IDENTIFIER_POINTER (name
));
20611 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
20614 /* Output debug information for imported module or decl DECL.
20615 NAME is non-NULL name in context if the decl has been renamed.
20616 CHILD is true if decl is one of the renamed decls as part of
20617 importing whole module. */
20620 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
20623 /* dw_die_ref at_import_die; */
20624 dw_die_ref scope_die
;
20626 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20631 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
20632 We need decl DIE for reference and scope die. First, get DIE for the decl
20635 /* Get the scope die for decl context. Use comp_unit_die for global module
20636 or decl. If die is not found for non globals, force new die. */
20638 && TYPE_P (context
)
20639 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
20642 if (!(dwarf_version
>= 3 || !dwarf_strict
))
20645 scope_die
= get_context_die (context
);
20649 gcc_assert (scope_die
->die_child
);
20650 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
20651 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
20652 scope_die
= scope_die
->die_child
;
20655 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
20656 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
20660 /* Output debug information for namelists. */
20663 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
20665 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
20669 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20672 gcc_assert (scope_die
!= NULL
);
20673 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
20674 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
20676 /* If there are no item_decls, we have a nondefining namelist, e.g.
20677 with USE association; hence, set DW_AT_declaration. */
20678 if (item_decls
== NULL_TREE
)
20680 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
20684 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
20686 nml_item_ref_die
= lookup_decl_die (value
);
20687 if (!nml_item_ref_die
)
20688 nml_item_ref_die
= force_decl_die (value
);
20690 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
20691 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
20697 /* Write the debugging output for DECL. */
20700 dwarf2out_decl (tree decl
)
20702 dw_die_ref context_die
= comp_unit_die ();
20704 switch (TREE_CODE (decl
))
20709 case FUNCTION_DECL
:
20710 /* What we would really like to do here is to filter out all mere
20711 file-scope declarations of file-scope functions which are never
20712 referenced later within this translation unit (and keep all of ones
20713 that *are* referenced later on) but we aren't clairvoyant, so we have
20714 no idea which functions will be referenced in the future (i.e. later
20715 on within the current translation unit). So here we just ignore all
20716 file-scope function declarations which are not also definitions. If
20717 and when the debugger needs to know something about these functions,
20718 it will have to hunt around and find the DWARF information associated
20719 with the definition of the function.
20721 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
20722 nodes represent definitions and which ones represent mere
20723 declarations. We have to check DECL_INITIAL instead. That's because
20724 the C front-end supports some weird semantics for "extern inline"
20725 function definitions. These can get inlined within the current
20726 translation unit (and thus, we need to generate Dwarf info for their
20727 abstract instances so that the Dwarf info for the concrete inlined
20728 instances can have something to refer to) but the compiler never
20729 generates any out-of-lines instances of such things (despite the fact
20730 that they *are* definitions).
20732 The important point is that the C front-end marks these "extern
20733 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
20734 them anyway. Note that the C++ front-end also plays some similar games
20735 for inline function definitions appearing within include files which
20736 also contain `#pragma interface' pragmas.
20738 If we are called from dwarf2out_abstract_function output a DIE
20739 anyway. We can end up here this way with early inlining and LTO
20740 where the inlined function is output in a different LTRANS unit
20742 if (DECL_INITIAL (decl
) == NULL_TREE
20743 && ! DECL_ABSTRACT (decl
))
20746 /* If we're a nested function, initially use a parent of NULL; if we're
20747 a plain function, this will be fixed up in decls_for_scope. If
20748 we're a method, it will be ignored, since we already have a DIE. */
20749 if (decl_function_context (decl
)
20750 /* But if we're in terse mode, we don't care about scope. */
20751 && debug_info_level
> DINFO_LEVEL_TERSE
)
20752 context_die
= NULL
;
20756 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
20757 declaration and if the declaration was never even referenced from
20758 within this entire compilation unit. We suppress these DIEs in
20759 order to save space in the .debug section (by eliminating entries
20760 which are probably useless). Note that we must not suppress
20761 block-local extern declarations (whether used or not) because that
20762 would screw-up the debugger's name lookup mechanism and cause it to
20763 miss things which really ought to be in scope at a given point. */
20764 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
20767 /* For local statics lookup proper context die. */
20768 if (TREE_STATIC (decl
)
20769 && DECL_CONTEXT (decl
)
20770 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
20771 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20773 /* If we are in terse mode, don't generate any DIEs to represent any
20774 variable declarations or definitions. */
20775 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20780 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20782 if (!is_fortran () && !is_ada ())
20784 if (TREE_STATIC (decl
) && decl_function_context (decl
))
20785 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20788 case NAMESPACE_DECL
:
20789 case IMPORTED_DECL
:
20790 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20792 if (lookup_decl_die (decl
) != NULL
)
20797 /* Don't emit stubs for types unless they are needed by other DIEs. */
20798 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
20801 /* Don't bother trying to generate any DIEs to represent any of the
20802 normal built-in types for the language we are compiling. */
20803 if (DECL_IS_BUILTIN (decl
))
20806 /* If we are in terse mode, don't generate any DIEs for types. */
20807 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20810 /* If we're a function-scope tag, initially use a parent of NULL;
20811 this will be fixed up in decls_for_scope. */
20812 if (decl_function_context (decl
))
20813 context_die
= NULL
;
20817 case NAMELIST_DECL
:
20824 gen_decl_die (decl
, NULL
, context_die
);
20827 /* Write the debugging output for DECL. */
20830 dwarf2out_function_decl (tree decl
)
20832 dwarf2out_decl (decl
);
20833 call_arg_locations
= NULL
;
20834 call_arg_loc_last
= NULL
;
20835 call_site_count
= -1;
20836 tail_call_site_count
= -1;
20837 block_map
.release ();
20838 htab_empty (decl_loc_table
);
20839 htab_empty (cached_dw_loc_list_table
);
20842 /* Output a marker (i.e. a label) for the beginning of the generated code for
20843 a lexical block. */
20846 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
20847 unsigned int blocknum
)
20849 switch_to_section (current_function_section ());
20850 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
20853 /* Output a marker (i.e. a label) for the end of the generated code for a
20857 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
20859 switch_to_section (current_function_section ());
20860 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
20863 /* Returns nonzero if it is appropriate not to emit any debugging
20864 information for BLOCK, because it doesn't contain any instructions.
20866 Don't allow this for blocks with nested functions or local classes
20867 as we would end up with orphans, and in the presence of scheduling
20868 we may end up calling them anyway. */
20871 dwarf2out_ignore_block (const_tree block
)
20876 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
20877 if (TREE_CODE (decl
) == FUNCTION_DECL
20878 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
20880 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
20882 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
20883 if (TREE_CODE (decl
) == FUNCTION_DECL
20884 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
20891 /* Hash table routines for file_hash. */
20894 file_table_eq (const void *p1_p
, const void *p2_p
)
20896 const struct dwarf_file_data
*const p1
=
20897 (const struct dwarf_file_data
*) p1_p
;
20898 const char *const p2
= (const char *) p2_p
;
20899 return filename_cmp (p1
->filename
, p2
) == 0;
20903 file_table_hash (const void *p_p
)
20905 const struct dwarf_file_data
*const p
= (const struct dwarf_file_data
*) p_p
;
20906 return htab_hash_string (p
->filename
);
20909 /* Lookup FILE_NAME (in the list of filenames that we know about here in
20910 dwarf2out.c) and return its "index". The index of each (known) filename is
20911 just a unique number which is associated with only that one filename. We
20912 need such numbers for the sake of generating labels (in the .debug_sfnames
20913 section) and references to those files numbers (in the .debug_srcinfo
20914 and.debug_macinfo sections). If the filename given as an argument is not
20915 found in our current list, add it to the list and assign it the next
20916 available unique index number. In order to speed up searches, we remember
20917 the index of the filename was looked up last. This handles the majority of
20920 static struct dwarf_file_data
*
20921 lookup_filename (const char *file_name
)
20924 struct dwarf_file_data
* created
;
20926 /* Check to see if the file name that was searched on the previous
20927 call matches this file name. If so, return the index. */
20928 if (file_table_last_lookup
20929 && (file_name
== file_table_last_lookup
->filename
20930 || filename_cmp (file_table_last_lookup
->filename
, file_name
) == 0))
20931 return file_table_last_lookup
;
20933 /* Didn't match the previous lookup, search the table. */
20934 slot
= htab_find_slot_with_hash (file_table
, file_name
,
20935 htab_hash_string (file_name
), INSERT
);
20937 return (struct dwarf_file_data
*) *slot
;
20939 created
= ggc_alloc_dwarf_file_data ();
20940 created
->filename
= file_name
;
20941 created
->emitted_number
= 0;
20946 /* If the assembler will construct the file table, then translate the compiler
20947 internal file table number into the assembler file table number, and emit
20948 a .file directive if we haven't already emitted one yet. The file table
20949 numbers are different because we prune debug info for unused variables and
20950 types, which may include filenames. */
20953 maybe_emit_file (struct dwarf_file_data
* fd
)
20955 if (! fd
->emitted_number
)
20957 if (last_emitted_file
)
20958 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
20960 fd
->emitted_number
= 1;
20961 last_emitted_file
= fd
;
20963 if (DWARF2_ASM_LINE_DEBUG_INFO
)
20965 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
20966 output_quoted_string (asm_out_file
,
20967 remap_debug_filename (fd
->filename
));
20968 fputc ('\n', asm_out_file
);
20972 return fd
->emitted_number
;
20975 /* Schedule generation of a DW_AT_const_value attribute to DIE.
20976 That generation should happen after function debug info has been
20977 generated. The value of the attribute is the constant value of ARG. */
20980 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
20982 die_arg_entry entry
;
20987 if (!tmpl_value_parm_die_table
)
20988 vec_alloc (tmpl_value_parm_die_table
, 32);
20992 vec_safe_push (tmpl_value_parm_die_table
, entry
);
20995 /* Return TRUE if T is an instance of generic type, FALSE
20999 generic_type_p (tree t
)
21001 if (t
== NULL_TREE
|| !TYPE_P (t
))
21003 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
21006 /* Schedule the generation of the generic parameter dies for the
21007 instance of generic type T. The proper generation itself is later
21008 done by gen_scheduled_generic_parms_dies. */
21011 schedule_generic_params_dies_gen (tree t
)
21013 if (!generic_type_p (t
))
21016 if (!generic_type_instances
)
21017 vec_alloc (generic_type_instances
, 256);
21019 vec_safe_push (generic_type_instances
, t
);
21022 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21023 by append_entry_to_tmpl_value_parm_die_table. This function must
21024 be called after function DIEs have been generated. */
21027 gen_remaining_tmpl_value_param_die_attribute (void)
21029 if (tmpl_value_parm_die_table
)
21034 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
21035 tree_add_const_value_attribute (e
->die
, e
->arg
);
21039 /* Generate generic parameters DIEs for instances of generic types
21040 that have been previously scheduled by
21041 schedule_generic_params_dies_gen. This function must be called
21042 after all the types of the CU have been laid out. */
21045 gen_scheduled_generic_parms_dies (void)
21050 if (!generic_type_instances
)
21053 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
21054 if (COMPLETE_TYPE_P (t
))
21055 gen_generic_params_dies (t
);
21059 /* Replace DW_AT_name for the decl with name. */
21062 dwarf2out_set_name (tree decl
, tree name
)
21068 die
= TYPE_SYMTAB_DIE (decl
);
21072 dname
= dwarf2_name (name
, 0);
21076 attr
= get_AT (die
, DW_AT_name
);
21079 struct indirect_string_node
*node
;
21081 node
= find_AT_string (dname
);
21082 /* replace the string. */
21083 attr
->dw_attr_val
.v
.val_str
= node
;
21087 add_name_attribute (die
, dname
);
21090 /* True if before or during processing of the first function being emitted. */
21091 static bool in_first_function_p
= true;
21092 /* True if loc_note during dwarf2out_var_location call might still be
21093 before first real instruction at address equal to .Ltext0. */
21094 static bool maybe_at_text_label_p
= true;
21095 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
21096 static unsigned int first_loclabel_num_not_at_text_label
;
21098 /* Called by the final INSN scan whenever we see a var location. We
21099 use it to drop labels in the right places, and throw the location in
21100 our lookup table. */
21103 dwarf2out_var_location (rtx loc_note
)
21105 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
21106 struct var_loc_node
*newloc
;
21107 rtx next_real
, next_note
;
21108 static const char *last_label
;
21109 static const char *last_postcall_label
;
21110 static bool last_in_cold_section_p
;
21111 static rtx expected_next_loc_note
;
21115 if (!NOTE_P (loc_note
))
21117 if (CALL_P (loc_note
))
21120 if (SIBLING_CALL_P (loc_note
))
21121 tail_call_site_count
++;
21126 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
21127 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
21130 /* Optimize processing a large consecutive sequence of location
21131 notes so we don't spend too much time in next_real_insn. If the
21132 next insn is another location note, remember the next_real_insn
21133 calculation for next time. */
21134 next_real
= cached_next_real_insn
;
21137 if (expected_next_loc_note
!= loc_note
)
21138 next_real
= NULL_RTX
;
21141 next_note
= NEXT_INSN (loc_note
);
21143 || INSN_DELETED_P (next_note
)
21144 || ! NOTE_P (next_note
)
21145 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
21146 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
21147 next_note
= NULL_RTX
;
21150 next_real
= next_real_insn (loc_note
);
21154 expected_next_loc_note
= next_note
;
21155 cached_next_real_insn
= next_real
;
21158 cached_next_real_insn
= NULL_RTX
;
21160 /* If there are no instructions which would be affected by this note,
21161 don't do anything. */
21163 && next_real
== NULL_RTX
21164 && !NOTE_DURING_CALL_P (loc_note
))
21167 if (next_real
== NULL_RTX
)
21168 next_real
= get_last_insn ();
21170 /* If there were any real insns between note we processed last time
21171 and this note (or if it is the first note), clear
21172 last_{,postcall_}label so that they are not reused this time. */
21173 if (last_var_location_insn
== NULL_RTX
21174 || last_var_location_insn
!= next_real
21175 || last_in_cold_section_p
!= in_cold_section_p
)
21178 last_postcall_label
= NULL
;
21183 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
21184 newloc
= add_var_loc_to_decl (decl
, loc_note
,
21185 NOTE_DURING_CALL_P (loc_note
)
21186 ? last_postcall_label
: last_label
);
21187 if (newloc
== NULL
)
21196 /* If there were no real insns between note we processed last time
21197 and this note, use the label we emitted last time. Otherwise
21198 create a new label and emit it. */
21199 if (last_label
== NULL
)
21201 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
21202 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
21204 last_label
= ggc_strdup (loclabel
);
21205 /* See if loclabel might be equal to .Ltext0. If yes,
21206 bump first_loclabel_num_not_at_text_label. */
21207 if (!have_multiple_function_sections
21208 && in_first_function_p
21209 && maybe_at_text_label_p
)
21211 static rtx last_start
;
21213 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
21214 if (insn
== last_start
)
21216 else if (!NONDEBUG_INSN_P (insn
))
21220 rtx body
= PATTERN (insn
);
21221 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
21223 /* Inline asm could occupy zero bytes. */
21224 else if (GET_CODE (body
) == ASM_INPUT
21225 || asm_noperands (body
) >= 0)
21227 #ifdef HAVE_attr_length
21228 else if (get_attr_min_length (insn
) == 0)
21233 /* Assume insn has non-zero length. */
21234 maybe_at_text_label_p
= false;
21238 if (maybe_at_text_label_p
)
21240 last_start
= loc_note
;
21241 first_loclabel_num_not_at_text_label
= loclabel_num
;
21248 struct call_arg_loc_node
*ca_loc
21249 = ggc_alloc_cleared_call_arg_loc_node ();
21250 rtx prev
= prev_real_insn (loc_note
), x
;
21251 ca_loc
->call_arg_loc_note
= loc_note
;
21252 ca_loc
->next
= NULL
;
21253 ca_loc
->label
= last_label
;
21256 || (NONJUMP_INSN_P (prev
)
21257 && GET_CODE (PATTERN (prev
)) == SEQUENCE
21258 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
21259 if (!CALL_P (prev
))
21260 prev
= XVECEXP (PATTERN (prev
), 0, 0);
21261 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
21262 x
= get_call_rtx_from (PATTERN (prev
));
21265 x
= XEXP (XEXP (x
, 0), 0);
21266 if (GET_CODE (x
) == SYMBOL_REF
21267 && SYMBOL_REF_DECL (x
)
21268 && TREE_CODE (SYMBOL_REF_DECL (x
)) == FUNCTION_DECL
)
21269 ca_loc
->symbol_ref
= x
;
21271 ca_loc
->block
= insn_scope (prev
);
21272 if (call_arg_locations
)
21273 call_arg_loc_last
->next
= ca_loc
;
21275 call_arg_locations
= ca_loc
;
21276 call_arg_loc_last
= ca_loc
;
21278 else if (!NOTE_DURING_CALL_P (loc_note
))
21279 newloc
->label
= last_label
;
21282 if (!last_postcall_label
)
21284 sprintf (loclabel
, "%s-1", last_label
);
21285 last_postcall_label
= ggc_strdup (loclabel
);
21287 newloc
->label
= last_postcall_label
;
21290 last_var_location_insn
= next_real
;
21291 last_in_cold_section_p
= in_cold_section_p
;
21294 /* Note in one location list that text section has changed. */
21297 var_location_switch_text_section_1 (void **slot
, void *data ATTRIBUTE_UNUSED
)
21299 var_loc_list
*list
= (var_loc_list
*) *slot
;
21301 list
->last_before_switch
21302 = list
->last
->next
? list
->last
->next
: list
->last
;
21306 /* Note in all location lists that text section has changed. */
21309 var_location_switch_text_section (void)
21311 if (decl_loc_table
== NULL
)
21314 htab_traverse (decl_loc_table
, var_location_switch_text_section_1
, NULL
);
21317 /* Create a new line number table. */
21319 static dw_line_info_table
*
21320 new_line_info_table (void)
21322 dw_line_info_table
*table
;
21324 table
= ggc_alloc_cleared_dw_line_info_table_struct ();
21325 table
->file_num
= 1;
21326 table
->line_num
= 1;
21327 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
21332 /* Lookup the "current" table into which we emit line info, so
21333 that we don't have to do it for every source line. */
21336 set_cur_line_info_table (section
*sec
)
21338 dw_line_info_table
*table
;
21340 if (sec
== text_section
)
21341 table
= text_section_line_info
;
21342 else if (sec
== cold_text_section
)
21344 table
= cold_text_section_line_info
;
21347 cold_text_section_line_info
= table
= new_line_info_table ();
21348 table
->end_label
= cold_end_label
;
21353 const char *end_label
;
21355 if (flag_reorder_blocks_and_partition
)
21357 if (in_cold_section_p
)
21358 end_label
= crtl
->subsections
.cold_section_end_label
;
21360 end_label
= crtl
->subsections
.hot_section_end_label
;
21364 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21365 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
21366 current_function_funcdef_no
);
21367 end_label
= ggc_strdup (label
);
21370 table
= new_line_info_table ();
21371 table
->end_label
= end_label
;
21373 vec_safe_push (separate_line_info
, table
);
21376 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21377 table
->is_stmt
= (cur_line_info_table
21378 ? cur_line_info_table
->is_stmt
21379 : DWARF_LINE_DEFAULT_IS_STMT_START
);
21380 cur_line_info_table
= table
;
21384 /* We need to reset the locations at the beginning of each
21385 function. We can't do this in the end_function hook, because the
21386 declarations that use the locations won't have been output when
21387 that hook is called. Also compute have_multiple_function_sections here. */
21390 dwarf2out_begin_function (tree fun
)
21392 section
*sec
= function_section (fun
);
21394 if (sec
!= text_section
)
21395 have_multiple_function_sections
= true;
21397 if (flag_reorder_blocks_and_partition
&& !cold_text_section
)
21399 gcc_assert (current_function_decl
== fun
);
21400 cold_text_section
= unlikely_text_section ();
21401 switch_to_section (cold_text_section
);
21402 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
21403 switch_to_section (sec
);
21406 dwarf2out_note_section_used ();
21407 call_site_count
= 0;
21408 tail_call_site_count
= 0;
21410 set_cur_line_info_table (sec
);
21413 /* Helper function of dwarf2out_end_function, called only after emitting
21414 the very first function into assembly. Check if some .debug_loc range
21415 might end with a .LVL* label that could be equal to .Ltext0.
21416 In that case we must force using absolute addresses in .debug_loc ranges,
21417 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
21418 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
21420 Set have_multiple_function_sections to true in that case and
21421 terminate htab traversal. */
21424 find_empty_loc_ranges_at_text_label (void **slot
, void *)
21426 var_loc_list
*entry
;
21427 struct var_loc_node
*node
;
21429 entry
= (var_loc_list
*) *slot
;
21430 node
= entry
->first
;
21431 if (node
&& node
->next
&& node
->next
->label
)
21434 const char *label
= node
->next
->label
;
21435 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
21437 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
21439 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
21440 if (strcmp (label
, loclabel
) == 0)
21442 have_multiple_function_sections
= true;
21450 /* Hook called after emitting a function into assembly.
21451 This does something only for the very first function emitted. */
21454 dwarf2out_end_function (unsigned int)
21456 if (in_first_function_p
21457 && !have_multiple_function_sections
21458 && first_loclabel_num_not_at_text_label
21460 htab_traverse (decl_loc_table
, find_empty_loc_ranges_at_text_label
,
21462 in_first_function_p
= false;
21463 maybe_at_text_label_p
= false;
21466 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
21469 push_dw_line_info_entry (dw_line_info_table
*table
,
21470 enum dw_line_info_opcode opcode
, unsigned int val
)
21472 dw_line_info_entry e
;
21475 vec_safe_push (table
->entries
, e
);
21478 /* Output a label to mark the beginning of a source code line entry
21479 and record information relating to this source line, in
21480 'line_info_table' for later output of the .debug_line section. */
21481 /* ??? The discriminator parameter ought to be unsigned. */
21484 dwarf2out_source_line (unsigned int line
, const char *filename
,
21485 int discriminator
, bool is_stmt
)
21487 unsigned int file_num
;
21488 dw_line_info_table
*table
;
21490 if (debug_info_level
< DINFO_LEVEL_TERSE
|| line
== 0)
21493 /* The discriminator column was added in dwarf4. Simplify the below
21494 by simply removing it if we're not supposed to output it. */
21495 if (dwarf_version
< 4 && dwarf_strict
)
21498 table
= cur_line_info_table
;
21499 file_num
= maybe_emit_file (lookup_filename (filename
));
21501 /* ??? TODO: Elide duplicate line number entries. Traditionally,
21502 the debugger has used the second (possibly duplicate) line number
21503 at the beginning of the function to mark the end of the prologue.
21504 We could eliminate any other duplicates within the function. For
21505 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
21506 that second line number entry. */
21507 /* Recall that this end-of-prologue indication is *not* the same thing
21508 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
21509 to which the hook corresponds, follows the last insn that was
21510 emitted by gen_prologue. What we need is to precede the first insn
21511 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
21512 insn that corresponds to something the user wrote. These may be
21513 very different locations once scheduling is enabled. */
21515 if (0 && file_num
== table
->file_num
21516 && line
== table
->line_num
21517 && discriminator
== table
->discrim_num
21518 && is_stmt
== table
->is_stmt
)
21521 switch_to_section (current_function_section ());
21523 /* If requested, emit something human-readable. */
21524 if (flag_debug_asm
)
21525 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
, filename
, line
);
21527 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21529 /* Emit the .loc directive understood by GNU as. */
21530 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
21531 file_num, line, is_stmt, discriminator */
21532 fputs ("\t.loc ", asm_out_file
);
21533 fprint_ul (asm_out_file
, file_num
);
21534 putc (' ', asm_out_file
);
21535 fprint_ul (asm_out_file
, line
);
21536 putc (' ', asm_out_file
);
21537 putc ('0', asm_out_file
);
21539 if (is_stmt
!= table
->is_stmt
)
21541 fputs (" is_stmt ", asm_out_file
);
21542 putc (is_stmt
? '1' : '0', asm_out_file
);
21544 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
21546 gcc_assert (discriminator
> 0);
21547 fputs (" discriminator ", asm_out_file
);
21548 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
21550 putc ('\n', asm_out_file
);
21554 unsigned int label_num
= ++line_info_label_num
;
21556 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
21558 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
21559 if (file_num
!= table
->file_num
)
21560 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
21561 if (discriminator
!= table
->discrim_num
)
21562 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
21563 if (is_stmt
!= table
->is_stmt
)
21564 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
21565 push_dw_line_info_entry (table
, LI_set_line
, line
);
21568 table
->file_num
= file_num
;
21569 table
->line_num
= line
;
21570 table
->discrim_num
= discriminator
;
21571 table
->is_stmt
= is_stmt
;
21572 table
->in_use
= true;
21575 /* Record the beginning of a new source file. */
21578 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
21580 if (flag_eliminate_dwarf2_dups
)
21582 /* Record the beginning of the file for break_out_includes. */
21583 dw_die_ref bincl_die
;
21585 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die (), NULL
);
21586 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
21589 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21592 e
.code
= DW_MACINFO_start_file
;
21594 e
.info
= ggc_strdup (filename
);
21595 vec_safe_push (macinfo_table
, e
);
21599 /* Record the end of a source file. */
21602 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
21604 if (flag_eliminate_dwarf2_dups
)
21605 /* Record the end of the file for break_out_includes. */
21606 new_die (DW_TAG_GNU_EINCL
, comp_unit_die (), NULL
);
21608 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21611 e
.code
= DW_MACINFO_end_file
;
21614 vec_safe_push (macinfo_table
, e
);
21618 /* Called from debug_define in toplev.c. The `buffer' parameter contains
21619 the tail part of the directive line, i.e. the part which is past the
21620 initial whitespace, #, whitespace, directive-name, whitespace part. */
21623 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
21624 const char *buffer ATTRIBUTE_UNUSED
)
21626 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21629 /* Insert a dummy first entry to be able to optimize the whole
21630 predefined macro block using DW_MACRO_GNU_transparent_include. */
21631 if (macinfo_table
->is_empty () && lineno
<= 1)
21636 vec_safe_push (macinfo_table
, e
);
21638 e
.code
= DW_MACINFO_define
;
21640 e
.info
= ggc_strdup (buffer
);
21641 vec_safe_push (macinfo_table
, e
);
21645 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
21646 the tail part of the directive line, i.e. the part which is past the
21647 initial whitespace, #, whitespace, directive-name, whitespace part. */
21650 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
21651 const char *buffer ATTRIBUTE_UNUSED
)
21653 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21656 /* Insert a dummy first entry to be able to optimize the whole
21657 predefined macro block using DW_MACRO_GNU_transparent_include. */
21658 if (macinfo_table
->is_empty () && lineno
<= 1)
21663 vec_safe_push (macinfo_table
, e
);
21665 e
.code
= DW_MACINFO_undef
;
21667 e
.info
= ggc_strdup (buffer
);
21668 vec_safe_push (macinfo_table
, e
);
21672 /* Helpers to manipulate hash table of CUs. */
21674 struct macinfo_entry_hasher
: typed_noop_remove
<macinfo_entry
>
21676 typedef macinfo_entry value_type
;
21677 typedef macinfo_entry compare_type
;
21678 static inline hashval_t
hash (const value_type
*);
21679 static inline bool equal (const value_type
*, const compare_type
*);
21683 macinfo_entry_hasher::hash (const value_type
*entry
)
21685 return htab_hash_string (entry
->info
);
21689 macinfo_entry_hasher::equal (const value_type
*entry1
,
21690 const compare_type
*entry2
)
21692 return !strcmp (entry1
->info
, entry2
->info
);
21695 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
21697 /* Output a single .debug_macinfo entry. */
21700 output_macinfo_op (macinfo_entry
*ref
)
21704 struct indirect_string_node
*node
;
21705 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21706 struct dwarf_file_data
*fd
;
21710 case DW_MACINFO_start_file
:
21711 fd
= lookup_filename (ref
->info
);
21712 file_num
= maybe_emit_file (fd
);
21713 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
21714 dw2_asm_output_data_uleb128 (ref
->lineno
,
21715 "Included from line number %lu",
21716 (unsigned long) ref
->lineno
);
21717 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
21719 case DW_MACINFO_end_file
:
21720 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
21722 case DW_MACINFO_define
:
21723 case DW_MACINFO_undef
:
21724 len
= strlen (ref
->info
) + 1;
21726 && len
> DWARF_OFFSET_SIZE
21727 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
21728 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
21730 ref
->code
= ref
->code
== DW_MACINFO_define
21731 ? DW_MACRO_GNU_define_indirect
21732 : DW_MACRO_GNU_undef_indirect
;
21733 output_macinfo_op (ref
);
21736 dw2_asm_output_data (1, ref
->code
,
21737 ref
->code
== DW_MACINFO_define
21738 ? "Define macro" : "Undefine macro");
21739 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21740 (unsigned long) ref
->lineno
);
21741 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
21743 case DW_MACRO_GNU_define_indirect
:
21744 case DW_MACRO_GNU_undef_indirect
:
21745 node
= find_AT_string (ref
->info
);
21747 && ((node
->form
== DW_FORM_strp
)
21748 || (node
->form
== DW_FORM_GNU_str_index
)));
21749 dw2_asm_output_data (1, ref
->code
,
21750 ref
->code
== DW_MACRO_GNU_define_indirect
21751 ? "Define macro indirect"
21752 : "Undefine macro indirect");
21753 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21754 (unsigned long) ref
->lineno
);
21755 if (node
->form
== DW_FORM_strp
)
21756 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
21757 debug_str_section
, "The macro: \"%s\"",
21760 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
21763 case DW_MACRO_GNU_transparent_include
:
21764 dw2_asm_output_data (1, ref
->code
, "Transparent include");
21765 ASM_GENERATE_INTERNAL_LABEL (label
,
21766 DEBUG_MACRO_SECTION_LABEL
, ref
->lineno
);
21767 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
21770 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
21771 ASM_COMMENT_START
, (unsigned long) ref
->code
);
21776 /* Attempt to make a sequence of define/undef macinfo ops shareable with
21777 other compilation unit .debug_macinfo sections. IDX is the first
21778 index of a define/undef, return the number of ops that should be
21779 emitted in a comdat .debug_macinfo section and emit
21780 a DW_MACRO_GNU_transparent_include entry referencing it.
21781 If the define/undef entry should be emitted normally, return 0. */
21784 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
21785 macinfo_hash_type
*macinfo_htab
)
21787 macinfo_entry
*first
, *second
, *cur
, *inc
;
21788 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
21789 unsigned char checksum
[16];
21790 struct md5_ctx ctx
;
21791 char *grp_name
, *tail
;
21793 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
21794 macinfo_entry
**slot
;
21796 first
= &(*macinfo_table
)[idx
];
21797 second
= &(*macinfo_table
)[idx
+ 1];
21799 /* Optimize only if there are at least two consecutive define/undef ops,
21800 and either all of them are before first DW_MACINFO_start_file
21801 with lineno {0,1} (i.e. predefined macro block), or all of them are
21802 in some included header file. */
21803 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
21805 if (vec_safe_is_empty (files
))
21807 if (first
->lineno
> 1 || second
->lineno
> 1)
21810 else if (first
->lineno
== 0)
21813 /* Find the last define/undef entry that can be grouped together
21814 with first and at the same time compute md5 checksum of their
21815 codes, linenumbers and strings. */
21816 md5_init_ctx (&ctx
);
21817 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
21818 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
21820 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
21824 unsigned char code
= cur
->code
;
21825 md5_process_bytes (&code
, 1, &ctx
);
21826 checksum_uleb128 (cur
->lineno
, &ctx
);
21827 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
21829 md5_finish_ctx (&ctx
, checksum
);
21832 /* From the containing include filename (if any) pick up just
21833 usable characters from its basename. */
21834 if (vec_safe_is_empty (files
))
21837 base
= lbasename (files
->last ().info
);
21838 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
21839 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
21840 encoded_filename_len
++;
21841 /* Count . at the end. */
21842 if (encoded_filename_len
)
21843 encoded_filename_len
++;
21845 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
21846 linebuf_len
= strlen (linebuf
);
21848 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
21849 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
21851 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
21852 tail
= grp_name
+ 4;
21853 if (encoded_filename_len
)
21855 for (i
= 0; base
[i
]; i
++)
21856 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
21860 memcpy (tail
, linebuf
, linebuf_len
);
21861 tail
+= linebuf_len
;
21863 for (i
= 0; i
< 16; i
++)
21864 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
21866 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
21867 in the empty vector entry before the first define/undef. */
21868 inc
= &(*macinfo_table
)[idx
- 1];
21869 inc
->code
= DW_MACRO_GNU_transparent_include
;
21871 inc
->info
= ggc_strdup (grp_name
);
21872 if (!macinfo_htab
->is_created ())
21873 macinfo_htab
->create (10);
21874 /* Avoid emitting duplicates. */
21875 slot
= macinfo_htab
->find_slot (inc
, INSERT
);
21880 /* If such an entry has been used before, just emit
21881 a DW_MACRO_GNU_transparent_include op. */
21883 output_macinfo_op (inc
);
21884 /* And clear all macinfo_entry in the range to avoid emitting them
21885 in the second pass. */
21886 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
21895 inc
->lineno
= macinfo_htab
->elements ();
21896 output_macinfo_op (inc
);
21901 /* Save any strings needed by the macinfo table in the debug str
21902 table. All strings must be collected into the table by the time
21903 index_string is called. */
21906 save_macinfo_strings (void)
21910 macinfo_entry
*ref
;
21912 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
21916 /* Match the logic in output_macinfo_op to decide on
21917 indirect strings. */
21918 case DW_MACINFO_define
:
21919 case DW_MACINFO_undef
:
21920 len
= strlen (ref
->info
) + 1;
21922 && len
> DWARF_OFFSET_SIZE
21923 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
21924 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
21925 set_indirect_string (find_AT_string (ref
->info
));
21927 case DW_MACRO_GNU_define_indirect
:
21928 case DW_MACRO_GNU_undef_indirect
:
21929 set_indirect_string (find_AT_string (ref
->info
));
21937 /* Output macinfo section(s). */
21940 output_macinfo (void)
21943 unsigned long length
= vec_safe_length (macinfo_table
);
21944 macinfo_entry
*ref
;
21945 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
21946 macinfo_hash_type macinfo_htab
;
21951 /* output_macinfo* uses these interchangeably. */
21952 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_GNU_define
21953 && (int) DW_MACINFO_undef
== (int) DW_MACRO_GNU_undef
21954 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_GNU_start_file
21955 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_GNU_end_file
);
21957 /* For .debug_macro emit the section header. */
21960 dw2_asm_output_data (2, 4, "DWARF macro version number");
21961 if (DWARF_OFFSET_SIZE
== 8)
21962 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
21964 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
21965 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
21966 (!dwarf_split_debug_info
? debug_line_section_label
21967 : debug_skeleton_line_section_label
),
21968 debug_line_section
, NULL
);
21971 /* In the first loop, it emits the primary .debug_macinfo section
21972 and after each emitted op the macinfo_entry is cleared.
21973 If a longer range of define/undef ops can be optimized using
21974 DW_MACRO_GNU_transparent_include, the
21975 DW_MACRO_GNU_transparent_include op is emitted and kept in
21976 the vector before the first define/undef in the range and the
21977 whole range of define/undef ops is not emitted and kept. */
21978 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
21982 case DW_MACINFO_start_file
:
21983 vec_safe_push (files
, *ref
);
21985 case DW_MACINFO_end_file
:
21986 if (!vec_safe_is_empty (files
))
21989 case DW_MACINFO_define
:
21990 case DW_MACINFO_undef
:
21992 && HAVE_COMDAT_GROUP
21993 && vec_safe_length (files
) != 1
21996 && (*macinfo_table
)[i
- 1].code
== 0)
21998 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
22007 /* A dummy entry may be inserted at the beginning to be able
22008 to optimize the whole block of predefined macros. */
22014 output_macinfo_op (ref
);
22019 if (!macinfo_htab
.is_created ())
22022 macinfo_htab
.dispose ();
22024 /* If any DW_MACRO_GNU_transparent_include were used, on those
22025 DW_MACRO_GNU_transparent_include entries terminate the
22026 current chain and switch to a new comdat .debug_macinfo
22027 section and emit the define/undef entries within it. */
22028 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22033 case DW_MACRO_GNU_transparent_include
:
22035 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
22036 tree comdat_key
= get_identifier (ref
->info
);
22037 /* Terminate the previous .debug_macinfo section. */
22038 dw2_asm_output_data (1, 0, "End compilation unit");
22039 targetm
.asm_out
.named_section (DEBUG_MACRO_SECTION
,
22041 | SECTION_LINKONCE
,
22043 ASM_GENERATE_INTERNAL_LABEL (label
,
22044 DEBUG_MACRO_SECTION_LABEL
,
22046 ASM_OUTPUT_LABEL (asm_out_file
, label
);
22049 dw2_asm_output_data (2, 4, "DWARF macro version number");
22050 if (DWARF_OFFSET_SIZE
== 8)
22051 dw2_asm_output_data (1, 1, "Flags: 64-bit");
22053 dw2_asm_output_data (1, 0, "Flags: 32-bit");
22056 case DW_MACINFO_define
:
22057 case DW_MACINFO_undef
:
22058 output_macinfo_op (ref
);
22063 gcc_unreachable ();
22067 /* Set up for Dwarf output at the start of compilation. */
22070 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
22072 /* Allocate the file_table. */
22073 file_table
= htab_create_ggc (50, file_table_hash
,
22074 file_table_eq
, NULL
);
22076 /* Allocate the decl_die_table. */
22077 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
22078 decl_die_table_eq
, NULL
);
22080 /* Allocate the decl_loc_table. */
22081 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
22082 decl_loc_table_eq
, NULL
);
22084 /* Allocate the cached_dw_loc_list_table. */
22085 cached_dw_loc_list_table
22086 = htab_create_ggc (10, cached_dw_loc_list_table_hash
,
22087 cached_dw_loc_list_table_eq
, NULL
);
22089 /* Allocate the initial hunk of the decl_scope_table. */
22090 vec_alloc (decl_scope_table
, 256);
22092 /* Allocate the initial hunk of the abbrev_die_table. */
22093 abbrev_die_table
= ggc_alloc_cleared_vec_dw_die_ref
22094 (ABBREV_DIE_TABLE_INCREMENT
);
22095 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
22096 /* Zero-th entry is allocated, but unused. */
22097 abbrev_die_table_in_use
= 1;
22099 /* Allocate the pubtypes and pubnames vectors. */
22100 vec_alloc (pubname_table
, 32);
22101 vec_alloc (pubtype_table
, 32);
22103 vec_alloc (incomplete_types
, 64);
22105 vec_alloc (used_rtx_array
, 32);
22107 if (!dwarf_split_debug_info
)
22109 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
22110 SECTION_DEBUG
, NULL
);
22111 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22112 SECTION_DEBUG
, NULL
);
22113 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
22114 SECTION_DEBUG
, NULL
);
22118 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
22119 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22120 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
22121 SECTION_DEBUG
| SECTION_EXCLUDE
,
22123 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
22124 SECTION_DEBUG
, NULL
);
22125 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
22126 SECTION_DEBUG
, NULL
);
22127 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22128 SECTION_DEBUG
, NULL
);
22129 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
22130 DEBUG_SKELETON_ABBREV_SECTION_LABEL
, 0);
22132 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
22133 the main .o, but the skeleton_line goes into the split off dwo. */
22134 debug_skeleton_line_section
22135 = get_section (DEBUG_DWO_LINE_SECTION
,
22136 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22137 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
22138 DEBUG_SKELETON_LINE_SECTION_LABEL
, 0);
22139 debug_str_offsets_section
= get_section (DEBUG_STR_OFFSETS_SECTION
,
22140 SECTION_DEBUG
| SECTION_EXCLUDE
,
22142 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
22143 DEBUG_SKELETON_INFO_SECTION_LABEL
, 0);
22144 debug_loc_section
= get_section (DEBUG_DWO_LOC_SECTION
,
22145 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22146 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
22147 DEBUG_STR_DWO_SECTION_FLAGS
, NULL
);
22149 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
22150 SECTION_DEBUG
, NULL
);
22151 debug_macinfo_section
= get_section (dwarf_strict
22152 ? DEBUG_MACINFO_SECTION
22153 : DEBUG_MACRO_SECTION
,
22154 DEBUG_MACRO_SECTION_FLAGS
, NULL
);
22155 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
22156 SECTION_DEBUG
, NULL
);
22157 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
22158 SECTION_DEBUG
, NULL
);
22159 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
22160 SECTION_DEBUG
, NULL
);
22161 debug_str_section
= get_section (DEBUG_STR_SECTION
,
22162 DEBUG_STR_SECTION_FLAGS
, NULL
);
22163 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
22164 SECTION_DEBUG
, NULL
);
22165 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
22166 SECTION_DEBUG
, NULL
);
22168 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
22169 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
22170 DEBUG_ABBREV_SECTION_LABEL
, 0);
22171 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
22172 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
22173 COLD_TEXT_SECTION_LABEL
, 0);
22174 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
22176 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
22177 DEBUG_INFO_SECTION_LABEL
, 0);
22178 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
22179 DEBUG_LINE_SECTION_LABEL
, 0);
22180 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
22181 DEBUG_RANGES_SECTION_LABEL
, 0);
22182 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
22183 DEBUG_ADDR_SECTION_LABEL
, 0);
22184 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
22186 ? DEBUG_MACINFO_SECTION_LABEL
22187 : DEBUG_MACRO_SECTION_LABEL
, 0);
22188 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
, 0);
22190 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22191 vec_alloc (macinfo_table
, 64);
22193 switch_to_section (text_section
);
22194 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
22196 /* Make sure the line number table for .text always exists. */
22197 text_section_line_info
= new_line_info_table ();
22198 text_section_line_info
->end_label
= text_end_label
;
22201 /* Called before compile () starts outputtting functions, variables
22202 and toplevel asms into assembly. */
22205 dwarf2out_assembly_start (void)
22207 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
22208 && dwarf2out_do_cfi_asm ()
22209 && (!(flag_unwind_tables
|| flag_exceptions
)
22210 || targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
))
22211 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
22214 /* A helper function for dwarf2out_finish called through
22215 htab_traverse. Assign a string its index. All strings must be
22216 collected into the table by the time index_string is called,
22217 because the indexing code relies on htab_traverse to traverse nodes
22218 in the same order for each run. */
22221 index_string (void **h
, void *v
)
22223 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22224 unsigned int *index
= (unsigned int *) v
;
22226 find_string_form (node
);
22227 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22229 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
22230 node
->index
= *index
;
22236 /* A helper function for output_indirect_strings called through
22237 htab_traverse. Output the offset to a string and update the
22241 output_index_string_offset (void **h
, void *v
)
22243 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22244 unsigned int *offset
= (unsigned int *) v
;
22246 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22248 /* Assert that this node has been assigned an index. */
22249 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
22250 && node
->index
!= NOT_INDEXED
);
22251 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
22252 "indexed string 0x%x: %s", node
->index
, node
->str
);
22253 *offset
+= strlen (node
->str
) + 1;
22258 /* A helper function for dwarf2out_finish called through
22259 htab_traverse. Output the indexed string. */
22262 output_index_string (void **h
, void *v
)
22264 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22265 unsigned int *cur_idx
= (unsigned int *) v
;
22267 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22269 /* Assert that the strings are output in the same order as their
22270 indexes were assigned. */
22271 gcc_assert (*cur_idx
== node
->index
);
22272 assemble_string (node
->str
, strlen (node
->str
) + 1);
22278 /* A helper function for dwarf2out_finish called through
22279 htab_traverse. Emit one queued .debug_str string. */
22282 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
22284 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22286 node
->form
= find_string_form (node
);
22287 if (node
->form
== DW_FORM_strp
&& node
->refcount
> 0)
22289 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
22290 assemble_string (node
->str
, strlen (node
->str
) + 1);
22296 /* Output the indexed string table. */
22299 output_indirect_strings (void)
22301 switch_to_section (debug_str_section
);
22302 if (!dwarf_split_debug_info
)
22303 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
22306 unsigned int offset
= 0;
22307 unsigned int cur_idx
= 0;
22309 htab_traverse (skeleton_debug_str_hash
, output_indirect_string
, NULL
);
22311 switch_to_section (debug_str_offsets_section
);
22312 htab_traverse_noresize (debug_str_hash
,
22313 output_index_string_offset
,
22315 switch_to_section (debug_str_dwo_section
);
22316 htab_traverse_noresize (debug_str_hash
,
22317 output_index_string
,
22322 /* Callback for htab_traverse to assign an index to an entry in the
22323 table, and to write that entry to the .debug_addr section. */
22326 output_addr_table_entry (void **slot
, void *data
)
22328 addr_table_entry
*entry
= (addr_table_entry
*) *slot
;
22329 unsigned int *cur_index
= (unsigned int *)data
;
22331 if (entry
->refcount
== 0)
22333 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
22334 || entry
->index
== NOT_INDEXED
);
22338 gcc_assert (entry
->index
== *cur_index
);
22341 switch (entry
->kind
)
22344 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
22345 "0x%x", entry
->index
);
22347 case ate_kind_rtx_dtprel
:
22348 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
22349 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
22352 fputc ('\n', asm_out_file
);
22354 case ate_kind_label
:
22355 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
22356 "0x%x", entry
->index
);
22359 gcc_unreachable ();
22364 /* Produce the .debug_addr section. */
22367 output_addr_table (void)
22369 unsigned int index
= 0;
22370 if (addr_index_table
== NULL
|| htab_size (addr_index_table
) == 0)
22373 switch_to_section (debug_addr_section
);
22374 htab_traverse_noresize (addr_index_table
, output_addr_table_entry
, &index
);
22377 #if ENABLE_ASSERT_CHECKING
22378 /* Verify that all marks are clear. */
22381 verify_marks_clear (dw_die_ref die
)
22385 gcc_assert (! die
->die_mark
);
22386 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
22388 #endif /* ENABLE_ASSERT_CHECKING */
22390 /* Clear the marks for a die and its children.
22391 Be cool if the mark isn't set. */
22394 prune_unmark_dies (dw_die_ref die
)
22400 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
22403 /* Given DIE that we're marking as used, find any other dies
22404 it references as attributes and mark them as used. */
22407 prune_unused_types_walk_attribs (dw_die_ref die
)
22412 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22414 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
22416 /* A reference to another DIE.
22417 Make sure that it will get emitted.
22418 If it was broken out into a comdat group, don't follow it. */
22419 if (! AT_ref (a
)->comdat_type_p
22420 || a
->dw_attr
== DW_AT_specification
)
22421 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
22423 /* Set the string's refcount to 0 so that prune_unused_types_mark
22424 accounts properly for it. */
22425 if (AT_class (a
) == dw_val_class_str
)
22426 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
22430 /* Mark the generic parameters and arguments children DIEs of DIE. */
22433 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
22437 if (die
== NULL
|| die
->die_child
== NULL
)
22439 c
= die
->die_child
;
22442 if (is_template_parameter (c
))
22443 prune_unused_types_mark (c
, 1);
22445 } while (c
&& c
!= die
->die_child
);
22448 /* Mark DIE as being used. If DOKIDS is true, then walk down
22449 to DIE's children. */
22452 prune_unused_types_mark (dw_die_ref die
, int dokids
)
22456 if (die
->die_mark
== 0)
22458 /* We haven't done this node yet. Mark it as used. */
22460 /* If this is the DIE of a generic type instantiation,
22461 mark the children DIEs that describe its generic parms and
22463 prune_unused_types_mark_generic_parms_dies (die
);
22465 /* We also have to mark its parents as used.
22466 (But we don't want to mark our parent's kids due to this,
22467 unless it is a class.) */
22468 if (die
->die_parent
)
22469 prune_unused_types_mark (die
->die_parent
,
22470 class_scope_p (die
->die_parent
));
22472 /* Mark any referenced nodes. */
22473 prune_unused_types_walk_attribs (die
);
22475 /* If this node is a specification,
22476 also mark the definition, if it exists. */
22477 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
22478 prune_unused_types_mark (die
->die_definition
, 1);
22481 if (dokids
&& die
->die_mark
!= 2)
22483 /* We need to walk the children, but haven't done so yet.
22484 Remember that we've walked the kids. */
22487 /* If this is an array type, we need to make sure our
22488 kids get marked, even if they're types. If we're
22489 breaking out types into comdat sections, do this
22490 for all type definitions. */
22491 if (die
->die_tag
== DW_TAG_array_type
22492 || (use_debug_types
22493 && is_type_die (die
) && ! is_declaration_die (die
)))
22494 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
22496 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22500 /* For local classes, look if any static member functions were emitted
22501 and if so, mark them. */
22504 prune_unused_types_walk_local_classes (dw_die_ref die
)
22508 if (die
->die_mark
== 2)
22511 switch (die
->die_tag
)
22513 case DW_TAG_structure_type
:
22514 case DW_TAG_union_type
:
22515 case DW_TAG_class_type
:
22518 case DW_TAG_subprogram
:
22519 if (!get_AT_flag (die
, DW_AT_declaration
)
22520 || die
->die_definition
!= NULL
)
22521 prune_unused_types_mark (die
, 1);
22528 /* Mark children. */
22529 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
22532 /* Walk the tree DIE and mark types that we actually use. */
22535 prune_unused_types_walk (dw_die_ref die
)
22539 /* Don't do anything if this node is already marked and
22540 children have been marked as well. */
22541 if (die
->die_mark
== 2)
22544 switch (die
->die_tag
)
22546 case DW_TAG_structure_type
:
22547 case DW_TAG_union_type
:
22548 case DW_TAG_class_type
:
22549 if (die
->die_perennial_p
)
22552 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
22553 if (c
->die_tag
== DW_TAG_subprogram
)
22556 /* Finding used static member functions inside of classes
22557 is needed just for local classes, because for other classes
22558 static member function DIEs with DW_AT_specification
22559 are emitted outside of the DW_TAG_*_type. If we ever change
22560 it, we'd need to call this even for non-local classes. */
22562 prune_unused_types_walk_local_classes (die
);
22564 /* It's a type node --- don't mark it. */
22567 case DW_TAG_const_type
:
22568 case DW_TAG_packed_type
:
22569 case DW_TAG_pointer_type
:
22570 case DW_TAG_reference_type
:
22571 case DW_TAG_rvalue_reference_type
:
22572 case DW_TAG_volatile_type
:
22573 case DW_TAG_typedef
:
22574 case DW_TAG_array_type
:
22575 case DW_TAG_interface_type
:
22576 case DW_TAG_friend
:
22577 case DW_TAG_variant_part
:
22578 case DW_TAG_enumeration_type
:
22579 case DW_TAG_subroutine_type
:
22580 case DW_TAG_string_type
:
22581 case DW_TAG_set_type
:
22582 case DW_TAG_subrange_type
:
22583 case DW_TAG_ptr_to_member_type
:
22584 case DW_TAG_file_type
:
22585 if (die
->die_perennial_p
)
22588 /* It's a type node --- don't mark it. */
22592 /* Mark everything else. */
22596 if (die
->die_mark
== 0)
22600 /* Now, mark any dies referenced from here. */
22601 prune_unused_types_walk_attribs (die
);
22606 /* Mark children. */
22607 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22610 /* Increment the string counts on strings referred to from DIE's
22614 prune_unused_types_update_strings (dw_die_ref die
)
22619 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22620 if (AT_class (a
) == dw_val_class_str
)
22622 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
22624 /* Avoid unnecessarily putting strings that are used less than
22625 twice in the hash table. */
22627 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
22630 slot
= htab_find_slot_with_hash (debug_str_hash
, s
->str
,
22631 htab_hash_string (s
->str
),
22633 gcc_assert (*slot
== NULL
);
22639 /* Remove from the tree DIE any dies that aren't marked. */
22642 prune_unused_types_prune (dw_die_ref die
)
22646 gcc_assert (die
->die_mark
);
22647 prune_unused_types_update_strings (die
);
22649 if (! die
->die_child
)
22652 c
= die
->die_child
;
22654 dw_die_ref prev
= c
;
22655 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
22656 if (c
== die
->die_child
)
22658 /* No marked children between 'prev' and the end of the list. */
22660 /* No marked children at all. */
22661 die
->die_child
= NULL
;
22664 prev
->die_sib
= c
->die_sib
;
22665 die
->die_child
= prev
;
22670 if (c
!= prev
->die_sib
)
22672 prune_unused_types_prune (c
);
22673 } while (c
!= die
->die_child
);
22676 /* Remove dies representing declarations that we never use. */
22679 prune_unused_types (void)
22682 limbo_die_node
*node
;
22683 comdat_type_node
*ctnode
;
22685 dw_die_ref base_type
;
22687 #if ENABLE_ASSERT_CHECKING
22688 /* All the marks should already be clear. */
22689 verify_marks_clear (comp_unit_die ());
22690 for (node
= limbo_die_list
; node
; node
= node
->next
)
22691 verify_marks_clear (node
->die
);
22692 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22693 verify_marks_clear (ctnode
->root_die
);
22694 #endif /* ENABLE_ASSERT_CHECKING */
22696 /* Mark types that are used in global variables. */
22697 premark_types_used_by_global_vars ();
22699 /* Set the mark on nodes that are actually used. */
22700 prune_unused_types_walk (comp_unit_die ());
22701 for (node
= limbo_die_list
; node
; node
= node
->next
)
22702 prune_unused_types_walk (node
->die
);
22703 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22705 prune_unused_types_walk (ctnode
->root_die
);
22706 prune_unused_types_mark (ctnode
->type_die
, 1);
22709 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
22710 are unusual in that they are pubnames that are the children of pubtypes.
22711 They should only be marked via their parent DW_TAG_enumeration_type die,
22712 not as roots in themselves. */
22713 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
22714 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
22715 prune_unused_types_mark (pub
->die
, 1);
22716 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
22717 prune_unused_types_mark (base_type
, 1);
22719 if (debug_str_hash
)
22720 htab_empty (debug_str_hash
);
22721 if (skeleton_debug_str_hash
)
22722 htab_empty (skeleton_debug_str_hash
);
22723 prune_unused_types_prune (comp_unit_die ());
22724 for (node
= limbo_die_list
; node
; node
= node
->next
)
22725 prune_unused_types_prune (node
->die
);
22726 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22727 prune_unused_types_prune (ctnode
->root_die
);
22729 /* Leave the marks clear. */
22730 prune_unmark_dies (comp_unit_die ());
22731 for (node
= limbo_die_list
; node
; node
= node
->next
)
22732 prune_unmark_dies (node
->die
);
22733 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22734 prune_unmark_dies (ctnode
->root_die
);
22737 /* Set the parameter to true if there are any relative pathnames in
22740 file_table_relative_p (void ** slot
, void *param
)
22742 bool *p
= (bool *) param
;
22743 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
22744 if (!IS_ABSOLUTE_PATH (d
->filename
))
22752 /* Helpers to manipulate hash table of comdat type units. */
22754 struct comdat_type_hasher
: typed_noop_remove
<comdat_type_node
>
22756 typedef comdat_type_node value_type
;
22757 typedef comdat_type_node compare_type
;
22758 static inline hashval_t
hash (const value_type
*);
22759 static inline bool equal (const value_type
*, const compare_type
*);
22763 comdat_type_hasher::hash (const value_type
*type_node
)
22766 memcpy (&h
, type_node
->signature
, sizeof (h
));
22771 comdat_type_hasher::equal (const value_type
*type_node_1
,
22772 const compare_type
*type_node_2
)
22774 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
22775 DWARF_TYPE_SIGNATURE_SIZE
));
22778 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
22779 to the location it would have been added, should we know its
22780 DECL_ASSEMBLER_NAME when we added other attributes. This will
22781 probably improve compactness of debug info, removing equivalent
22782 abbrevs, and hide any differences caused by deferring the
22783 computation of the assembler name, triggered by e.g. PCH. */
22786 move_linkage_attr (dw_die_ref die
)
22788 unsigned ix
= vec_safe_length (die
->die_attr
);
22789 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
22791 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
22792 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
22796 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
22798 if (prev
->dw_attr
== DW_AT_decl_line
|| prev
->dw_attr
== DW_AT_name
)
22802 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
22804 die
->die_attr
->pop ();
22805 die
->die_attr
->quick_insert (ix
, linkage
);
22809 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
22810 referenced from typed stack ops and count how often they are used. */
22813 mark_base_types (dw_loc_descr_ref loc
)
22815 dw_die_ref base_type
= NULL
;
22817 for (; loc
; loc
= loc
->dw_loc_next
)
22819 switch (loc
->dw_loc_opc
)
22821 case DW_OP_GNU_regval_type
:
22822 case DW_OP_GNU_deref_type
:
22823 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
22825 case DW_OP_GNU_convert
:
22826 case DW_OP_GNU_reinterpret
:
22827 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
22830 case DW_OP_GNU_const_type
:
22831 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
22833 case DW_OP_GNU_entry_value
:
22834 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
22839 gcc_assert (base_type
->die_parent
== comp_unit_die ());
22840 if (base_type
->die_mark
)
22841 base_type
->die_mark
++;
22844 base_types
.safe_push (base_type
);
22845 base_type
->die_mark
= 1;
22850 /* Comparison function for sorting marked base types. */
22853 base_type_cmp (const void *x
, const void *y
)
22855 dw_die_ref dx
= *(const dw_die_ref
*) x
;
22856 dw_die_ref dy
= *(const dw_die_ref
*) y
;
22857 unsigned int byte_size1
, byte_size2
;
22858 unsigned int encoding1
, encoding2
;
22859 if (dx
->die_mark
> dy
->die_mark
)
22861 if (dx
->die_mark
< dy
->die_mark
)
22863 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
22864 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
22865 if (byte_size1
< byte_size2
)
22867 if (byte_size1
> byte_size2
)
22869 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
22870 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
22871 if (encoding1
< encoding2
)
22873 if (encoding1
> encoding2
)
22878 /* Move base types marked by mark_base_types as early as possible
22879 in the CU, sorted by decreasing usage count both to make the
22880 uleb128 references as small as possible and to make sure they
22881 will have die_offset already computed by calc_die_sizes when
22882 sizes of typed stack loc ops is computed. */
22885 move_marked_base_types (void)
22888 dw_die_ref base_type
, die
, c
;
22890 if (base_types
.is_empty ())
22893 /* Sort by decreasing usage count, they will be added again in that
22895 base_types
.qsort (base_type_cmp
);
22896 die
= comp_unit_die ();
22897 c
= die
->die_child
;
22900 dw_die_ref prev
= c
;
22902 while (c
->die_mark
)
22904 remove_child_with_prev (c
, prev
);
22905 /* As base types got marked, there must be at least
22906 one node other than DW_TAG_base_type. */
22907 gcc_assert (c
!= c
->die_sib
);
22911 while (c
!= die
->die_child
);
22912 gcc_assert (die
->die_child
);
22913 c
= die
->die_child
;
22914 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
22916 base_type
->die_mark
= 0;
22917 base_type
->die_sib
= c
->die_sib
;
22918 c
->die_sib
= base_type
;
22923 /* Helper function for resolve_addr, attempt to resolve
22924 one CONST_STRING, return non-zero if not successful. Similarly verify that
22925 SYMBOL_REFs refer to variables emitted in the current CU. */
22928 resolve_one_addr (rtx
*addr
, void *data ATTRIBUTE_UNUSED
)
22932 if (GET_CODE (rtl
) == CONST_STRING
)
22934 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
22935 tree t
= build_string (len
, XSTR (rtl
, 0));
22936 tree tlen
= size_int (len
- 1);
22938 = build_array_type (char_type_node
, build_index_type (tlen
));
22939 rtl
= lookup_constant_def (t
);
22940 if (!rtl
|| !MEM_P (rtl
))
22942 rtl
= XEXP (rtl
, 0);
22943 if (GET_CODE (rtl
) == SYMBOL_REF
22944 && SYMBOL_REF_DECL (rtl
)
22945 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
22947 vec_safe_push (used_rtx_array
, rtl
);
22952 if (GET_CODE (rtl
) == SYMBOL_REF
22953 && SYMBOL_REF_DECL (rtl
))
22955 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
22957 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
22960 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
22964 if (GET_CODE (rtl
) == CONST
22965 && for_each_rtx (&XEXP (rtl
, 0), resolve_one_addr
, NULL
))
22971 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
22972 if possible, and create DW_TAG_dwarf_procedure that can be referenced
22973 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
22976 string_cst_pool_decl (tree t
)
22978 rtx rtl
= output_constant_def (t
, 1);
22979 unsigned char *array
;
22980 dw_loc_descr_ref l
;
22985 if (!rtl
|| !MEM_P (rtl
))
22987 rtl
= XEXP (rtl
, 0);
22988 if (GET_CODE (rtl
) != SYMBOL_REF
22989 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
22992 decl
= SYMBOL_REF_DECL (rtl
);
22993 if (!lookup_decl_die (decl
))
22995 len
= TREE_STRING_LENGTH (t
);
22996 vec_safe_push (used_rtx_array
, rtl
);
22997 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
22998 array
= (unsigned char *) ggc_alloc_atomic (len
);
22999 memcpy (array
, TREE_STRING_POINTER (t
), len
);
23000 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
23001 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
23002 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
23003 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
23004 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
23005 add_AT_loc (ref
, DW_AT_location
, l
);
23006 equate_decl_number_to_die (decl
, ref
);
23011 /* Helper function of resolve_addr_in_expr. LOC is
23012 a DW_OP_addr followed by DW_OP_stack_value, either at the start
23013 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
23014 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
23015 with DW_OP_GNU_implicit_pointer if possible
23016 and return true, if unsuccessful, return false. */
23019 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
23021 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
23022 HOST_WIDE_INT offset
= 0;
23023 dw_die_ref ref
= NULL
;
23026 if (GET_CODE (rtl
) == CONST
23027 && GET_CODE (XEXP (rtl
, 0)) == PLUS
23028 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
23030 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
23031 rtl
= XEXP (XEXP (rtl
, 0), 0);
23033 if (GET_CODE (rtl
) == CONST_STRING
)
23035 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
23036 tree t
= build_string (len
, XSTR (rtl
, 0));
23037 tree tlen
= size_int (len
- 1);
23040 = build_array_type (char_type_node
, build_index_type (tlen
));
23041 rtl
= string_cst_pool_decl (t
);
23045 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
23047 decl
= SYMBOL_REF_DECL (rtl
);
23048 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
23050 ref
= lookup_decl_die (decl
);
23051 if (ref
&& (get_AT (ref
, DW_AT_location
)
23052 || get_AT (ref
, DW_AT_const_value
)))
23054 loc
->dw_loc_opc
= DW_OP_GNU_implicit_pointer
;
23055 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23056 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
23057 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23058 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23059 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23060 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
23068 /* Helper function for resolve_addr, handle one location
23069 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23070 the location list couldn't be resolved. */
23073 resolve_addr_in_expr (dw_loc_descr_ref loc
)
23075 dw_loc_descr_ref keep
= NULL
;
23076 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
23077 switch (loc
->dw_loc_opc
)
23080 if (resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
23083 || prev
->dw_loc_opc
== DW_OP_piece
23084 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
23085 && loc
->dw_loc_next
23086 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
23088 && optimize_one_addr_into_implicit_ptr (loc
))
23093 case DW_OP_GNU_addr_index
:
23094 case DW_OP_GNU_const_index
:
23095 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
23096 || (loc
->dw_loc_opc
== DW_OP_GNU_const_index
&& loc
->dtprel
))
23097 && resolve_one_addr (&loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
,
23101 case DW_OP_const4u
:
23102 case DW_OP_const8u
:
23104 && resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
23107 case DW_OP_plus_uconst
:
23108 if (size_of_loc_descr (loc
)
23109 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
23111 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
23113 dw_loc_descr_ref repl
23114 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
23115 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
23116 add_loc_descr (&repl
, loc
->dw_loc_next
);
23120 case DW_OP_implicit_value
:
23121 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
23122 && resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
, NULL
))
23125 case DW_OP_GNU_implicit_pointer
:
23126 case DW_OP_GNU_parameter_ref
:
23127 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
23130 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
23133 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23134 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23135 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23138 case DW_OP_GNU_const_type
:
23139 case DW_OP_GNU_regval_type
:
23140 case DW_OP_GNU_deref_type
:
23141 case DW_OP_GNU_convert
:
23142 case DW_OP_GNU_reinterpret
:
23143 while (loc
->dw_loc_next
23144 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
)
23146 dw_die_ref base1
, base2
;
23147 unsigned enc1
, enc2
, size1
, size2
;
23148 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23149 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23150 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
23151 else if (loc
->dw_loc_oprnd1
.val_class
23152 == dw_val_class_unsigned_const
)
23155 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23156 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
23157 == dw_val_class_unsigned_const
)
23159 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23160 gcc_assert (base1
->die_tag
== DW_TAG_base_type
23161 && base2
->die_tag
== DW_TAG_base_type
);
23162 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
23163 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
23164 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
23165 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
23167 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
23168 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
23172 /* Optimize away next DW_OP_GNU_convert after
23173 adjusting LOC's base type die reference. */
23174 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23175 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23176 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
23178 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
23179 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23182 /* Don't change integer DW_OP_GNU_convert after e.g. floating
23183 point typed stack entry. */
23184 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
23185 keep
= loc
->dw_loc_next
;
23195 /* Helper function of resolve_addr. DIE had DW_AT_location of
23196 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
23197 and DW_OP_addr couldn't be resolved. resolve_addr has already
23198 removed the DW_AT_location attribute. This function attempts to
23199 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
23200 to it or DW_AT_const_value attribute, if possible. */
23203 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
23205 if (TREE_CODE (decl
) != VAR_DECL
23206 || lookup_decl_die (decl
) != die
23207 || DECL_EXTERNAL (decl
)
23208 || !TREE_STATIC (decl
)
23209 || DECL_INITIAL (decl
) == NULL_TREE
23210 || DECL_P (DECL_INITIAL (decl
))
23211 || get_AT (die
, DW_AT_const_value
))
23214 tree init
= DECL_INITIAL (decl
);
23215 HOST_WIDE_INT offset
= 0;
23216 /* For variables that have been optimized away and thus
23217 don't have a memory location, see if we can emit
23218 DW_AT_const_value instead. */
23219 if (tree_add_const_value_attribute (die
, init
))
23223 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
23224 and ADDR_EXPR refers to a decl that has DW_AT_location or
23225 DW_AT_const_value (but isn't addressable, otherwise
23226 resolving the original DW_OP_addr wouldn't fail), see if
23227 we can add DW_OP_GNU_implicit_pointer. */
23229 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
23230 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
23232 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
23233 init
= TREE_OPERAND (init
, 0);
23236 if (TREE_CODE (init
) != ADDR_EXPR
)
23238 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
23239 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
23240 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
23241 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
23242 && TREE_OPERAND (init
, 0) != decl
))
23245 dw_loc_descr_ref l
;
23247 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
23249 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
23252 decl
= SYMBOL_REF_DECL (rtl
);
23255 decl
= TREE_OPERAND (init
, 0);
23256 ref
= lookup_decl_die (decl
);
23258 || (!get_AT (ref
, DW_AT_location
)
23259 && !get_AT (ref
, DW_AT_const_value
)))
23261 l
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
23262 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23263 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23264 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23265 add_AT_loc (die
, DW_AT_location
, l
);
23269 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23270 an address in .rodata section if the string literal is emitted there,
23271 or remove the containing location list or replace DW_AT_const_value
23272 with DW_AT_location and empty location expression, if it isn't found
23273 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23274 to something that has been emitted in the current CU. */
23277 resolve_addr (dw_die_ref die
)
23281 dw_loc_list_ref
*curr
, *start
, loc
;
23284 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23285 switch (AT_class (a
))
23287 case dw_val_class_loc_list
:
23288 start
= curr
= AT_loc_list_ptr (a
);
23291 /* The same list can be referenced more than once. See if we have
23292 already recorded the result from a previous pass. */
23294 *curr
= loc
->dw_loc_next
;
23295 else if (!loc
->resolved_addr
)
23297 /* As things stand, we do not expect or allow one die to
23298 reference a suffix of another die's location list chain.
23299 References must be identical or completely separate.
23300 There is therefore no need to cache the result of this
23301 pass on any list other than the first; doing so
23302 would lead to unnecessary writes. */
23305 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
23306 if (!resolve_addr_in_expr ((*curr
)->expr
))
23308 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
23309 dw_loc_descr_ref l
= (*curr
)->expr
;
23311 if (next
&& (*curr
)->ll_symbol
)
23313 gcc_assert (!next
->ll_symbol
);
23314 next
->ll_symbol
= (*curr
)->ll_symbol
;
23316 if (dwarf_split_debug_info
)
23317 remove_loc_list_addr_table_entries (l
);
23322 mark_base_types ((*curr
)->expr
);
23323 curr
= &(*curr
)->dw_loc_next
;
23327 loc
->resolved_addr
= 1;
23331 loc
->dw_loc_next
= *start
;
23336 remove_AT (die
, a
->dw_attr
);
23340 case dw_val_class_loc
:
23342 dw_loc_descr_ref l
= AT_loc (a
);
23343 /* For -gdwarf-2 don't attempt to optimize
23344 DW_AT_data_member_location containing
23345 DW_OP_plus_uconst - older consumers might
23346 rely on it being that op instead of a more complex,
23347 but shorter, location description. */
23348 if ((dwarf_version
> 2
23349 || a
->dw_attr
!= DW_AT_data_member_location
23351 || l
->dw_loc_opc
!= DW_OP_plus_uconst
23352 || l
->dw_loc_next
!= NULL
)
23353 && !resolve_addr_in_expr (l
))
23355 if (dwarf_split_debug_info
)
23356 remove_loc_list_addr_table_entries (l
);
23358 && l
->dw_loc_next
== NULL
23359 && l
->dw_loc_opc
== DW_OP_addr
23360 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
23361 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
23362 && a
->dw_attr
== DW_AT_location
)
23364 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
23365 remove_AT (die
, a
->dw_attr
);
23367 optimize_location_into_implicit_ptr (die
, decl
);
23370 remove_AT (die
, a
->dw_attr
);
23374 mark_base_types (l
);
23377 case dw_val_class_addr
:
23378 if (a
->dw_attr
== DW_AT_const_value
23379 && resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
, NULL
))
23381 if (AT_index (a
) != NOT_INDEXED
)
23382 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23383 remove_AT (die
, a
->dw_attr
);
23386 if (die
->die_tag
== DW_TAG_GNU_call_site
23387 && a
->dw_attr
== DW_AT_abstract_origin
)
23389 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
23390 dw_die_ref tdie
= lookup_decl_die (tdecl
);
23392 && DECL_EXTERNAL (tdecl
)
23393 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
)
23395 force_decl_die (tdecl
);
23396 tdie
= lookup_decl_die (tdecl
);
23400 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
23401 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
23402 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
23406 if (AT_index (a
) != NOT_INDEXED
)
23407 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23408 remove_AT (die
, a
->dw_attr
);
23417 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
23420 /* Helper routines for optimize_location_lists.
23421 This pass tries to share identical local lists in .debug_loc
23424 /* Iteratively hash operands of LOC opcode. */
23427 hash_loc_operands (dw_loc_descr_ref loc
, hashval_t hash
)
23429 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
23430 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
23432 switch (loc
->dw_loc_opc
)
23434 case DW_OP_const4u
:
23435 case DW_OP_const8u
:
23439 case DW_OP_const1u
:
23440 case DW_OP_const1s
:
23441 case DW_OP_const2u
:
23442 case DW_OP_const2s
:
23443 case DW_OP_const4s
:
23444 case DW_OP_const8s
:
23448 case DW_OP_plus_uconst
:
23484 case DW_OP_deref_size
:
23485 case DW_OP_xderef_size
:
23486 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23493 gcc_assert (val1
->val_class
== dw_val_class_loc
);
23494 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
23495 hash
= iterative_hash_object (offset
, hash
);
23498 case DW_OP_implicit_value
:
23499 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
23500 switch (val2
->val_class
)
23502 case dw_val_class_const
:
23503 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23505 case dw_val_class_vec
:
23507 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23508 unsigned int len
= val2
->v
.val_vec
.length
;
23510 hash
= iterative_hash_object (elt_size
, hash
);
23511 hash
= iterative_hash_object (len
, hash
);
23512 hash
= iterative_hash (val2
->v
.val_vec
.array
,
23513 len
* elt_size
, hash
);
23516 case dw_val_class_const_double
:
23517 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
23518 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
23520 case dw_val_class_addr
:
23521 hash
= iterative_hash_rtx (val2
->v
.val_addr
, hash
);
23524 gcc_unreachable ();
23528 case DW_OP_bit_piece
:
23529 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23530 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23536 unsigned char dtprel
= 0xd1;
23537 hash
= iterative_hash_object (dtprel
, hash
);
23539 hash
= iterative_hash_rtx (val1
->v
.val_addr
, hash
);
23541 case DW_OP_GNU_addr_index
:
23542 case DW_OP_GNU_const_index
:
23546 unsigned char dtprel
= 0xd1;
23547 hash
= iterative_hash_object (dtprel
, hash
);
23549 hash
= iterative_hash_rtx (val1
->val_entry
->addr
.rtl
, hash
);
23552 case DW_OP_GNU_implicit_pointer
:
23553 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23555 case DW_OP_GNU_entry_value
:
23556 hash
= hash_loc_operands (val1
->v
.val_loc
, hash
);
23558 case DW_OP_GNU_regval_type
:
23559 case DW_OP_GNU_deref_type
:
23561 unsigned int byte_size
23562 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23563 unsigned int encoding
23564 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
23565 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23566 hash
= iterative_hash_object (byte_size
, hash
);
23567 hash
= iterative_hash_object (encoding
, hash
);
23570 case DW_OP_GNU_convert
:
23571 case DW_OP_GNU_reinterpret
:
23572 if (val1
->val_class
== dw_val_class_unsigned_const
)
23574 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
23578 case DW_OP_GNU_const_type
:
23580 unsigned int byte_size
23581 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23582 unsigned int encoding
23583 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
23584 hash
= iterative_hash_object (byte_size
, hash
);
23585 hash
= iterative_hash_object (encoding
, hash
);
23586 if (loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
23588 hash
= iterative_hash_object (val2
->val_class
, hash
);
23589 switch (val2
->val_class
)
23591 case dw_val_class_const
:
23592 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23594 case dw_val_class_vec
:
23596 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23597 unsigned int len
= val2
->v
.val_vec
.length
;
23599 hash
= iterative_hash_object (elt_size
, hash
);
23600 hash
= iterative_hash_object (len
, hash
);
23601 hash
= iterative_hash (val2
->v
.val_vec
.array
,
23602 len
* elt_size
, hash
);
23605 case dw_val_class_const_double
:
23606 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
23607 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
23610 gcc_unreachable ();
23616 /* Other codes have no operands. */
23622 /* Iteratively hash the whole DWARF location expression LOC. */
23624 static inline hashval_t
23625 hash_locs (dw_loc_descr_ref loc
, hashval_t hash
)
23627 dw_loc_descr_ref l
;
23628 bool sizes_computed
= false;
23629 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
23630 size_of_locs (loc
);
23632 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
23634 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
23635 hash
= iterative_hash_object (opc
, hash
);
23636 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
23638 size_of_locs (loc
);
23639 sizes_computed
= true;
23641 hash
= hash_loc_operands (l
, hash
);
23646 /* Compute hash of the whole location list LIST_HEAD. */
23649 hash_loc_list (dw_loc_list_ref list_head
)
23651 dw_loc_list_ref curr
= list_head
;
23652 hashval_t hash
= 0;
23654 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
23656 hash
= iterative_hash (curr
->begin
, strlen (curr
->begin
) + 1, hash
);
23657 hash
= iterative_hash (curr
->end
, strlen (curr
->end
) + 1, hash
);
23659 hash
= iterative_hash (curr
->section
, strlen (curr
->section
) + 1,
23661 hash
= hash_locs (curr
->expr
, hash
);
23663 list_head
->hash
= hash
;
23666 /* Return true if X and Y opcodes have the same operands. */
23669 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
23671 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
23672 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
23673 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
23674 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
23676 switch (x
->dw_loc_opc
)
23678 case DW_OP_const4u
:
23679 case DW_OP_const8u
:
23683 case DW_OP_const1u
:
23684 case DW_OP_const1s
:
23685 case DW_OP_const2u
:
23686 case DW_OP_const2s
:
23687 case DW_OP_const4s
:
23688 case DW_OP_const8s
:
23692 case DW_OP_plus_uconst
:
23728 case DW_OP_deref_size
:
23729 case DW_OP_xderef_size
:
23730 return valx1
->v
.val_int
== valy1
->v
.val_int
;
23733 /* If splitting debug info, the use of DW_OP_GNU_addr_index
23734 can cause irrelevant differences in dw_loc_addr. */
23735 gcc_assert (valx1
->val_class
== dw_val_class_loc
23736 && valy1
->val_class
== dw_val_class_loc
23737 && (dwarf_split_debug_info
23738 || x
->dw_loc_addr
== y
->dw_loc_addr
));
23739 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
23740 case DW_OP_implicit_value
:
23741 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
23742 || valx2
->val_class
!= valy2
->val_class
)
23744 switch (valx2
->val_class
)
23746 case dw_val_class_const
:
23747 return valx2
->v
.val_int
== valy2
->v
.val_int
;
23748 case dw_val_class_vec
:
23749 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
23750 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
23751 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
23752 valx2
->v
.val_vec
.elt_size
23753 * valx2
->v
.val_vec
.length
) == 0;
23754 case dw_val_class_const_double
:
23755 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
23756 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
23757 case dw_val_class_addr
:
23758 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
23760 gcc_unreachable ();
23763 case DW_OP_bit_piece
:
23764 return valx1
->v
.val_int
== valy1
->v
.val_int
23765 && valx2
->v
.val_int
== valy2
->v
.val_int
;
23768 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
23769 case DW_OP_GNU_addr_index
:
23770 case DW_OP_GNU_const_index
:
23772 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
23773 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
23774 return rtx_equal_p (ax1
, ay1
);
23776 case DW_OP_GNU_implicit_pointer
:
23777 return valx1
->val_class
== dw_val_class_die_ref
23778 && valx1
->val_class
== valy1
->val_class
23779 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
23780 && valx2
->v
.val_int
== valy2
->v
.val_int
;
23781 case DW_OP_GNU_entry_value
:
23782 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
23783 case DW_OP_GNU_const_type
:
23784 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
23785 || valx2
->val_class
!= valy2
->val_class
)
23787 switch (valx2
->val_class
)
23789 case dw_val_class_const
:
23790 return valx2
->v
.val_int
== valy2
->v
.val_int
;
23791 case dw_val_class_vec
:
23792 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
23793 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
23794 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
23795 valx2
->v
.val_vec
.elt_size
23796 * valx2
->v
.val_vec
.length
) == 0;
23797 case dw_val_class_const_double
:
23798 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
23799 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
23801 gcc_unreachable ();
23803 case DW_OP_GNU_regval_type
:
23804 case DW_OP_GNU_deref_type
:
23805 return valx1
->v
.val_int
== valy1
->v
.val_int
23806 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
23807 case DW_OP_GNU_convert
:
23808 case DW_OP_GNU_reinterpret
:
23809 if (valx1
->val_class
!= valy1
->val_class
)
23811 if (valx1
->val_class
== dw_val_class_unsigned_const
)
23812 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
23813 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
23814 case DW_OP_GNU_parameter_ref
:
23815 return valx1
->val_class
== dw_val_class_die_ref
23816 && valx1
->val_class
== valy1
->val_class
23817 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
23819 /* Other codes have no operands. */
23824 /* Return true if DWARF location expressions X and Y are the same. */
23827 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
23829 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
23830 if (x
->dw_loc_opc
!= y
->dw_loc_opc
23831 || x
->dtprel
!= y
->dtprel
23832 || !compare_loc_operands (x
, y
))
23834 return x
== NULL
&& y
== NULL
;
23837 /* Hashtable helpers. */
23839 struct loc_list_hasher
: typed_noop_remove
<dw_loc_list_struct
>
23841 typedef dw_loc_list_struct value_type
;
23842 typedef dw_loc_list_struct compare_type
;
23843 static inline hashval_t
hash (const value_type
*);
23844 static inline bool equal (const value_type
*, const compare_type
*);
23847 /* Return precomputed hash of location list X. */
23850 loc_list_hasher::hash (const value_type
*x
)
23855 /* Return true if location lists A and B are the same. */
23858 loc_list_hasher::equal (const value_type
*a
, const compare_type
*b
)
23862 if (a
->hash
!= b
->hash
)
23864 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
23865 if (strcmp (a
->begin
, b
->begin
) != 0
23866 || strcmp (a
->end
, b
->end
) != 0
23867 || (a
->section
== NULL
) != (b
->section
== NULL
)
23868 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
23869 || !compare_locs (a
->expr
, b
->expr
))
23871 return a
== NULL
&& b
== NULL
;
23874 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
23877 /* Recursively optimize location lists referenced from DIE
23878 children and share them whenever possible. */
23881 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type htab
)
23886 dw_loc_list_struct
**slot
;
23888 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23889 if (AT_class (a
) == dw_val_class_loc_list
)
23891 dw_loc_list_ref list
= AT_loc_list (a
);
23892 /* TODO: perform some optimizations here, before hashing
23893 it and storing into the hash table. */
23894 hash_loc_list (list
);
23895 slot
= htab
.find_slot_with_hash (list
, list
->hash
, INSERT
);
23899 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
23902 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
23906 /* Recursively assign each location list a unique index into the debug_addr
23910 index_location_lists (dw_die_ref die
)
23916 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23917 if (AT_class (a
) == dw_val_class_loc_list
)
23919 dw_loc_list_ref list
= AT_loc_list (a
);
23920 dw_loc_list_ref curr
;
23921 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
23923 /* Don't index an entry that has already been indexed
23924 or won't be output. */
23925 if (curr
->begin_entry
!= NULL
23926 || (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
))
23930 = add_addr_table_entry (xstrdup (curr
->begin
),
23935 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
23938 /* Optimize location lists referenced from DIE
23939 children and share them whenever possible. */
23942 optimize_location_lists (dw_die_ref die
)
23944 loc_list_hash_type htab
;
23946 optimize_location_lists_1 (die
, htab
);
23950 /* Output stuff that dwarf requires at the end of every file,
23951 and generate the DWARF-2 debugging info. */
23954 dwarf2out_finish (const char *filename
)
23956 limbo_die_node
*node
, *next_node
;
23957 comdat_type_node
*ctnode
;
23958 hash_table
<comdat_type_hasher
> comdat_type_table
;
23960 dw_die_ref main_comp_unit_die
;
23962 /* PCH might result in DW_AT_producer string being restored from the
23963 header compilation, so always fill it with empty string initially
23964 and overwrite only here. */
23965 dw_attr_ref producer
= get_AT (comp_unit_die (), DW_AT_producer
);
23966 producer_string
= gen_producer_string ();
23967 producer
->dw_attr_val
.v
.val_str
->refcount
--;
23968 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
23970 gen_scheduled_generic_parms_dies ();
23971 gen_remaining_tmpl_value_param_die_attribute ();
23973 /* Add the name for the main input file now. We delayed this from
23974 dwarf2out_init to avoid complications with PCH. */
23975 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
23976 if (!IS_ABSOLUTE_PATH (filename
) || targetm
.force_at_comp_dir
)
23977 add_comp_dir_attribute (comp_unit_die ());
23978 else if (get_AT (comp_unit_die (), DW_AT_comp_dir
) == NULL
)
23981 htab_traverse (file_table
, file_table_relative_p
, &p
);
23983 add_comp_dir_attribute (comp_unit_die ());
23986 if (deferred_locations_list
)
23987 for (i
= 0; i
< deferred_locations_list
->length (); i
++)
23989 add_location_or_const_value_attribute (
23990 (*deferred_locations_list
)[i
].die
,
23991 (*deferred_locations_list
)[i
].variable
,
23996 /* Traverse the limbo die list, and add parent/child links. The only
23997 dies without parents that should be here are concrete instances of
23998 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
23999 For concrete instances, we can get the parent die from the abstract
24001 for (node
= limbo_die_list
; node
; node
= next_node
)
24003 dw_die_ref die
= node
->die
;
24004 next_node
= node
->next
;
24006 if (die
->die_parent
== NULL
)
24008 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
24010 if (origin
&& origin
->die_parent
)
24011 add_child_die (origin
->die_parent
, die
);
24012 else if (is_cu_die (die
))
24014 else if (seen_error ())
24015 /* It's OK to be confused by errors in the input. */
24016 add_child_die (comp_unit_die (), die
);
24019 /* In certain situations, the lexical block containing a
24020 nested function can be optimized away, which results
24021 in the nested function die being orphaned. Likewise
24022 with the return type of that nested function. Force
24023 this to be a child of the containing function.
24025 It may happen that even the containing function got fully
24026 inlined and optimized out. In that case we are lost and
24027 assign the empty child. This should not be big issue as
24028 the function is likely unreachable too. */
24029 gcc_assert (node
->created_for
);
24031 if (DECL_P (node
->created_for
))
24032 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
24033 else if (TYPE_P (node
->created_for
))
24034 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
24036 origin
= comp_unit_die ();
24038 add_child_die (origin
, die
);
24043 limbo_die_list
= NULL
;
24045 #if ENABLE_ASSERT_CHECKING
24047 dw_die_ref die
= comp_unit_die (), c
;
24048 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
24051 resolve_addr (comp_unit_die ());
24052 move_marked_base_types ();
24054 for (node
= deferred_asm_name
; node
; node
= node
->next
)
24056 tree decl
= node
->created_for
;
24057 /* When generating LTO bytecode we can not generate new assembler
24058 names at this point and all important decls got theirs via
24060 if ((!flag_generate_lto
|| DECL_ASSEMBLER_NAME_SET_P (decl
))
24061 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
24063 add_linkage_attr (node
->die
, decl
);
24064 move_linkage_attr (node
->die
);
24068 deferred_asm_name
= NULL
;
24070 /* Walk through the list of incomplete types again, trying once more to
24071 emit full debugging info for them. */
24072 retry_incomplete_types ();
24074 if (flag_eliminate_unused_debug_types
)
24075 prune_unused_types ();
24077 /* Generate separate COMDAT sections for type DIEs. */
24078 if (use_debug_types
)
24080 break_out_comdat_types (comp_unit_die ());
24082 /* Each new type_unit DIE was added to the limbo die list when created.
24083 Since these have all been added to comdat_type_list, clear the
24085 limbo_die_list
= NULL
;
24087 /* For each new comdat type unit, copy declarations for incomplete
24088 types to make the new unit self-contained (i.e., no direct
24089 references to the main compile unit). */
24090 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24091 copy_decls_for_unworthy_types (ctnode
->root_die
);
24092 copy_decls_for_unworthy_types (comp_unit_die ());
24094 /* In the process of copying declarations from one unit to another,
24095 we may have left some declarations behind that are no longer
24096 referenced. Prune them. */
24097 prune_unused_types ();
24100 /* Generate separate CUs for each of the include files we've seen.
24101 They will go into limbo_die_list. */
24102 if (flag_eliminate_dwarf2_dups
)
24103 break_out_includes (comp_unit_die ());
24105 /* Traverse the DIE's and add add sibling attributes to those DIE's
24106 that have children. */
24107 add_sibling_attributes (comp_unit_die ());
24108 for (node
= limbo_die_list
; node
; node
= node
->next
)
24109 add_sibling_attributes (node
->die
);
24110 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24111 add_sibling_attributes (ctnode
->root_die
);
24113 /* When splitting DWARF info, we put some attributes in the
24114 skeleton compile_unit DIE that remains in the .o, while
24115 most attributes go in the DWO compile_unit_die. */
24116 if (dwarf_split_debug_info
)
24117 main_comp_unit_die
= gen_compile_unit_die (NULL
);
24119 main_comp_unit_die
= comp_unit_die ();
24121 /* Output a terminator label for the .text section. */
24122 switch_to_section (text_section
);
24123 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
24124 if (cold_text_section
)
24126 switch_to_section (cold_text_section
);
24127 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
24130 /* We can only use the low/high_pc attributes if all of the code was
24132 if (!have_multiple_function_sections
24133 || (dwarf_version
< 3 && dwarf_strict
))
24135 /* Don't add if the CU has no associated code. */
24136 if (text_section_used
)
24137 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
24138 text_end_label
, true);
24144 bool range_list_added
= false;
24146 if (text_section_used
)
24147 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
24148 text_end_label
, &range_list_added
, true);
24149 if (cold_text_section_used
)
24150 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
24151 cold_end_label
, &range_list_added
, true);
24153 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
24155 if (DECL_IGNORED_P (fde
->decl
))
24157 if (!fde
->in_std_section
)
24158 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
24159 fde
->dw_fde_end
, &range_list_added
,
24161 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
24162 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
24163 fde
->dw_fde_second_end
, &range_list_added
,
24167 if (range_list_added
)
24169 /* We need to give .debug_loc and .debug_ranges an appropriate
24170 "base address". Use zero so that these addresses become
24171 absolute. Historically, we've emitted the unexpected
24172 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24173 Emit both to give time for other tools to adapt. */
24174 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
24175 if (! dwarf_strict
&& dwarf_version
< 4)
24176 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
24182 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24183 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
24184 debug_line_section_label
);
24187 add_AT_macptr (comp_unit_die (),
24188 dwarf_strict
? DW_AT_macro_info
: DW_AT_GNU_macros
,
24189 macinfo_section_label
);
24191 if (dwarf_split_debug_info
&& addr_index_table
!= NULL
)
24193 /* optimize_location_lists calculates the size of the lists,
24194 so index them first, and assign indices to the entries.
24195 Although optimize_location_lists will remove entries from
24196 the table, it only does so for duplicates, and therefore
24197 only reduces ref_counts to 1. */
24198 unsigned int index
= 0;
24199 index_location_lists (comp_unit_die ());
24200 htab_traverse_noresize (addr_index_table
,
24201 index_addr_table_entry
, &index
);
24203 if (have_location_lists
)
24204 optimize_location_lists (comp_unit_die ());
24206 save_macinfo_strings ();
24208 if (dwarf_split_debug_info
)
24210 unsigned int index
= 0;
24212 /* Add attributes common to skeleton compile_units and
24213 type_units. Because these attributes include strings, it
24214 must be done before freezing the string table. Top-level
24215 skeleton die attrs are added when the skeleton type unit is
24216 created, so ensure it is created by this point. */
24217 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
24218 (void) get_skeleton_type_unit ();
24219 htab_traverse_noresize (debug_str_hash
, index_string
, &index
);
24222 /* Output all of the compilation units. We put the main one last so that
24223 the offsets are available to output_pubnames. */
24224 for (node
= limbo_die_list
; node
; node
= node
->next
)
24225 output_comp_unit (node
->die
, 0);
24227 comdat_type_table
.create (100);
24228 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24230 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
24232 /* Don't output duplicate types. */
24233 if (*slot
!= HTAB_EMPTY_ENTRY
)
24236 /* Add a pointer to the line table for the main compilation unit
24237 so that the debugger can make sense of DW_AT_decl_file
24239 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24240 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
24241 (!dwarf_split_debug_info
24242 ? debug_line_section_label
24243 : debug_skeleton_line_section_label
));
24245 output_comdat_type_unit (ctnode
);
24248 comdat_type_table
.dispose ();
24250 /* The AT_pubnames attribute needs to go in all skeleton dies, including
24251 both the main_cu and all skeleton TUs. Making this call unconditional
24252 would end up either adding a second copy of the AT_pubnames attribute, or
24253 requiring a special case in add_top_level_skeleton_die_attrs. */
24254 if (!dwarf_split_debug_info
)
24255 add_AT_pubnames (comp_unit_die ());
24257 if (dwarf_split_debug_info
)
24260 unsigned char checksum
[16];
24261 struct md5_ctx ctx
;
24263 /* Compute a checksum of the comp_unit to use as the dwo_id. */
24264 md5_init_ctx (&ctx
);
24266 die_checksum (comp_unit_die (), &ctx
, &mark
);
24267 unmark_all_dies (comp_unit_die ());
24268 md5_finish_ctx (&ctx
, checksum
);
24270 /* Use the first 8 bytes of the checksum as the dwo_id,
24271 and add it to both comp-unit DIEs. */
24272 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
24273 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
24275 /* Add the base offset of the ranges table to the skeleton
24277 if (ranges_table_in_use
)
24278 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
24279 ranges_section_label
);
24281 switch_to_section (debug_addr_section
);
24282 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
24283 output_addr_table ();
24286 /* Output the main compilation unit if non-empty or if .debug_macinfo
24287 or .debug_macro will be emitted. */
24288 output_comp_unit (comp_unit_die (), have_macinfo
);
24290 if (dwarf_split_debug_info
&& info_section_emitted
)
24291 output_skeleton_debug_sections (main_comp_unit_die
);
24293 /* Output the abbreviation table. */
24294 if (abbrev_die_table_in_use
!= 1)
24296 switch_to_section (debug_abbrev_section
);
24297 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
24298 output_abbrev_section ();
24301 /* Output location list section if necessary. */
24302 if (have_location_lists
)
24304 /* Output the location lists info. */
24305 switch_to_section (debug_loc_section
);
24306 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
24307 output_location_lists (comp_unit_die ());
24310 output_pubtables ();
24312 /* Output the address range information if a CU (.debug_info section)
24313 was emitted. We output an empty table even if we had no functions
24314 to put in it. This because the consumer has no way to tell the
24315 difference between an empty table that we omitted and failure to
24316 generate a table that would have contained data. */
24317 if (info_section_emitted
)
24319 unsigned long aranges_length
= size_of_aranges ();
24321 switch_to_section (debug_aranges_section
);
24322 output_aranges (aranges_length
);
24325 /* Output ranges section if necessary. */
24326 if (ranges_table_in_use
)
24328 switch_to_section (debug_ranges_section
);
24329 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
24333 /* Have to end the macro section. */
24336 switch_to_section (debug_macinfo_section
);
24337 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
24339 dw2_asm_output_data (1, 0, "End compilation unit");
24342 /* Output the source line correspondence table. We must do this
24343 even if there is no line information. Otherwise, on an empty
24344 translation unit, we will generate a present, but empty,
24345 .debug_info section. IRIX 6.5 `nm' will then complain when
24346 examining the file. This is done late so that any filenames
24347 used by the debug_info section are marked as 'used'. */
24348 switch_to_section (debug_line_section
);
24349 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
24350 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
24351 output_line_info (false);
24353 if (dwarf_split_debug_info
&& info_section_emitted
)
24355 switch_to_section (debug_skeleton_line_section
);
24356 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
24357 output_line_info (true);
24360 /* If we emitted any indirect strings, output the string table too. */
24361 if (debug_str_hash
|| skeleton_debug_str_hash
)
24362 output_indirect_strings ();
24365 #include "gt-dwarf2out.h"