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"
65 #include "stringpool.h"
66 #include "stor-layout.h"
70 #include "hash-table.h"
73 #include "hard-reg-set.h"
75 #include "insn-config.h"
82 #include "dwarf2out.h"
83 #include "dwarf2asm.h"
87 #include "diagnostic.h"
88 #include "tree-pretty-print.h"
91 #include "common/common-target.h"
92 #include "langhooks.h"
100 #include "gdb/gdb-index.h"
102 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
103 static rtx last_var_location_insn
;
104 static rtx cached_next_real_insn
;
106 #ifdef VMS_DEBUGGING_INFO
107 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
109 /* Define this macro to be a nonzero value if the directory specifications
110 which are output in the debug info should end with a separator. */
111 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
112 /* Define this macro to evaluate to a nonzero value if GCC should refrain
113 from generating indirect strings in DWARF2 debug information, for instance
114 if your target is stuck with an old version of GDB that is unable to
115 process them properly or uses VMS Debug. */
116 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
118 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
119 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
122 /* ??? Poison these here until it can be done generically. They've been
123 totally replaced in this file; make sure it stays that way. */
124 #undef DWARF2_UNWIND_INFO
125 #undef DWARF2_FRAME_INFO
126 #if (GCC_VERSION >= 3000)
127 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
130 /* The size of the target's pointer type. */
132 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
135 /* Array of RTXes referenced by the debugging information, which therefore
136 must be kept around forever. */
137 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
139 /* A pointer to the base of a list of incomplete types which might be
140 completed at some later time. incomplete_types_list needs to be a
141 vec<tree, va_gc> *because we want to tell the garbage collector about
143 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
145 /* A pointer to the base of a table of references to declaration
146 scopes. This table is a display which tracks the nesting
147 of declaration scopes at the current scope and containing
148 scopes. This table is used to find the proper place to
149 define type declaration DIE's. */
150 static GTY(()) vec
<tree
, va_gc
> *decl_scope_table
;
152 /* Pointers to various DWARF2 sections. */
153 static GTY(()) section
*debug_info_section
;
154 static GTY(()) section
*debug_skeleton_info_section
;
155 static GTY(()) section
*debug_abbrev_section
;
156 static GTY(()) section
*debug_skeleton_abbrev_section
;
157 static GTY(()) section
*debug_aranges_section
;
158 static GTY(()) section
*debug_addr_section
;
159 static GTY(()) section
*debug_macinfo_section
;
160 static GTY(()) section
*debug_line_section
;
161 static GTY(()) section
*debug_skeleton_line_section
;
162 static GTY(()) section
*debug_loc_section
;
163 static GTY(()) section
*debug_pubnames_section
;
164 static GTY(()) section
*debug_pubtypes_section
;
165 static GTY(()) section
*debug_str_section
;
166 static GTY(()) section
*debug_str_dwo_section
;
167 static GTY(()) section
*debug_str_offsets_section
;
168 static GTY(()) section
*debug_ranges_section
;
169 static GTY(()) section
*debug_frame_section
;
171 /* Maximum size (in bytes) of an artificially generated label. */
172 #define MAX_ARTIFICIAL_LABEL_BYTES 30
174 /* According to the (draft) DWARF 3 specification, the initial length
175 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
176 bytes are 0xffffffff, followed by the length stored in the next 8
179 However, the SGI/MIPS ABI uses an initial length which is equal to
180 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
182 #ifndef DWARF_INITIAL_LENGTH_SIZE
183 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
186 /* Round SIZE up to the nearest BOUNDARY. */
187 #define DWARF_ROUND(SIZE,BOUNDARY) \
188 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
190 /* CIE identifier. */
191 #if HOST_BITS_PER_WIDE_INT >= 64
192 #define DWARF_CIE_ID \
193 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
195 #define DWARF_CIE_ID DW_CIE_ID
199 /* A vector for a table that contains frame description
200 information for each routine. */
201 #define NOT_INDEXED (-1U)
202 #define NO_INDEX_ASSIGNED (-2U)
204 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
206 struct GTY(()) indirect_string_node
{
208 unsigned int refcount
;
209 enum dwarf_form form
;
214 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
216 /* With split_debug_info, both the comp_dir and dwo_name go in the
217 main object file, rather than the dwo, similar to the force_direct
218 parameter elsewhere but with additional complications:
220 1) The string is needed in both the main object file and the dwo.
221 That is, the comp_dir and dwo_name will appear in both places.
223 2) Strings can use three forms: DW_FORM_string, DW_FORM_strp or
224 DW_FORM_GNU_str_index.
226 3) GCC chooses the form to use late, depending on the size and
229 Rather than forcing the all debug string handling functions and
230 callers to deal with these complications, simply use a separate,
231 special-cased string table for any attribute that should go in the
232 main object file. This limits the complexity to just the places
235 static GTY ((param_is (struct indirect_string_node
)))
236 htab_t skeleton_debug_str_hash
;
238 static GTY(()) int dw2_string_counter
;
240 /* True if the compilation unit places functions in more than one section. */
241 static GTY(()) bool have_multiple_function_sections
= false;
243 /* Whether the default text and cold text sections have been used at all. */
245 static GTY(()) bool text_section_used
= false;
246 static GTY(()) bool cold_text_section_used
= false;
248 /* The default cold text section. */
249 static GTY(()) section
*cold_text_section
;
251 /* The DIE for C++1y 'auto' in a function return type. */
252 static GTY(()) dw_die_ref auto_die
;
254 /* The DIE for C++1y 'decltype(auto)' in a function return type. */
255 static GTY(()) dw_die_ref decltype_auto_die
;
257 /* Forward declarations for functions defined in this file. */
259 static char *stripattributes (const char *);
260 static void output_call_frame_info (int);
261 static void dwarf2out_note_section_used (void);
263 /* Personality decl of current unit. Used only when assembler does not support
265 static GTY(()) rtx current_unit_personality
;
267 /* Data and reference forms for relocatable data. */
268 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
269 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
271 #ifndef DEBUG_FRAME_SECTION
272 #define DEBUG_FRAME_SECTION ".debug_frame"
275 #ifndef FUNC_BEGIN_LABEL
276 #define FUNC_BEGIN_LABEL "LFB"
279 #ifndef FUNC_END_LABEL
280 #define FUNC_END_LABEL "LFE"
283 #ifndef PROLOGUE_END_LABEL
284 #define PROLOGUE_END_LABEL "LPE"
287 #ifndef EPILOGUE_BEGIN_LABEL
288 #define EPILOGUE_BEGIN_LABEL "LEB"
291 #ifndef FRAME_BEGIN_LABEL
292 #define FRAME_BEGIN_LABEL "Lframe"
294 #define CIE_AFTER_SIZE_LABEL "LSCIE"
295 #define CIE_END_LABEL "LECIE"
296 #define FDE_LABEL "LSFDE"
297 #define FDE_AFTER_SIZE_LABEL "LASFDE"
298 #define FDE_END_LABEL "LEFDE"
299 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
300 #define LINE_NUMBER_END_LABEL "LELT"
301 #define LN_PROLOG_AS_LABEL "LASLTP"
302 #define LN_PROLOG_END_LABEL "LELTP"
303 #define DIE_LABEL_PREFIX "DW"
305 /* Match the base name of a file to the base name of a compilation unit. */
308 matches_main_base (const char *path
)
310 /* Cache the last query. */
311 static const char *last_path
= NULL
;
312 static int last_match
= 0;
313 if (path
!= last_path
)
316 int length
= base_of_path (path
, &base
);
318 last_match
= (length
== main_input_baselength
319 && memcmp (base
, main_input_basename
, length
) == 0);
324 #ifdef DEBUG_DEBUG_STRUCT
327 dump_struct_debug (tree type
, enum debug_info_usage usage
,
328 enum debug_struct_file criterion
, int generic
,
329 int matches
, int result
)
331 /* Find the type name. */
332 tree type_decl
= TYPE_STUB_DECL (type
);
334 const char *name
= 0;
335 if (TREE_CODE (t
) == TYPE_DECL
)
338 name
= IDENTIFIER_POINTER (t
);
340 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
342 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
343 matches
? "bas" : "hdr",
344 generic
? "gen" : "ord",
345 usage
== DINFO_USAGE_DFN
? ";" :
346 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
348 (void*) type_decl
, name
);
351 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
352 dump_struct_debug (type, usage, criterion, generic, matches, result)
356 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
362 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
364 enum debug_struct_file criterion
;
366 bool generic
= lang_hooks
.types
.generic_p (type
);
369 criterion
= debug_struct_generic
[usage
];
371 criterion
= debug_struct_ordinary
[usage
];
373 if (criterion
== DINFO_STRUCT_FILE_NONE
)
374 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
375 if (criterion
== DINFO_STRUCT_FILE_ANY
)
376 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
378 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
380 if (type_decl
!= NULL
)
382 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
383 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
385 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
386 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
389 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
392 /* Return a pointer to a copy of the section string name S with all
393 attributes stripped off, and an asterisk prepended (for assemble_name). */
396 stripattributes (const char *s
)
398 char *stripped
= XNEWVEC (char, strlen (s
) + 2);
403 while (*s
&& *s
!= ',')
410 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
411 switch to the data section instead, and write out a synthetic start label
412 for collect2 the first time around. */
415 switch_to_eh_frame_section (bool back
)
419 #ifdef EH_FRAME_SECTION_NAME
420 if (eh_frame_section
== 0)
424 if (EH_TABLES_CAN_BE_READ_ONLY
)
430 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
432 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
434 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
437 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
438 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
439 && (per_encoding
& 0x70) != DW_EH_PE_absptr
440 && (per_encoding
& 0x70) != DW_EH_PE_aligned
441 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
442 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
443 ? 0 : SECTION_WRITE
);
446 flags
= SECTION_WRITE
;
447 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
449 #endif /* EH_FRAME_SECTION_NAME */
451 if (eh_frame_section
)
452 switch_to_section (eh_frame_section
);
455 /* We have no special eh_frame section. Put the information in
456 the data section and emit special labels to guide collect2. */
457 switch_to_section (data_section
);
461 label
= get_file_function_name ("F");
462 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
463 targetm
.asm_out
.globalize_label (asm_out_file
,
464 IDENTIFIER_POINTER (label
));
465 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
470 /* Switch [BACK] to the eh or debug frame table section, depending on
474 switch_to_frame_table_section (int for_eh
, bool back
)
477 switch_to_eh_frame_section (back
);
480 if (!debug_frame_section
)
481 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
482 SECTION_DEBUG
, NULL
);
483 switch_to_section (debug_frame_section
);
487 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
489 enum dw_cfi_oprnd_type
490 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
495 case DW_CFA_GNU_window_save
:
496 case DW_CFA_remember_state
:
497 case DW_CFA_restore_state
:
498 return dw_cfi_oprnd_unused
;
501 case DW_CFA_advance_loc1
:
502 case DW_CFA_advance_loc2
:
503 case DW_CFA_advance_loc4
:
504 case DW_CFA_MIPS_advance_loc8
:
505 return dw_cfi_oprnd_addr
;
508 case DW_CFA_offset_extended
:
510 case DW_CFA_offset_extended_sf
:
511 case DW_CFA_def_cfa_sf
:
513 case DW_CFA_restore_extended
:
514 case DW_CFA_undefined
:
515 case DW_CFA_same_value
:
516 case DW_CFA_def_cfa_register
:
517 case DW_CFA_register
:
518 case DW_CFA_expression
:
519 return dw_cfi_oprnd_reg_num
;
521 case DW_CFA_def_cfa_offset
:
522 case DW_CFA_GNU_args_size
:
523 case DW_CFA_def_cfa_offset_sf
:
524 return dw_cfi_oprnd_offset
;
526 case DW_CFA_def_cfa_expression
:
527 return dw_cfi_oprnd_loc
;
534 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
536 enum dw_cfi_oprnd_type
537 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
542 case DW_CFA_def_cfa_sf
:
544 case DW_CFA_offset_extended_sf
:
545 case DW_CFA_offset_extended
:
546 return dw_cfi_oprnd_offset
;
548 case DW_CFA_register
:
549 return dw_cfi_oprnd_reg_num
;
551 case DW_CFA_expression
:
552 return dw_cfi_oprnd_loc
;
555 return dw_cfi_oprnd_unused
;
559 /* Output one FDE. */
562 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
563 char *section_start_label
, int fde_encoding
, char *augmentation
,
564 bool any_lsda_needed
, int lsda_encoding
)
566 const char *begin
, *end
;
567 static unsigned int j
;
570 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
572 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
574 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
575 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
576 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
577 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
578 " indicating 64-bit DWARF extension");
579 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
581 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
584 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
586 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
587 debug_frame_section
, "FDE CIE offset");
589 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
590 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
594 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
595 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
596 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
597 "FDE initial location");
598 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
599 end
, begin
, "FDE address range");
603 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
604 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
611 int size
= size_of_encoded_value (lsda_encoding
);
613 if (lsda_encoding
== DW_EH_PE_aligned
)
615 int offset
= ( 4 /* Length */
617 + 2 * size_of_encoded_value (fde_encoding
)
618 + 1 /* Augmentation size */ );
619 int pad
= -offset
& (PTR_SIZE
- 1);
622 gcc_assert (size_of_uleb128 (size
) == 1);
625 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
627 if (fde
->uses_eh_lsda
)
629 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
630 fde
->funcdef_number
);
631 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
632 gen_rtx_SYMBOL_REF (Pmode
, l1
),
634 "Language Specific Data Area");
638 if (lsda_encoding
== DW_EH_PE_aligned
)
639 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
640 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
641 "Language Specific Data Area (none)");
645 dw2_asm_output_data_uleb128 (0, "Augmentation size");
648 /* Loop through the Call Frame Instructions associated with this FDE. */
649 fde
->dw_fde_current_label
= begin
;
651 size_t from
, until
, i
;
654 until
= vec_safe_length (fde
->dw_fde_cfi
);
656 if (fde
->dw_fde_second_begin
== NULL
)
659 until
= fde
->dw_fde_switch_cfi_index
;
661 from
= fde
->dw_fde_switch_cfi_index
;
663 for (i
= from
; i
< until
; i
++)
664 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
667 /* If we are to emit a ref/link from function bodies to their frame tables,
668 do it now. This is typically performed to make sure that tables
669 associated with functions are dragged with them and not discarded in
670 garbage collecting links. We need to do this on a per function basis to
671 cope with -ffunction-sections. */
673 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
674 /* Switch to the function section, emit the ref to the tables, and
675 switch *back* into the table section. */
676 switch_to_section (function_section (fde
->decl
));
677 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
678 switch_to_frame_table_section (for_eh
, true);
681 /* Pad the FDE out to an address sized boundary. */
682 ASM_OUTPUT_ALIGN (asm_out_file
,
683 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
684 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
689 /* Return true if frame description entry FDE is needed for EH. */
692 fde_needed_for_eh_p (dw_fde_ref fde
)
694 if (flag_asynchronous_unwind_tables
)
697 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
700 if (fde
->uses_eh_lsda
)
703 /* If exceptions are enabled, we have collected nothrow info. */
704 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
710 /* Output the call frame information used to record information
711 that relates to calculating the frame pointer, and records the
712 location of saved registers. */
715 output_call_frame_info (int for_eh
)
720 char l1
[20], l2
[20], section_start_label
[20];
721 bool any_lsda_needed
= false;
722 char augmentation
[6];
723 int augmentation_size
;
724 int fde_encoding
= DW_EH_PE_absptr
;
725 int per_encoding
= DW_EH_PE_absptr
;
726 int lsda_encoding
= DW_EH_PE_absptr
;
728 rtx personality
= NULL
;
731 /* Don't emit a CIE if there won't be any FDEs. */
735 /* Nothing to do if the assembler's doing it all. */
736 if (dwarf2out_do_cfi_asm ())
739 /* If we don't have any functions we'll want to unwind out of, don't emit
740 any EH unwind information. If we make FDEs linkonce, we may have to
741 emit an empty label for an FDE that wouldn't otherwise be emitted. We
742 want to avoid having an FDE kept around when the function it refers to
743 is discarded. Example where this matters: a primary function template
744 in C++ requires EH information, an explicit specialization doesn't. */
747 bool any_eh_needed
= false;
749 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
751 if (fde
->uses_eh_lsda
)
752 any_eh_needed
= any_lsda_needed
= true;
753 else if (fde_needed_for_eh_p (fde
))
754 any_eh_needed
= true;
755 else if (TARGET_USES_WEAK_UNWIND_INFO
)
756 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
763 /* We're going to be generating comments, so turn on app. */
767 /* Switch to the proper frame section, first time. */
768 switch_to_frame_table_section (for_eh
, false);
770 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
771 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
773 /* Output the CIE. */
774 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
775 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
776 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
777 dw2_asm_output_data (4, 0xffffffff,
778 "Initial length escape value indicating 64-bit DWARF extension");
779 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
780 "Length of Common Information Entry");
781 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
783 /* Now that the CIE pointer is PC-relative for EH,
784 use 0 to identify the CIE. */
785 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
786 (for_eh
? 0 : DWARF_CIE_ID
),
787 "CIE Identifier Tag");
789 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
790 use CIE version 1, unless that would produce incorrect results
791 due to overflowing the return register column. */
792 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
794 if (return_reg
>= 256 || dwarf_version
> 2)
796 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
799 augmentation_size
= 0;
801 personality
= current_unit_personality
;
807 z Indicates that a uleb128 is present to size the
808 augmentation section.
809 L Indicates the encoding (and thus presence) of
810 an LSDA pointer in the FDE augmentation.
811 R Indicates a non-default pointer encoding for
813 P Indicates the presence of an encoding + language
814 personality routine in the CIE augmentation. */
816 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
817 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
818 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
820 p
= augmentation
+ 1;
824 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
825 assemble_external_libcall (personality
);
830 augmentation_size
+= 1;
832 if (fde_encoding
!= DW_EH_PE_absptr
)
835 augmentation_size
+= 1;
837 if (p
> augmentation
+ 1)
839 augmentation
[0] = 'z';
843 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
844 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
846 int offset
= ( 4 /* Length */
848 + 1 /* CIE version */
849 + strlen (augmentation
) + 1 /* Augmentation */
850 + size_of_uleb128 (1) /* Code alignment */
851 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
853 + 1 /* Augmentation size */
854 + 1 /* Personality encoding */ );
855 int pad
= -offset
& (PTR_SIZE
- 1);
857 augmentation_size
+= pad
;
859 /* Augmentations should be small, so there's scarce need to
860 iterate for a solution. Die if we exceed one uleb128 byte. */
861 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
865 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
866 if (dw_cie_version
>= 4)
868 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
869 dw2_asm_output_data (1, 0, "CIE Segment Size");
871 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
872 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
873 "CIE Data Alignment Factor");
875 if (dw_cie_version
== 1)
876 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
878 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
882 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
885 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
886 eh_data_format_name (per_encoding
));
887 dw2_asm_output_encoded_addr_rtx (per_encoding
,
893 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
894 eh_data_format_name (lsda_encoding
));
896 if (fde_encoding
!= DW_EH_PE_absptr
)
897 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
898 eh_data_format_name (fde_encoding
));
901 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
902 output_cfi (cfi
, NULL
, for_eh
);
904 /* Pad the CIE out to an address sized boundary. */
905 ASM_OUTPUT_ALIGN (asm_out_file
,
906 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
907 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
909 /* Loop through all of the FDE's. */
910 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
914 /* Don't emit EH unwind info for leaf functions that don't need it. */
915 if (for_eh
&& !fde_needed_for_eh_p (fde
))
918 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
919 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
920 augmentation
, any_lsda_needed
, lsda_encoding
);
923 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
924 dw2_asm_output_data (4, 0, "End of Table");
926 /* Turn off app to make assembly quicker. */
931 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
934 dwarf2out_do_cfi_startproc (bool second
)
938 rtx personality
= get_personality_function (current_function_decl
);
940 fprintf (asm_out_file
, "\t.cfi_startproc\n");
944 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
947 /* ??? The GAS support isn't entirely consistent. We have to
948 handle indirect support ourselves, but PC-relative is done
949 in the assembler. Further, the assembler can't handle any
950 of the weirder relocation types. */
951 if (enc
& DW_EH_PE_indirect
)
952 ref
= dw2_force_const_mem (ref
, true);
954 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
955 output_addr_const (asm_out_file
, ref
);
956 fputc ('\n', asm_out_file
);
959 if (crtl
->uses_eh_lsda
)
963 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
964 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
965 current_function_funcdef_no
);
966 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
967 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
969 if (enc
& DW_EH_PE_indirect
)
970 ref
= dw2_force_const_mem (ref
, true);
972 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
973 output_addr_const (asm_out_file
, ref
);
974 fputc ('\n', asm_out_file
);
978 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
979 this allocation may be done before pass_final. */
982 dwarf2out_alloc_current_fde (void)
986 fde
= ggc_alloc_cleared_dw_fde_node ();
987 fde
->decl
= current_function_decl
;
988 fde
->funcdef_number
= current_function_funcdef_no
;
989 fde
->fde_index
= vec_safe_length (fde_vec
);
990 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
991 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
992 fde
->nothrow
= crtl
->nothrow
;
993 fde
->drap_reg
= INVALID_REGNUM
;
994 fde
->vdrap_reg
= INVALID_REGNUM
;
996 /* Record the FDE associated with this function. */
998 vec_safe_push (fde_vec
, fde
);
1003 /* Output a marker (i.e. a label) for the beginning of a function, before
1007 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1008 const char *file ATTRIBUTE_UNUSED
)
1010 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1016 current_function_func_begin_label
= NULL
;
1018 do_frame
= dwarf2out_do_frame ();
1020 /* ??? current_function_func_begin_label is also used by except.c for
1021 call-site information. We must emit this label if it might be used. */
1023 && (!flag_exceptions
1024 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1027 fnsec
= function_section (current_function_decl
);
1028 switch_to_section (fnsec
);
1029 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1030 current_function_funcdef_no
);
1031 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1032 current_function_funcdef_no
);
1033 dup_label
= xstrdup (label
);
1034 current_function_func_begin_label
= dup_label
;
1036 /* We can elide the fde allocation if we're not emitting debug info. */
1040 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1041 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1042 would include pass_dwarf2_frame. If we've not created the FDE yet,
1046 fde
= dwarf2out_alloc_current_fde ();
1048 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1049 fde
->dw_fde_begin
= dup_label
;
1050 fde
->dw_fde_current_label
= dup_label
;
1051 fde
->in_std_section
= (fnsec
== text_section
1052 || (cold_text_section
&& fnsec
== cold_text_section
));
1054 /* We only want to output line number information for the genuine dwarf2
1055 prologue case, not the eh frame case. */
1056 #ifdef DWARF2_DEBUGGING_INFO
1058 dwarf2out_source_line (line
, file
, 0, true);
1061 if (dwarf2out_do_cfi_asm ())
1062 dwarf2out_do_cfi_startproc (false);
1065 rtx personality
= get_personality_function (current_function_decl
);
1066 if (!current_unit_personality
)
1067 current_unit_personality
= personality
;
1069 /* We cannot keep a current personality per function as without CFI
1070 asm, at the point where we emit the CFI data, there is no current
1071 function anymore. */
1072 if (personality
&& current_unit_personality
!= personality
)
1073 sorry ("multiple EH personalities are supported only with assemblers "
1074 "supporting .cfi_personality directive");
1078 /* Output a marker (i.e. a label) for the end of the generated code
1079 for a function prologue. This gets called *after* the prologue code has
1083 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1084 const char *file ATTRIBUTE_UNUSED
)
1086 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1088 /* Output a label to mark the endpoint of the code generated for this
1090 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1091 current_function_funcdef_no
);
1092 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1093 current_function_funcdef_no
);
1094 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1097 /* Output a marker (i.e. a label) for the beginning of the generated code
1098 for a function epilogue. This gets called *before* the prologue code has
1102 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1103 const char *file ATTRIBUTE_UNUSED
)
1105 dw_fde_ref fde
= cfun
->fde
;
1106 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1108 if (fde
->dw_fde_vms_begin_epilogue
)
1111 /* Output a label to mark the endpoint of the code generated for this
1113 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1114 current_function_funcdef_no
);
1115 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1116 current_function_funcdef_no
);
1117 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1120 /* Output a marker (i.e. a label) for the absolute end of the generated code
1121 for a function definition. This gets called *after* the epilogue code has
1125 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1126 const char *file ATTRIBUTE_UNUSED
)
1129 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1131 last_var_location_insn
= NULL_RTX
;
1132 cached_next_real_insn
= NULL_RTX
;
1134 if (dwarf2out_do_cfi_asm ())
1135 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1137 /* Output a label to mark the endpoint of the code generated for this
1139 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1140 current_function_funcdef_no
);
1141 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1143 gcc_assert (fde
!= NULL
);
1144 if (fde
->dw_fde_second_begin
== NULL
)
1145 fde
->dw_fde_end
= xstrdup (label
);
1149 dwarf2out_frame_finish (void)
1151 /* Output call frame information. */
1152 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1153 output_call_frame_info (0);
1155 /* Output another copy for the unwinder. */
1156 if ((flag_unwind_tables
|| flag_exceptions
)
1157 && targetm_common
.except_unwind_info (&global_options
) == UI_DWARF2
)
1158 output_call_frame_info (1);
1161 /* Note that the current function section is being used for code. */
1164 dwarf2out_note_section_used (void)
1166 section
*sec
= current_function_section ();
1167 if (sec
== text_section
)
1168 text_section_used
= true;
1169 else if (sec
== cold_text_section
)
1170 cold_text_section_used
= true;
1173 static void var_location_switch_text_section (void);
1174 static void set_cur_line_info_table (section
*);
1177 dwarf2out_switch_text_section (void)
1180 dw_fde_ref fde
= cfun
->fde
;
1182 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1184 if (!in_cold_section_p
)
1186 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1187 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1188 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1192 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1193 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1194 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1196 have_multiple_function_sections
= true;
1198 /* There is no need to mark used sections when not debugging. */
1199 if (cold_text_section
!= NULL
)
1200 dwarf2out_note_section_used ();
1202 if (dwarf2out_do_cfi_asm ())
1203 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1205 /* Now do the real section switch. */
1206 sect
= current_function_section ();
1207 switch_to_section (sect
);
1209 fde
->second_in_std_section
1210 = (sect
== text_section
1211 || (cold_text_section
&& sect
== cold_text_section
));
1213 if (dwarf2out_do_cfi_asm ())
1214 dwarf2out_do_cfi_startproc (true);
1216 var_location_switch_text_section ();
1218 if (cold_text_section
!= NULL
)
1219 set_cur_line_info_table (sect
);
1222 /* And now, the subset of the debugging information support code necessary
1223 for emitting location expressions. */
1225 /* Data about a single source file. */
1226 struct GTY(()) dwarf_file_data
{
1227 const char * filename
;
1231 typedef struct GTY(()) deferred_locations_struct
1235 } deferred_locations
;
1238 static GTY(()) vec
<deferred_locations
, va_gc
> *deferred_locations_list
;
1241 /* Describe an entry into the .debug_addr section. */
1245 ate_kind_rtx_dtprel
,
1249 typedef struct GTY(()) addr_table_entry_struct
{
1251 unsigned int refcount
;
1253 union addr_table_entry_struct_union
1255 rtx
GTY ((tag ("0"))) rtl
;
1256 char * GTY ((tag ("1"))) label
;
1258 GTY ((desc ("%1.kind"))) addr
;
1262 /* Location lists are ranges + location descriptions for that range,
1263 so you can track variables that are in different places over
1264 their entire life. */
1265 typedef struct GTY(()) dw_loc_list_struct
{
1266 dw_loc_list_ref dw_loc_next
;
1267 const char *begin
; /* Label and addr_entry for start of range */
1268 addr_table_entry
*begin_entry
;
1269 const char *end
; /* Label for end of range */
1270 char *ll_symbol
; /* Label for beginning of location list.
1271 Only on head of list */
1272 const char *section
; /* Section this loclist is relative to */
1273 dw_loc_descr_ref expr
;
1275 /* True if all addresses in this and subsequent lists are known to be
1278 /* True if this list has been replaced by dw_loc_next. */
1281 /* True if the range should be emitted even if begin and end
1286 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
1288 /* Convert a DWARF stack opcode into its string name. */
1291 dwarf_stack_op_name (unsigned int op
)
1293 const char *name
= get_DW_OP_name (op
);
1298 return "OP_<unknown>";
1301 /* Return a pointer to a newly allocated location description. Location
1302 descriptions are simple expression terms that can be strung
1303 together to form more complicated location (address) descriptions. */
1305 static inline dw_loc_descr_ref
1306 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1307 unsigned HOST_WIDE_INT oprnd2
)
1309 dw_loc_descr_ref descr
= ggc_alloc_cleared_dw_loc_descr_node ();
1311 descr
->dw_loc_opc
= op
;
1312 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1313 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1314 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1315 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1316 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1317 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1322 /* Return a pointer to a newly allocated location description for
1325 static inline dw_loc_descr_ref
1326 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
1329 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1332 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
1335 /* Add a location description term to a location description expression. */
1338 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1340 dw_loc_descr_ref
*d
;
1342 /* Find the end of the chain. */
1343 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1349 /* Compare two location operands for exact equality. */
1352 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1354 if (a
->val_class
!= b
->val_class
)
1356 switch (a
->val_class
)
1358 case dw_val_class_none
:
1360 case dw_val_class_addr
:
1361 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1363 case dw_val_class_offset
:
1364 case dw_val_class_unsigned_const
:
1365 case dw_val_class_const
:
1366 case dw_val_class_range_list
:
1367 case dw_val_class_lineptr
:
1368 case dw_val_class_macptr
:
1369 /* These are all HOST_WIDE_INT, signed or unsigned. */
1370 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1372 case dw_val_class_loc
:
1373 return a
->v
.val_loc
== b
->v
.val_loc
;
1374 case dw_val_class_loc_list
:
1375 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1376 case dw_val_class_die_ref
:
1377 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1378 case dw_val_class_fde_ref
:
1379 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1380 case dw_val_class_lbl_id
:
1381 case dw_val_class_high_pc
:
1382 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1383 case dw_val_class_str
:
1384 return a
->v
.val_str
== b
->v
.val_str
;
1385 case dw_val_class_flag
:
1386 return a
->v
.val_flag
== b
->v
.val_flag
;
1387 case dw_val_class_file
:
1388 return a
->v
.val_file
== b
->v
.val_file
;
1389 case dw_val_class_decl_ref
:
1390 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1392 case dw_val_class_const_double
:
1393 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1394 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1396 case dw_val_class_vec
:
1398 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1399 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1401 return (a_len
== b_len
1402 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1405 case dw_val_class_data8
:
1406 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1408 case dw_val_class_vms_delta
:
1409 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1410 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1415 /* Compare two location atoms for exact equality. */
1418 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1420 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1423 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1424 address size, but since we always allocate cleared storage it
1425 should be zero for other types of locations. */
1426 if (a
->dtprel
!= b
->dtprel
)
1429 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1430 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1433 /* Compare two complete location expressions for exact equality. */
1436 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1442 if (a
== NULL
|| b
== NULL
)
1444 if (!loc_descr_equal_p_1 (a
, b
))
1453 /* Add a constant OFFSET to a location expression. */
1456 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
1458 dw_loc_descr_ref loc
;
1461 gcc_assert (*list_head
!= NULL
);
1466 /* Find the end of the chain. */
1467 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1471 if (loc
->dw_loc_opc
== DW_OP_fbreg
1472 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1473 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1474 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1475 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1477 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1478 offset. Don't optimize if an signed integer overflow would happen. */
1480 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1481 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1484 else if (offset
> 0)
1485 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1489 loc
->dw_loc_next
= int_loc_descriptor (-offset
);
1490 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1494 /* Add a constant OFFSET to a location list. */
1497 loc_list_plus_const (dw_loc_list_ref list_head
, HOST_WIDE_INT offset
)
1500 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1501 loc_descr_plus_const (&d
->expr
, offset
);
1504 #define DWARF_REF_SIZE \
1505 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1507 static unsigned long int get_base_type_offset (dw_die_ref
);
1509 /* Return the size of a location descriptor. */
1511 static unsigned long
1512 size_of_loc_descr (dw_loc_descr_ref loc
)
1514 unsigned long size
= 1;
1516 switch (loc
->dw_loc_opc
)
1519 size
+= DWARF2_ADDR_SIZE
;
1521 case DW_OP_GNU_addr_index
:
1522 case DW_OP_GNU_const_index
:
1523 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1524 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1543 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1546 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1551 case DW_OP_plus_uconst
:
1552 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1590 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1593 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1596 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1599 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1600 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1603 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1605 case DW_OP_bit_piece
:
1606 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1607 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1609 case DW_OP_deref_size
:
1610 case DW_OP_xderef_size
:
1619 case DW_OP_call_ref
:
1620 size
+= DWARF_REF_SIZE
;
1622 case DW_OP_implicit_value
:
1623 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1624 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1626 case DW_OP_GNU_implicit_pointer
:
1627 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1629 case DW_OP_GNU_entry_value
:
1631 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1632 size
+= size_of_uleb128 (op_size
) + op_size
;
1635 case DW_OP_GNU_const_type
:
1638 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1639 size
+= size_of_uleb128 (o
) + 1;
1640 switch (loc
->dw_loc_oprnd2
.val_class
)
1642 case dw_val_class_vec
:
1643 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1644 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1646 case dw_val_class_const
:
1647 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1649 case dw_val_class_const_double
:
1650 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1657 case DW_OP_GNU_regval_type
:
1660 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1661 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1662 + size_of_uleb128 (o
);
1665 case DW_OP_GNU_deref_type
:
1668 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1669 size
+= 1 + size_of_uleb128 (o
);
1672 case DW_OP_GNU_convert
:
1673 case DW_OP_GNU_reinterpret
:
1674 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1675 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1679 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1680 size
+= size_of_uleb128 (o
);
1683 case DW_OP_GNU_parameter_ref
:
1693 /* Return the size of a series of location descriptors. */
1696 size_of_locs (dw_loc_descr_ref loc
)
1701 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1702 field, to avoid writing to a PCH file. */
1703 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1705 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1707 size
+= size_of_loc_descr (l
);
1712 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1714 l
->dw_loc_addr
= size
;
1715 size
+= size_of_loc_descr (l
);
1721 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
1722 static void get_ref_die_offset_label (char *, dw_die_ref
);
1723 static unsigned long int get_ref_die_offset (dw_die_ref
);
1725 /* Output location description stack opcode's operands (if any).
1726 The for_eh_or_skip parameter controls whether register numbers are
1727 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1728 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1729 info). This should be suppressed for the cases that have not been converted
1730 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1733 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
1735 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
1736 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
1738 switch (loc
->dw_loc_opc
)
1740 #ifdef DWARF2_DEBUGGING_INFO
1743 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
1748 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1749 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
1751 fputc ('\n', asm_out_file
);
1756 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
1761 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
1762 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
1764 fputc ('\n', asm_out_file
);
1769 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
1770 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
1777 gcc_assert (val1
->val_class
== dw_val_class_loc
);
1778 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
1780 dw2_asm_output_data (2, offset
, NULL
);
1783 case DW_OP_implicit_value
:
1784 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1785 switch (val2
->val_class
)
1787 case dw_val_class_const
:
1788 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
1790 case dw_val_class_vec
:
1792 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
1793 unsigned int len
= val2
->v
.val_vec
.length
;
1797 if (elt_size
> sizeof (HOST_WIDE_INT
))
1802 for (i
= 0, p
= val2
->v
.val_vec
.array
;
1805 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
1806 "fp or vector constant word %u", i
);
1809 case dw_val_class_const_double
:
1811 unsigned HOST_WIDE_INT first
, second
;
1813 if (WORDS_BIG_ENDIAN
)
1815 first
= val2
->v
.val_double
.high
;
1816 second
= val2
->v
.val_double
.low
;
1820 first
= val2
->v
.val_double
.low
;
1821 second
= val2
->v
.val_double
.high
;
1823 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1825 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
1829 case dw_val_class_addr
:
1830 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
1831 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
1846 case DW_OP_implicit_value
:
1847 /* We currently don't make any attempt to make sure these are
1848 aligned properly like we do for the main unwind info, so
1849 don't support emitting things larger than a byte if we're
1850 only doing unwinding. */
1855 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1858 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1861 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1864 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1866 case DW_OP_plus_uconst
:
1867 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1901 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1905 unsigned r
= val1
->v
.val_unsigned
;
1906 if (for_eh_or_skip
>= 0)
1907 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1908 gcc_assert (size_of_uleb128 (r
)
1909 == size_of_uleb128 (val1
->v
.val_unsigned
));
1910 dw2_asm_output_data_uleb128 (r
, NULL
);
1914 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
1918 unsigned r
= val1
->v
.val_unsigned
;
1919 if (for_eh_or_skip
>= 0)
1920 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
1921 gcc_assert (size_of_uleb128 (r
)
1922 == size_of_uleb128 (val1
->v
.val_unsigned
));
1923 dw2_asm_output_data_uleb128 (r
, NULL
);
1924 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
1928 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1930 case DW_OP_bit_piece
:
1931 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
1932 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
1934 case DW_OP_deref_size
:
1935 case DW_OP_xderef_size
:
1936 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
1942 if (targetm
.asm_out
.output_dwarf_dtprel
)
1944 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
1947 fputc ('\n', asm_out_file
);
1954 #ifdef DWARF2_DEBUGGING_INFO
1955 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
1962 case DW_OP_GNU_addr_index
:
1963 case DW_OP_GNU_const_index
:
1964 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1965 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
1966 "(index into .debug_addr)");
1969 case DW_OP_GNU_implicit_pointer
:
1971 char label
[MAX_ARTIFICIAL_LABEL_BYTES
1972 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
1973 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
1974 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
1975 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
1976 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
1980 case DW_OP_GNU_entry_value
:
1981 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
1982 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
1985 case DW_OP_GNU_const_type
:
1987 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
1989 dw2_asm_output_data_uleb128 (o
, NULL
);
1990 switch (val2
->val_class
)
1992 case dw_val_class_const
:
1993 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
1994 dw2_asm_output_data (1, l
, NULL
);
1995 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
1997 case dw_val_class_vec
:
1999 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2000 unsigned int len
= val2
->v
.val_vec
.length
;
2005 dw2_asm_output_data (1, l
, NULL
);
2006 if (elt_size
> sizeof (HOST_WIDE_INT
))
2011 for (i
= 0, p
= val2
->v
.val_vec
.array
;
2014 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2015 "fp or vector constant word %u", i
);
2018 case dw_val_class_const_double
:
2020 unsigned HOST_WIDE_INT first
, second
;
2021 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2023 dw2_asm_output_data (1, 2 * l
, NULL
);
2024 if (WORDS_BIG_ENDIAN
)
2026 first
= val2
->v
.val_double
.high
;
2027 second
= val2
->v
.val_double
.low
;
2031 first
= val2
->v
.val_double
.low
;
2032 second
= val2
->v
.val_double
.high
;
2034 dw2_asm_output_data (l
, first
, NULL
);
2035 dw2_asm_output_data (l
, second
, NULL
);
2043 case DW_OP_GNU_regval_type
:
2045 unsigned r
= val1
->v
.val_unsigned
;
2046 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2048 if (for_eh_or_skip
>= 0)
2050 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2051 gcc_assert (size_of_uleb128 (r
)
2052 == size_of_uleb128 (val1
->v
.val_unsigned
));
2054 dw2_asm_output_data_uleb128 (r
, NULL
);
2055 dw2_asm_output_data_uleb128 (o
, NULL
);
2058 case DW_OP_GNU_deref_type
:
2060 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2062 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2063 dw2_asm_output_data_uleb128 (o
, NULL
);
2066 case DW_OP_GNU_convert
:
2067 case DW_OP_GNU_reinterpret
:
2068 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2069 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2072 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2074 dw2_asm_output_data_uleb128 (o
, NULL
);
2078 case DW_OP_GNU_parameter_ref
:
2081 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2082 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2083 dw2_asm_output_data (4, o
, NULL
);
2088 /* Other codes have no operands. */
2093 /* Output a sequence of location operations.
2094 The for_eh_or_skip parameter controls whether register numbers are
2095 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2096 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2097 info). This should be suppressed for the cases that have not been converted
2098 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2101 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2103 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2105 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2106 /* Output the opcode. */
2107 if (for_eh_or_skip
>= 0
2108 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2110 unsigned r
= (opc
- DW_OP_breg0
);
2111 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2112 gcc_assert (r
<= 31);
2113 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2115 else if (for_eh_or_skip
>= 0
2116 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2118 unsigned r
= (opc
- DW_OP_reg0
);
2119 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2120 gcc_assert (r
<= 31);
2121 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2124 dw2_asm_output_data (1, opc
,
2125 "%s", dwarf_stack_op_name (opc
));
2127 /* Output the operand(s) (if any). */
2128 output_loc_operands (loc
, for_eh_or_skip
);
2132 /* Output location description stack opcode's operands (if any).
2133 The output is single bytes on a line, suitable for .cfi_escape. */
2136 output_loc_operands_raw (dw_loc_descr_ref loc
)
2138 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2139 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2141 switch (loc
->dw_loc_opc
)
2144 case DW_OP_GNU_addr_index
:
2145 case DW_OP_GNU_const_index
:
2146 case DW_OP_implicit_value
:
2147 /* We cannot output addresses in .cfi_escape, only bytes. */
2153 case DW_OP_deref_size
:
2154 case DW_OP_xderef_size
:
2155 fputc (',', asm_out_file
);
2156 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2161 fputc (',', asm_out_file
);
2162 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2167 fputc (',', asm_out_file
);
2168 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2173 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2174 fputc (',', asm_out_file
);
2175 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2183 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2184 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2186 fputc (',', asm_out_file
);
2187 dw2_asm_output_data_raw (2, offset
);
2193 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2194 gcc_assert (size_of_uleb128 (r
)
2195 == size_of_uleb128 (val1
->v
.val_unsigned
));
2196 fputc (',', asm_out_file
);
2197 dw2_asm_output_data_uleb128_raw (r
);
2202 case DW_OP_plus_uconst
:
2204 fputc (',', asm_out_file
);
2205 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2208 case DW_OP_bit_piece
:
2209 fputc (',', asm_out_file
);
2210 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2211 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2248 fputc (',', asm_out_file
);
2249 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2254 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2255 gcc_assert (size_of_uleb128 (r
)
2256 == size_of_uleb128 (val1
->v
.val_unsigned
));
2257 fputc (',', asm_out_file
);
2258 dw2_asm_output_data_uleb128_raw (r
);
2259 fputc (',', asm_out_file
);
2260 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2264 case DW_OP_GNU_implicit_pointer
:
2265 case DW_OP_GNU_entry_value
:
2266 case DW_OP_GNU_const_type
:
2267 case DW_OP_GNU_regval_type
:
2268 case DW_OP_GNU_deref_type
:
2269 case DW_OP_GNU_convert
:
2270 case DW_OP_GNU_reinterpret
:
2271 case DW_OP_GNU_parameter_ref
:
2276 /* Other codes have no operands. */
2282 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2286 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2287 /* Output the opcode. */
2288 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2290 unsigned r
= (opc
- DW_OP_breg0
);
2291 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2292 gcc_assert (r
<= 31);
2293 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2295 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2297 unsigned r
= (opc
- DW_OP_reg0
);
2298 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2299 gcc_assert (r
<= 31);
2300 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2302 /* Output the opcode. */
2303 fprintf (asm_out_file
, "%#x", opc
);
2304 output_loc_operands_raw (loc
);
2306 if (!loc
->dw_loc_next
)
2308 loc
= loc
->dw_loc_next
;
2310 fputc (',', asm_out_file
);
2314 /* This function builds a dwarf location descriptor sequence from a
2315 dw_cfa_location, adding the given OFFSET to the result of the
2318 struct dw_loc_descr_node
*
2319 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
2321 struct dw_loc_descr_node
*head
, *tmp
;
2323 offset
+= cfa
->offset
;
2327 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2328 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2329 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2330 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2331 add_loc_descr (&head
, tmp
);
2334 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
2335 add_loc_descr (&head
, tmp
);
2339 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2344 /* This function builds a dwarf location descriptor sequence for
2345 the address at OFFSET from the CFA when stack is aligned to
2348 struct dw_loc_descr_node
*
2349 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2350 HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
2352 struct dw_loc_descr_node
*head
;
2353 unsigned int dwarf_fp
2354 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2356 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2357 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2359 head
= new_reg_loc_descr (dwarf_fp
, 0);
2360 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2361 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2362 loc_descr_plus_const (&head
, offset
);
2365 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2369 /* And now, the support for symbolic debugging information. */
2371 /* .debug_str support. */
2372 static int output_indirect_string (void **, void *);
2374 static void dwarf2out_init (const char *);
2375 static void dwarf2out_finish (const char *);
2376 static void dwarf2out_assembly_start (void);
2377 static void dwarf2out_define (unsigned int, const char *);
2378 static void dwarf2out_undef (unsigned int, const char *);
2379 static void dwarf2out_start_source_file (unsigned, const char *);
2380 static void dwarf2out_end_source_file (unsigned);
2381 static void dwarf2out_function_decl (tree
);
2382 static void dwarf2out_begin_block (unsigned, unsigned);
2383 static void dwarf2out_end_block (unsigned, unsigned);
2384 static bool dwarf2out_ignore_block (const_tree
);
2385 static void dwarf2out_global_decl (tree
);
2386 static void dwarf2out_type_decl (tree
, int);
2387 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool);
2388 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2390 static void dwarf2out_abstract_function (tree
);
2391 static void dwarf2out_var_location (rtx
);
2392 static void dwarf2out_begin_function (tree
);
2393 static void dwarf2out_end_function (unsigned int);
2394 static void dwarf2out_set_name (tree
, tree
);
2396 /* The debug hooks structure. */
2398 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2402 dwarf2out_assembly_start
,
2405 dwarf2out_start_source_file
,
2406 dwarf2out_end_source_file
,
2407 dwarf2out_begin_block
,
2408 dwarf2out_end_block
,
2409 dwarf2out_ignore_block
,
2410 dwarf2out_source_line
,
2411 dwarf2out_begin_prologue
,
2412 #if VMS_DEBUGGING_INFO
2413 dwarf2out_vms_end_prologue
,
2414 dwarf2out_vms_begin_epilogue
,
2416 debug_nothing_int_charstar
,
2417 debug_nothing_int_charstar
,
2419 dwarf2out_end_epilogue
,
2420 dwarf2out_begin_function
,
2421 dwarf2out_end_function
, /* end_function */
2422 dwarf2out_function_decl
, /* function_decl */
2423 dwarf2out_global_decl
,
2424 dwarf2out_type_decl
, /* type_decl */
2425 dwarf2out_imported_module_or_decl
,
2426 debug_nothing_tree
, /* deferred_inline_function */
2427 /* The DWARF 2 backend tries to reduce debugging bloat by not
2428 emitting the abstract description of inline functions until
2429 something tries to reference them. */
2430 dwarf2out_abstract_function
, /* outlining_inline_function */
2431 debug_nothing_rtx
, /* label */
2432 debug_nothing_int
, /* handle_pch */
2433 dwarf2out_var_location
,
2434 dwarf2out_switch_text_section
,
2436 1, /* start_end_main_source_file */
2437 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2440 /* NOTE: In the comments in this file, many references are made to
2441 "Debugging Information Entries". This term is abbreviated as `DIE'
2442 throughout the remainder of this file. */
2444 /* An internal representation of the DWARF output is built, and then
2445 walked to generate the DWARF debugging info. The walk of the internal
2446 representation is done after the entire program has been compiled.
2447 The types below are used to describe the internal representation. */
2449 /* Whether to put type DIEs into their own section .debug_types instead
2450 of making them part of the .debug_info section. Only supported for
2451 Dwarf V4 or higher and the user didn't disable them through
2452 -fno-debug-types-section. It is more efficient to put them in a
2453 separate comdat sections since the linker will then be able to
2454 remove duplicates. But not all tools support .debug_types sections
2457 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2459 /* Various DIE's use offsets relative to the beginning of the
2460 .debug_info section to refer to each other. */
2462 typedef long int dw_offset
;
2464 /* Define typedefs here to avoid circular dependencies. */
2466 typedef struct dw_attr_struct
*dw_attr_ref
;
2467 typedef struct dw_line_info_struct
*dw_line_info_ref
;
2468 typedef struct pubname_struct
*pubname_ref
;
2469 typedef struct dw_ranges_struct
*dw_ranges_ref
;
2470 typedef struct dw_ranges_by_label_struct
*dw_ranges_by_label_ref
;
2471 typedef struct comdat_type_struct
*comdat_type_node_ref
;
2473 /* The entries in the line_info table more-or-less mirror the opcodes
2474 that are used in the real dwarf line table. Arrays of these entries
2475 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2478 enum dw_line_info_opcode
{
2479 /* Emit DW_LNE_set_address; the operand is the label index. */
2482 /* Emit a row to the matrix with the given line. This may be done
2483 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2487 /* Emit a DW_LNS_set_file. */
2490 /* Emit a DW_LNS_set_column. */
2493 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2496 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2497 LI_set_prologue_end
,
2498 LI_set_epilogue_begin
,
2500 /* Emit a DW_LNE_set_discriminator. */
2501 LI_set_discriminator
2504 typedef struct GTY(()) dw_line_info_struct
{
2505 enum dw_line_info_opcode opcode
;
2507 } dw_line_info_entry
;
2510 typedef struct GTY(()) dw_line_info_table_struct
{
2511 /* The label that marks the end of this section. */
2512 const char *end_label
;
2514 /* The values for the last row of the matrix, as collected in the table.
2515 These are used to minimize the changes to the next row. */
2516 unsigned int file_num
;
2517 unsigned int line_num
;
2518 unsigned int column_num
;
2523 vec
<dw_line_info_entry
, va_gc
> *entries
;
2524 } dw_line_info_table
;
2526 typedef dw_line_info_table
*dw_line_info_table_p
;
2529 /* Each DIE attribute has a field specifying the attribute kind,
2530 a link to the next attribute in the chain, and an attribute value.
2531 Attributes are typically linked below the DIE they modify. */
2533 typedef struct GTY(()) dw_attr_struct
{
2534 enum dwarf_attribute dw_attr
;
2535 dw_val_node dw_attr_val
;
2540 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2541 The children of each node form a circular list linked by
2542 die_sib. die_child points to the node *before* the "first" child node. */
2544 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct
{
2545 union die_symbol_or_type_node
2547 const char * GTY ((tag ("0"))) die_symbol
;
2548 comdat_type_node_ref
GTY ((tag ("1"))) die_type_node
;
2550 GTY ((desc ("%0.comdat_type_p"))) die_id
;
2551 vec
<dw_attr_node
, va_gc
> *die_attr
;
2552 dw_die_ref die_parent
;
2553 dw_die_ref die_child
;
2555 dw_die_ref die_definition
; /* ref from a specification to its definition */
2556 dw_offset die_offset
;
2557 unsigned long die_abbrev
;
2559 unsigned int decl_id
;
2560 enum dwarf_tag die_tag
;
2561 /* Die is used and must not be pruned as unused. */
2562 BOOL_BITFIELD die_perennial_p
: 1;
2563 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
2564 /* Lots of spare bits. */
2568 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2569 #define FOR_EACH_CHILD(die, c, expr) do { \
2570 c = die->die_child; \
2574 } while (c != die->die_child); \
2577 /* The pubname structure */
2579 typedef struct GTY(()) pubname_struct
{
2586 struct GTY(()) dw_ranges_struct
{
2587 /* If this is positive, it's a block number, otherwise it's a
2588 bitwise-negated index into dw_ranges_by_label. */
2592 /* A structure to hold a macinfo entry. */
2594 typedef struct GTY(()) macinfo_struct
{
2596 unsigned HOST_WIDE_INT lineno
;
2602 struct GTY(()) dw_ranges_by_label_struct
{
2607 /* The comdat type node structure. */
2608 typedef struct GTY(()) comdat_type_struct
2610 dw_die_ref root_die
;
2611 dw_die_ref type_die
;
2612 dw_die_ref skeleton_die
;
2613 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
2614 struct comdat_type_struct
*next
;
2618 /* The limbo die list structure. */
2619 typedef struct GTY(()) limbo_die_struct
{
2622 struct limbo_die_struct
*next
;
2626 typedef struct skeleton_chain_struct
2630 struct skeleton_chain_struct
*parent
;
2632 skeleton_chain_node
;
2634 /* Define a macro which returns nonzero for a TYPE_DECL which was
2635 implicitly generated for a type.
2637 Note that, unlike the C front-end (which generates a NULL named
2638 TYPE_DECL node for each complete tagged type, each array type,
2639 and each function type node created) the C++ front-end generates
2640 a _named_ TYPE_DECL node for each tagged type node created.
2641 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2642 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2643 front-end, but for each type, tagged or not. */
2645 #define TYPE_DECL_IS_STUB(decl) \
2646 (DECL_NAME (decl) == NULL_TREE \
2647 || (DECL_ARTIFICIAL (decl) \
2648 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2649 /* This is necessary for stub decls that \
2650 appear in nested inline functions. */ \
2651 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2652 && (decl_ultimate_origin (decl) \
2653 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2655 /* Information concerning the compilation unit's programming
2656 language, and compiler version. */
2658 /* Fixed size portion of the DWARF compilation unit header. */
2659 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2660 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2662 /* Fixed size portion of the DWARF comdat type unit header. */
2663 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2664 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2665 + DWARF_OFFSET_SIZE)
2667 /* Fixed size portion of public names info. */
2668 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2670 /* Fixed size portion of the address range info. */
2671 #define DWARF_ARANGES_HEADER_SIZE \
2672 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2673 DWARF2_ADDR_SIZE * 2) \
2674 - DWARF_INITIAL_LENGTH_SIZE)
2676 /* Size of padding portion in the address range info. It must be
2677 aligned to twice the pointer size. */
2678 #define DWARF_ARANGES_PAD_SIZE \
2679 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2680 DWARF2_ADDR_SIZE * 2) \
2681 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2683 /* Use assembler line directives if available. */
2684 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2685 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2686 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2688 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2692 /* Minimum line offset in a special line info. opcode.
2693 This value was chosen to give a reasonable range of values. */
2694 #define DWARF_LINE_BASE -10
2696 /* First special line opcode - leave room for the standard opcodes. */
2697 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2699 /* Range of line offsets in a special line info. opcode. */
2700 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2702 /* Flag that indicates the initial value of the is_stmt_start flag.
2703 In the present implementation, we do not mark any lines as
2704 the beginning of a source statement, because that information
2705 is not made available by the GCC front-end. */
2706 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2708 /* Maximum number of operations per instruction bundle. */
2709 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2710 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2713 /* This location is used by calc_die_sizes() to keep track
2714 the offset of each DIE within the .debug_info section. */
2715 static unsigned long next_die_offset
;
2717 /* Record the root of the DIE's built for the current compilation unit. */
2718 static GTY(()) dw_die_ref single_comp_unit_die
;
2720 /* A list of type DIEs that have been separated into comdat sections. */
2721 static GTY(()) comdat_type_node
*comdat_type_list
;
2723 /* A list of DIEs with a NULL parent waiting to be relocated. */
2724 static GTY(()) limbo_die_node
*limbo_die_list
;
2726 /* A list of DIEs for which we may have to generate
2727 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2728 static GTY(()) limbo_die_node
*deferred_asm_name
;
2730 /* Filenames referenced by this compilation unit. */
2731 static GTY((param_is (struct dwarf_file_data
))) htab_t file_table
;
2733 /* A hash table of references to DIE's that describe declarations.
2734 The key is a DECL_UID() which is a unique number identifying each decl. */
2735 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
2737 /* A hash table of references to DIE's that describe COMMON blocks.
2738 The key is DECL_UID() ^ die_parent. */
2739 static GTY ((param_is (struct die_struct
))) htab_t common_block_die_table
;
2741 typedef struct GTY(()) die_arg_entry_struct
{
2747 /* Node of the variable location list. */
2748 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
2749 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2750 EXPR_LIST chain. For small bitsizes, bitsize is encoded
2751 in mode of the EXPR_LIST node and first EXPR_LIST operand
2752 is either NOTE_INSN_VAR_LOCATION for a piece with a known
2753 location or NULL for padding. For larger bitsizes,
2754 mode is 0 and first operand is a CONCAT with bitsize
2755 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2756 NULL as second operand. */
2758 const char * GTY (()) label
;
2759 struct var_loc_node
* GTY (()) next
;
2762 /* Variable location list. */
2763 struct GTY (()) var_loc_list_def
{
2764 struct var_loc_node
* GTY (()) first
;
2766 /* Pointer to the last but one or last element of the
2767 chained list. If the list is empty, both first and
2768 last are NULL, if the list contains just one node
2769 or the last node certainly is not redundant, it points
2770 to the last node, otherwise points to the last but one.
2771 Do not mark it for GC because it is marked through the chain. */
2772 struct var_loc_node
* GTY ((skip ("%h"))) last
;
2774 /* Pointer to the last element before section switch,
2775 if NULL, either sections weren't switched or first
2776 is after section switch. */
2777 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
2779 /* DECL_UID of the variable decl. */
2780 unsigned int decl_id
;
2782 typedef struct var_loc_list_def var_loc_list
;
2784 /* Call argument location list. */
2785 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
2786 rtx
GTY (()) call_arg_loc_note
;
2787 const char * GTY (()) label
;
2788 tree
GTY (()) block
;
2790 rtx
GTY (()) symbol_ref
;
2791 struct call_arg_loc_node
* GTY (()) next
;
2795 /* Table of decl location linked lists. */
2796 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
2798 /* Head and tail of call_arg_loc chain. */
2799 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
2800 static struct call_arg_loc_node
*call_arg_loc_last
;
2802 /* Number of call sites in the current function. */
2803 static int call_site_count
= -1;
2804 /* Number of tail call sites in the current function. */
2805 static int tail_call_site_count
= -1;
2807 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
2809 static vec
<dw_die_ref
> block_map
;
2811 /* A cached location list. */
2812 struct GTY (()) cached_dw_loc_list_def
{
2813 /* The DECL_UID of the decl that this entry describes. */
2814 unsigned int decl_id
;
2816 /* The cached location list. */
2817 dw_loc_list_ref loc_list
;
2819 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
2821 /* Table of cached location lists. */
2822 static GTY ((param_is (cached_dw_loc_list
))) htab_t cached_dw_loc_list_table
;
2824 /* A pointer to the base of a list of references to DIE's that
2825 are uniquely identified by their tag, presence/absence of
2826 children DIE's, and list of attribute/value pairs. */
2827 static GTY((length ("abbrev_die_table_allocated")))
2828 dw_die_ref
*abbrev_die_table
;
2830 /* Number of elements currently allocated for abbrev_die_table. */
2831 static GTY(()) unsigned abbrev_die_table_allocated
;
2833 /* Number of elements in type_die_table currently in use. */
2834 static GTY(()) unsigned abbrev_die_table_in_use
;
2836 /* Size (in elements) of increments by which we may expand the
2837 abbrev_die_table. */
2838 #define ABBREV_DIE_TABLE_INCREMENT 256
2840 /* A global counter for generating labels for line number data. */
2841 static unsigned int line_info_label_num
;
2843 /* The current table to which we should emit line number information
2844 for the current function. This will be set up at the beginning of
2845 assembly for the function. */
2846 static dw_line_info_table
*cur_line_info_table
;
2848 /* The two default tables of line number info. */
2849 static GTY(()) dw_line_info_table
*text_section_line_info
;
2850 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
2852 /* The set of all non-default tables of line number info. */
2853 static GTY(()) vec
<dw_line_info_table_p
, va_gc
> *separate_line_info
;
2855 /* A flag to tell pubnames/types export if there is an info section to
2857 static bool info_section_emitted
;
2859 /* A pointer to the base of a table that contains a list of publicly
2860 accessible names. */
2861 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
2863 /* A pointer to the base of a table that contains a list of publicly
2864 accessible types. */
2865 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
2867 /* A pointer to the base of a table that contains a list of macro
2868 defines/undefines (and file start/end markers). */
2869 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
2871 /* True if .debug_macinfo or .debug_macros section is going to be
2873 #define have_macinfo \
2874 (debug_info_level >= DINFO_LEVEL_VERBOSE \
2875 && !macinfo_table->is_empty ())
2877 /* Array of dies for which we should generate .debug_ranges info. */
2878 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
2880 /* Number of elements currently allocated for ranges_table. */
2881 static GTY(()) unsigned ranges_table_allocated
;
2883 /* Number of elements in ranges_table currently in use. */
2884 static GTY(()) unsigned ranges_table_in_use
;
2886 /* Array of pairs of labels referenced in ranges_table. */
2887 static GTY ((length ("ranges_by_label_allocated")))
2888 dw_ranges_by_label_ref ranges_by_label
;
2890 /* Number of elements currently allocated for ranges_by_label. */
2891 static GTY(()) unsigned ranges_by_label_allocated
;
2893 /* Number of elements in ranges_by_label currently in use. */
2894 static GTY(()) unsigned ranges_by_label_in_use
;
2896 /* Size (in elements) of increments by which we may expand the
2898 #define RANGES_TABLE_INCREMENT 64
2900 /* Whether we have location lists that need outputting */
2901 static GTY(()) bool have_location_lists
;
2903 /* Unique label counter. */
2904 static GTY(()) unsigned int loclabel_num
;
2906 /* Unique label counter for point-of-call tables. */
2907 static GTY(()) unsigned int poc_label_num
;
2909 /* Record whether the function being analyzed contains inlined functions. */
2910 static int current_function_has_inlines
;
2912 /* The last file entry emitted by maybe_emit_file(). */
2913 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
2915 /* Number of internal labels generated by gen_internal_sym(). */
2916 static GTY(()) int label_num
;
2918 /* Cached result of previous call to lookup_filename. */
2919 static GTY(()) struct dwarf_file_data
* file_table_last_lookup
;
2921 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
2923 /* Instances of generic types for which we need to generate debug
2924 info that describe their generic parameters and arguments. That
2925 generation needs to happen once all types are properly laid out so
2926 we do it at the end of compilation. */
2927 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
2929 /* Offset from the "steady-state frame pointer" to the frame base,
2930 within the current function. */
2931 static HOST_WIDE_INT frame_pointer_fb_offset
;
2932 static bool frame_pointer_fb_offset_valid
;
2934 static vec
<dw_die_ref
> base_types
;
2936 /* Forward declarations for functions defined in this file. */
2938 static int is_pseudo_reg (const_rtx
);
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, 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_NAME (type
);
10234 if (TREE_CODE (name
) == TYPE_DECL
)
10235 name
= DECL_NAME (name
);
10236 if (name
== get_identifier ("auto")
10237 || name
== get_identifier ("decltype(auto)"))
10243 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10244 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10247 is_base_type (tree type
)
10249 switch (TREE_CODE (type
))
10255 case FIXED_POINT_TYPE
:
10263 case QUAL_UNION_TYPE
:
10264 case ENUMERAL_TYPE
:
10265 case FUNCTION_TYPE
:
10268 case REFERENCE_TYPE
:
10276 if (is_cxx_auto (type
))
10278 gcc_unreachable ();
10284 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10285 node, return the size in bits for the type if it is a constant, or else
10286 return the alignment for the type if the type's size is not constant, or
10287 else return BITS_PER_WORD if the type actually turns out to be an
10288 ERROR_MARK node. */
10290 static inline unsigned HOST_WIDE_INT
10291 simple_type_size_in_bits (const_tree type
)
10293 if (TREE_CODE (type
) == ERROR_MARK
)
10294 return BITS_PER_WORD
;
10295 else if (TYPE_SIZE (type
) == NULL_TREE
)
10297 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
10298 return tree_to_uhwi (TYPE_SIZE (type
));
10300 return TYPE_ALIGN (type
);
10303 /* Similarly, but return a double_int instead of UHWI. */
10305 static inline double_int
10306 double_int_type_size_in_bits (const_tree type
)
10308 if (TREE_CODE (type
) == ERROR_MARK
)
10309 return double_int::from_uhwi (BITS_PER_WORD
);
10310 else if (TYPE_SIZE (type
) == NULL_TREE
)
10311 return double_int_zero
;
10312 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
10313 return tree_to_double_int (TYPE_SIZE (type
));
10315 return double_int::from_uhwi (TYPE_ALIGN (type
));
10318 /* Given a pointer to a tree node for a subrange type, return a pointer
10319 to a DIE that describes the given type. */
10322 subrange_type_die (tree type
, tree low
, tree high
, dw_die_ref context_die
)
10324 dw_die_ref subrange_die
;
10325 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
10327 if (context_die
== NULL
)
10328 context_die
= comp_unit_die ();
10330 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
10332 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
10334 /* The size of the subrange type and its base type do not match,
10335 so we need to generate a size attribute for the subrange type. */
10336 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
10340 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
);
10342 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
);
10344 return subrange_die
;
10347 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10348 entry that chains various modifiers in front of the given type. */
10351 modified_type_die (tree type
, int type_quals
,
10352 dw_die_ref context_die
)
10354 const int is_const_type
= ((type_quals
& TYPE_QUAL_CONST
) != 0);
10355 const int is_volatile_type
= ((type_quals
& TYPE_QUAL_VOLATILE
) != 0);
10356 enum tree_code code
= TREE_CODE (type
);
10357 dw_die_ref mod_type_die
;
10358 dw_die_ref sub_die
= NULL
;
10359 tree item_type
= NULL
;
10360 tree qualified_type
;
10361 tree name
, low
, high
;
10362 dw_die_ref mod_scope
;
10364 if (code
== ERROR_MARK
)
10367 /* See if we already have the appropriately qualified variant of
10370 = get_qualified_type (type
, type_quals
);
10372 if (qualified_type
== sizetype
10373 && TYPE_NAME (qualified_type
)
10374 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
10376 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
10378 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
10379 && TYPE_PRECISION (t
)
10380 == TYPE_PRECISION (qualified_type
)
10381 && TYPE_UNSIGNED (t
)
10382 == TYPE_UNSIGNED (qualified_type
));
10383 qualified_type
= t
;
10386 /* If we do, then we can just use its DIE, if it exists. */
10387 if (qualified_type
)
10389 mod_type_die
= lookup_type_die (qualified_type
);
10391 return mod_type_die
;
10394 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
10396 /* Handle C typedef types. */
10397 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
10398 && !DECL_ARTIFICIAL (name
))
10400 tree dtype
= TREE_TYPE (name
);
10402 if (qualified_type
== dtype
)
10404 /* For a named type, use the typedef. */
10405 gen_type_die (qualified_type
, context_die
);
10406 return lookup_type_die (qualified_type
);
10408 else if (type_quals
== TYPE_QUALS (dtype
))
10409 /* cv-unqualified version of named type. Just use the unnamed
10410 type to which it refers. */
10411 return modified_type_die (DECL_ORIGINAL_TYPE (name
), type_quals
, context_die
);
10412 /* Else cv-qualified version of named type; fall through. */
10415 mod_scope
= scope_die_for (type
, context_die
);
10417 if ((type_quals
& TYPE_QUAL_CONST
)
10418 /* If both is_const_type and is_volatile_type, prefer the path
10419 which leads to a qualified type. */
10420 && (!is_volatile_type
10421 || get_qualified_type (type
, TYPE_QUAL_CONST
) == NULL_TREE
10422 || get_qualified_type (type
, TYPE_QUAL_VOLATILE
) != NULL_TREE
))
10424 mod_type_die
= new_die (DW_TAG_const_type
, mod_scope
, type
);
10425 sub_die
= modified_type_die (type
, type_quals
& ~TYPE_QUAL_CONST
, context_die
);
10427 else if (type_quals
& TYPE_QUAL_VOLATILE
)
10429 mod_type_die
= new_die (DW_TAG_volatile_type
, mod_scope
, type
);
10430 sub_die
= modified_type_die (type
, type_quals
& ~TYPE_QUAL_VOLATILE
, context_die
);
10432 else if (use_upc_dwarf2_extensions
10433 && (type_quals
& TYPE_QUAL_UPC_SHARED
))
10435 HOST_WIDE_INT block_factor
= 1;
10437 /* Inside the compiler,
10438 "shared int x;" TYPE_UPC_BLOCK_FACTOR is null.
10439 "shared [] int *p;" TYPE_UPC_BLOCK_FACTOR is zero.
10440 "shared [10] int x[50];" TYPE_UPC_BLOCK_FACTOR is 10 * bitsize(int)
10441 The DWARF2 encoding is as follows:
10442 "shared int x;" DW_AT_count: 1
10443 "shared [] int *p;" <no DW_AT_count attribute>
10444 "shared [10] int x[50];" DW_AT_count: 10
10445 The logic below handles thse various contingencies. */
10447 mod_type_die
= new_die (DW_TAG_upc_shared_type
,
10448 comp_unit_die (), type
);
10450 if (TYPE_HAS_UPC_BLOCK_FACTOR (type
))
10451 block_factor
= TREE_INT_CST_LOW (TYPE_UPC_BLOCK_FACTOR (type
));
10453 if (block_factor
!= 0)
10454 add_AT_unsigned (mod_type_die
, DW_AT_count
, block_factor
);
10456 sub_die
= modified_type_die (type
,
10457 type_quals
& ~TYPE_QUAL_UPC_SHARED
,
10460 else if (use_upc_dwarf2_extensions
&& type_quals
& TYPE_QUAL_UPC_STRICT
)
10462 mod_type_die
= new_die (DW_TAG_upc_strict_type
,
10463 comp_unit_die (), type
);
10464 sub_die
= modified_type_die (type
,
10465 type_quals
& ~TYPE_QUAL_UPC_STRICT
,
10468 else if (use_upc_dwarf2_extensions
&& type_quals
& TYPE_QUAL_UPC_RELAXED
)
10470 mod_type_die
= new_die (DW_TAG_upc_relaxed_type
,
10471 comp_unit_die (), type
);
10472 sub_die
= modified_type_die (type
,
10473 type_quals
& ~TYPE_QUAL_UPC_RELAXED
,
10476 else if (code
== POINTER_TYPE
)
10478 mod_type_die
= new_die (DW_TAG_pointer_type
, mod_scope
, type
);
10479 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10480 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10481 item_type
= TREE_TYPE (type
);
10482 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10483 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10484 TYPE_ADDR_SPACE (item_type
));
10486 else if (code
== REFERENCE_TYPE
)
10488 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
10489 mod_type_die
= new_die (DW_TAG_rvalue_reference_type
, mod_scope
,
10492 mod_type_die
= new_die (DW_TAG_reference_type
, mod_scope
, type
);
10493 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
10494 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
10495 item_type
= TREE_TYPE (type
);
10496 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
10497 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
10498 TYPE_ADDR_SPACE (item_type
));
10500 else if (code
== INTEGER_TYPE
10501 && TREE_TYPE (type
) != NULL_TREE
10502 && subrange_type_for_debug_p (type
, &low
, &high
))
10504 mod_type_die
= subrange_type_die (type
, low
, high
, context_die
);
10505 item_type
= TREE_TYPE (type
);
10507 else if (is_base_type (type
))
10508 mod_type_die
= base_type_die (type
);
10511 gen_type_die (type
, context_die
);
10513 /* We have to get the type_main_variant here (and pass that to the
10514 `lookup_type_die' routine) because the ..._TYPE node we have
10515 might simply be a *copy* of some original type node (where the
10516 copy was created to help us keep track of typedef names) and
10517 that copy might have a different TYPE_UID from the original
10519 if (TREE_CODE (type
) != VECTOR_TYPE
)
10520 return lookup_type_die (type_main_variant (type
));
10522 /* Vectors have the debugging information in the type,
10523 not the main variant. */
10524 return lookup_type_die (type
);
10527 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10528 don't output a DW_TAG_typedef, since there isn't one in the
10529 user's program; just attach a DW_AT_name to the type.
10530 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
10531 if the base type already has the same name. */
10533 && ((TREE_CODE (name
) != TYPE_DECL
10534 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
10535 || (!is_const_type
&& !is_volatile_type
)))
10536 || (TREE_CODE (name
) == TYPE_DECL
10537 && TREE_TYPE (name
) == qualified_type
10538 && DECL_NAME (name
))))
10540 if (TREE_CODE (name
) == TYPE_DECL
)
10541 /* Could just call add_name_and_src_coords_attributes here,
10542 but since this is a builtin type it doesn't have any
10543 useful source coordinates anyway. */
10544 name
= DECL_NAME (name
);
10545 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
10547 /* This probably indicates a bug. */
10548 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
10550 name
= TYPE_NAME (type
);
10552 && TREE_CODE (name
) == TYPE_DECL
)
10553 name
= DECL_NAME (name
);
10554 add_name_attribute (mod_type_die
,
10555 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
10558 if (qualified_type
)
10559 equate_type_number_to_die (qualified_type
, mod_type_die
);
10562 /* We must do this after the equate_type_number_to_die call, in case
10563 this is a recursive type. This ensures that the modified_type_die
10564 recursion will terminate even if the type is recursive. Recursive
10565 types are possible in Ada. */
10566 sub_die
= modified_type_die (item_type
, TYPE_QUALS (item_type
), context_die
);
10568 if (sub_die
!= NULL
)
10569 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
10571 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
10572 if (TYPE_ARTIFICIAL (type
))
10573 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
10575 return mod_type_die
;
10578 /* Generate DIEs for the generic parameters of T.
10579 T must be either a generic type or a generic function.
10580 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10583 gen_generic_params_dies (tree t
)
10587 dw_die_ref die
= NULL
;
10590 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
10594 die
= lookup_type_die (t
);
10595 else if (DECL_P (t
))
10596 die
= lookup_decl_die (t
);
10600 parms
= lang_hooks
.get_innermost_generic_parms (t
);
10602 /* T has no generic parameter. It means T is neither a generic type
10603 or function. End of story. */
10606 parms_num
= TREE_VEC_LENGTH (parms
);
10607 args
= lang_hooks
.get_innermost_generic_args (t
);
10608 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
10609 non_default
= int_cst_value (TREE_CHAIN (args
));
10611 non_default
= TREE_VEC_LENGTH (args
);
10612 for (i
= 0; i
< parms_num
; i
++)
10614 tree parm
, arg
, arg_pack_elems
;
10615 dw_die_ref parm_die
;
10617 parm
= TREE_VEC_ELT (parms
, i
);
10618 arg
= TREE_VEC_ELT (args
, i
);
10619 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
10620 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
10622 if (parm
&& TREE_VALUE (parm
) && arg
)
10624 /* If PARM represents a template parameter pack,
10625 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10626 by DW_TAG_template_*_parameter DIEs for the argument
10627 pack elements of ARG. Note that ARG would then be
10628 an argument pack. */
10629 if (arg_pack_elems
)
10630 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
10634 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
10635 true /* emit name */, die
);
10636 if (i
>= non_default
)
10637 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
10642 /* Create and return a DIE for PARM which should be
10643 the representation of a generic type parameter.
10644 For instance, in the C++ front end, PARM would be a template parameter.
10645 ARG is the argument to PARM.
10646 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10648 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10649 as a child node. */
10652 generic_parameter_die (tree parm
, tree arg
,
10654 dw_die_ref parent_die
)
10656 dw_die_ref tmpl_die
= NULL
;
10657 const char *name
= NULL
;
10659 if (!parm
|| !DECL_NAME (parm
) || !arg
)
10662 /* We support non-type generic parameters and arguments,
10663 type generic parameters and arguments, as well as
10664 generic generic parameters (a.k.a. template template parameters in C++)
10666 if (TREE_CODE (parm
) == PARM_DECL
)
10667 /* PARM is a nontype generic parameter */
10668 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
10669 else if (TREE_CODE (parm
) == TYPE_DECL
)
10670 /* PARM is a type generic parameter. */
10671 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
10672 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10673 /* PARM is a generic generic parameter.
10674 Its DIE is a GNU extension. It shall have a
10675 DW_AT_name attribute to represent the name of the template template
10676 parameter, and a DW_AT_GNU_template_name attribute to represent the
10677 name of the template template argument. */
10678 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
10681 gcc_unreachable ();
10687 /* If PARM is a generic parameter pack, it means we are
10688 emitting debug info for a template argument pack element.
10689 In other terms, ARG is a template argument pack element.
10690 In that case, we don't emit any DW_AT_name attribute for
10694 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
10696 add_AT_string (tmpl_die
, DW_AT_name
, name
);
10699 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10701 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10702 TMPL_DIE should have a child DW_AT_type attribute that is set
10703 to the type of the argument to PARM, which is ARG.
10704 If PARM is a type generic parameter, TMPL_DIE should have a
10705 child DW_AT_type that is set to ARG. */
10706 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
10707 add_type_attribute (tmpl_die
, tmpl_type
, 0,
10708 TREE_THIS_VOLATILE (tmpl_type
),
10713 /* So TMPL_DIE is a DIE representing a
10714 a generic generic template parameter, a.k.a template template
10715 parameter in C++ and arg is a template. */
10717 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10718 to the name of the argument. */
10719 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
10721 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
10724 if (TREE_CODE (parm
) == PARM_DECL
)
10725 /* So PARM is a non-type generic parameter.
10726 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10727 attribute of TMPL_DIE which value represents the value
10729 We must be careful here:
10730 The value of ARG might reference some function decls.
10731 We might currently be emitting debug info for a generic
10732 type and types are emitted before function decls, we don't
10733 know if the function decls referenced by ARG will actually be
10734 emitted after cgraph computations.
10735 So must defer the generation of the DW_AT_const_value to
10736 after cgraph is ready. */
10737 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
10743 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
10744 PARM_PACK must be a template parameter pack. The returned DIE
10745 will be child DIE of PARENT_DIE. */
10748 template_parameter_pack_die (tree parm_pack
,
10749 tree parm_pack_args
,
10750 dw_die_ref parent_die
)
10755 gcc_assert (parent_die
&& parm_pack
);
10757 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
10758 add_name_and_src_coords_attributes (die
, parm_pack
);
10759 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
10760 generic_parameter_die (parm_pack
,
10761 TREE_VEC_ELT (parm_pack_args
, j
),
10762 false /* Don't emit DW_AT_name */,
10767 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10768 an enumerated type. */
10771 type_is_enum (const_tree type
)
10773 return TREE_CODE (type
) == ENUMERAL_TYPE
;
10776 /* Return the DBX register number described by a given RTL node. */
10778 static unsigned int
10779 dbx_reg_number (const_rtx rtl
)
10781 unsigned regno
= REGNO (rtl
);
10783 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
10785 #ifdef LEAF_REG_REMAP
10786 if (crtl
->uses_only_leaf_regs
)
10788 int leaf_reg
= LEAF_REG_REMAP (regno
);
10789 if (leaf_reg
!= -1)
10790 regno
= (unsigned) leaf_reg
;
10794 regno
= DBX_REGISTER_NUMBER (regno
);
10795 gcc_assert (regno
!= INVALID_REGNUM
);
10799 /* Optionally add a DW_OP_piece term to a location description expression.
10800 DW_OP_piece is only added if the location description expression already
10801 doesn't end with DW_OP_piece. */
10804 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
10806 dw_loc_descr_ref loc
;
10808 if (*list_head
!= NULL
)
10810 /* Find the end of the chain. */
10811 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
10814 if (loc
->dw_loc_opc
!= DW_OP_piece
)
10815 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
10819 /* Return a location descriptor that designates a machine register or
10820 zero if there is none. */
10822 static dw_loc_descr_ref
10823 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
10827 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
10830 /* We only use "frame base" when we're sure we're talking about the
10831 post-prologue local stack frame. We do this by *not* running
10832 register elimination until this point, and recognizing the special
10833 argument pointer and soft frame pointer rtx's.
10834 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
10835 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
10836 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
10838 dw_loc_descr_ref result
= NULL
;
10840 if (dwarf_version
>= 4 || !dwarf_strict
)
10842 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
10845 add_loc_descr (&result
,
10846 new_loc_descr (DW_OP_stack_value
, 0, 0));
10851 regs
= targetm
.dwarf_register_span (rtl
);
10853 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1 || regs
)
10854 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
10857 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
10858 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
10860 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
10864 /* Return a location descriptor that designates a machine register for
10865 a given hard register number. */
10867 static dw_loc_descr_ref
10868 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
10870 dw_loc_descr_ref reg_loc_descr
;
10874 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
10876 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
10878 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10879 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10881 return reg_loc_descr
;
10884 /* Given an RTL of a register, return a location descriptor that
10885 designates a value that spans more than one register. */
10887 static dw_loc_descr_ref
10888 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
10889 enum var_init_status initialized
)
10892 dw_loc_descr_ref loc_result
= NULL
;
10894 /* Simple, contiguous registers. */
10895 if (regs
== NULL_RTX
)
10897 unsigned reg
= REGNO (rtl
);
10900 #ifdef LEAF_REG_REMAP
10901 if (crtl
->uses_only_leaf_regs
)
10903 int leaf_reg
= LEAF_REG_REMAP (reg
);
10904 if (leaf_reg
!= -1)
10905 reg
= (unsigned) leaf_reg
;
10909 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
10910 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
10912 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
10917 dw_loc_descr_ref t
;
10919 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
10920 VAR_INIT_STATUS_INITIALIZED
);
10921 add_loc_descr (&loc_result
, t
);
10922 add_loc_descr_op_piece (&loc_result
, size
);
10928 /* Now onto stupid register sets in non contiguous locations. */
10930 gcc_assert (GET_CODE (regs
) == PARALLEL
);
10932 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
10935 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
10937 dw_loc_descr_ref t
;
10939 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
10940 VAR_INIT_STATUS_INITIALIZED
);
10941 add_loc_descr (&loc_result
, t
);
10942 add_loc_descr_op_piece (&loc_result
, size
);
10945 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10946 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10950 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
10952 /* Return a location descriptor that designates a constant i,
10953 as a compound operation from constant (i >> shift), constant shift
10956 static dw_loc_descr_ref
10957 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
10959 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
10960 add_loc_descr (&ret
, int_loc_descriptor (shift
));
10961 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
10965 /* Return a location descriptor that designates a constant. */
10967 static dw_loc_descr_ref
10968 int_loc_descriptor (HOST_WIDE_INT i
)
10970 enum dwarf_location_atom op
;
10972 /* Pick the smallest representation of a constant, rather than just
10973 defaulting to the LEB encoding. */
10976 int clz
= clz_hwi (i
);
10977 int ctz
= ctz_hwi (i
);
10979 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
10980 else if (i
<= 0xff)
10981 op
= DW_OP_const1u
;
10982 else if (i
<= 0xffff)
10983 op
= DW_OP_const2u
;
10984 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
10985 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
10986 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
10987 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
10988 while DW_OP_const4u is 5 bytes. */
10989 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
10990 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
10991 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
10992 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
10993 while DW_OP_const4u is 5 bytes. */
10994 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
10995 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
10996 op
= DW_OP_const4u
;
10997 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
10998 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
10999 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
11000 while DW_OP_constu of constant >= 0x100000000 takes at least
11002 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
11003 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11004 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
11005 >= HOST_BITS_PER_WIDE_INT
)
11006 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
11007 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
11008 while DW_OP_constu takes in this case at least 6 bytes. */
11009 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
11010 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11011 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11012 && size_of_uleb128 (i
) > 6)
11013 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
11014 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
11021 op
= DW_OP_const1s
;
11022 else if (i
>= -0x8000)
11023 op
= DW_OP_const2s
;
11024 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11026 if (size_of_int_loc_descriptor (i
) < 5)
11028 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11029 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11032 op
= DW_OP_const4s
;
11036 if (size_of_int_loc_descriptor (i
)
11037 < (unsigned long) 1 + size_of_sleb128 (i
))
11039 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
11040 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11047 return new_loc_descr (op
, i
, 0);
11050 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
11051 without actually allocating it. */
11053 static unsigned long
11054 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
11056 return size_of_int_loc_descriptor (i
>> shift
)
11057 + size_of_int_loc_descriptor (shift
)
11061 /* Return size_of_locs (int_loc_descriptor (i)) without
11062 actually allocating it. */
11064 static unsigned long
11065 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
11074 else if (i
<= 0xff)
11076 else if (i
<= 0xffff)
11080 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
11081 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
11082 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11084 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11085 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
11086 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11088 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
11090 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
11091 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
11092 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
11093 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11095 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
11096 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
11097 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11099 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
11100 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
11102 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
11111 else if (i
>= -0x8000)
11113 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
11115 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11117 s
= size_of_int_loc_descriptor (-i
) + 1;
11125 unsigned long r
= 1 + size_of_sleb128 (i
);
11126 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
11128 s
= size_of_int_loc_descriptor (-i
) + 1;
11137 /* Return loc description representing "address" of integer value.
11138 This can appear only as toplevel expression. */
11140 static dw_loc_descr_ref
11141 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
11144 dw_loc_descr_ref loc_result
= NULL
;
11146 if (!(dwarf_version
>= 4 || !dwarf_strict
))
11149 litsize
= size_of_int_loc_descriptor (i
);
11150 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11151 is more compact. For DW_OP_stack_value we need:
11152 litsize + 1 (DW_OP_stack_value)
11153 and for DW_OP_implicit_value:
11154 1 (DW_OP_implicit_value) + 1 (length) + size. */
11155 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
11157 loc_result
= int_loc_descriptor (i
);
11158 add_loc_descr (&loc_result
,
11159 new_loc_descr (DW_OP_stack_value
, 0, 0));
11163 loc_result
= new_loc_descr (DW_OP_implicit_value
,
11165 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
11166 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
11170 /* Return a location descriptor that designates a base+offset location. */
11172 static dw_loc_descr_ref
11173 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
11174 enum var_init_status initialized
)
11176 unsigned int regno
;
11177 dw_loc_descr_ref result
;
11178 dw_fde_ref fde
= cfun
->fde
;
11180 /* We only use "frame base" when we're sure we're talking about the
11181 post-prologue local stack frame. We do this by *not* running
11182 register elimination until this point, and recognizing the special
11183 argument pointer and soft frame pointer rtx's. */
11184 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
11186 rtx elim
= (ira_use_lra_p
11187 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
11188 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
11192 if (GET_CODE (elim
) == PLUS
)
11194 offset
+= INTVAL (XEXP (elim
, 1));
11195 elim
= XEXP (elim
, 0);
11197 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
11198 && (elim
== hard_frame_pointer_rtx
11199 || elim
== stack_pointer_rtx
))
11200 || elim
== (frame_pointer_needed
11201 ? hard_frame_pointer_rtx
11202 : stack_pointer_rtx
));
11204 /* If drap register is used to align stack, use frame
11205 pointer + offset to access stack variables. If stack
11206 is aligned without drap, use stack pointer + offset to
11207 access stack variables. */
11208 if (crtl
->stack_realign_tried
11209 && reg
== frame_pointer_rtx
)
11212 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
11213 ? HARD_FRAME_POINTER_REGNUM
11215 return new_reg_loc_descr (base_reg
, offset
);
11218 gcc_assert (frame_pointer_fb_offset_valid
);
11219 offset
+= frame_pointer_fb_offset
;
11220 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11224 regno
= REGNO (reg
);
11225 #ifdef LEAF_REG_REMAP
11226 if (crtl
->uses_only_leaf_regs
)
11228 int leaf_reg
= LEAF_REG_REMAP (regno
);
11229 if (leaf_reg
!= -1)
11230 regno
= (unsigned) leaf_reg
;
11233 regno
= DWARF_FRAME_REGNUM (regno
);
11235 if (!optimize
&& fde
11236 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
))
11238 /* Use cfa+offset to represent the location of arguments passed
11239 on the stack when drap is used to align stack.
11240 Only do this when not optimizing, for optimized code var-tracking
11241 is supposed to track where the arguments live and the register
11242 used as vdrap or drap in some spot might be used for something
11243 else in other part of the routine. */
11244 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
11248 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
11251 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
11253 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
11254 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
11259 /* Return true if this RTL expression describes a base+offset calculation. */
11262 is_based_loc (const_rtx rtl
)
11264 return (GET_CODE (rtl
) == PLUS
11265 && ((REG_P (XEXP (rtl
, 0))
11266 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
11267 && CONST_INT_P (XEXP (rtl
, 1)))));
11270 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11273 static dw_loc_descr_ref
11274 tls_mem_loc_descriptor (rtx mem
)
11277 dw_loc_descr_ref loc_result
;
11279 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
11282 base
= get_base_address (MEM_EXPR (mem
));
11284 || TREE_CODE (base
) != VAR_DECL
11285 || !DECL_THREAD_LOCAL_P (base
))
11288 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1);
11289 if (loc_result
== NULL
)
11292 if (MEM_OFFSET (mem
))
11293 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
11298 /* Output debug info about reason why we failed to expand expression as dwarf
11302 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
11304 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
11306 fprintf (dump_file
, "Failed to expand as dwarf: ");
11308 print_generic_expr (dump_file
, expr
, dump_flags
);
11311 fprintf (dump_file
, "\n");
11312 print_rtl (dump_file
, rtl
);
11314 fprintf (dump_file
, "\nReason: %s\n", reason
);
11318 /* Helper function for const_ok_for_output, called either directly
11319 or via for_each_rtx. */
11322 const_ok_for_output_1 (rtx
*rtlp
, void *data ATTRIBUTE_UNUSED
)
11326 if (GET_CODE (rtl
) == UNSPEC
)
11328 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
11329 we can't express it in the debug info. */
11330 #ifdef ENABLE_CHECKING
11331 /* Don't complain about TLS UNSPECs, those are just too hard to
11332 delegitimize. Note this could be a non-decl SYMBOL_REF such as
11333 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
11334 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
11335 if (XVECLEN (rtl
, 0) == 0
11336 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
11337 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
)
11338 inform (current_function_decl
11339 ? DECL_SOURCE_LOCATION (current_function_decl
)
11340 : UNKNOWN_LOCATION
,
11341 #if NUM_UNSPEC_VALUES > 0
11342 "non-delegitimized UNSPEC %s (%d) found in variable location",
11343 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
11344 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
11347 "non-delegitimized UNSPEC %d found in variable location",
11351 expansion_failed (NULL_TREE
, rtl
,
11352 "UNSPEC hasn't been delegitimized.\n");
11356 if (targetm
.const_not_ok_for_debug_p (rtl
))
11358 expansion_failed (NULL_TREE
, rtl
,
11359 "Expression rejected for debug by the backend.\n");
11363 /* FIXME: Refer to PR60655. It is possible for simplification
11364 of rtl expressions in var tracking to produce such expressions.
11365 We should really identify / validate expressions
11366 enclosed in CONST that can be handled by assemblers on various
11367 targets and only handle legitimate cases here. */
11368 if (GET_CODE (rtl
) != SYMBOL_REF
)
11370 if (GET_CODE (rtl
) == NOT
)
11376 if (CONSTANT_POOL_ADDRESS_P (rtl
))
11379 get_pool_constant_mark (rtl
, &marked
);
11380 /* If all references to this pool constant were optimized away,
11381 it was not output and thus we can't represent it. */
11384 expansion_failed (NULL_TREE
, rtl
,
11385 "Constant was removed from constant pool.\n");
11390 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
11393 /* Avoid references to external symbols in debug info, on several targets
11394 the linker might even refuse to link when linking a shared library,
11395 and in many other cases the relocations for .debug_info/.debug_loc are
11396 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
11397 to be defined within the same shared library or executable are fine. */
11398 if (SYMBOL_REF_EXTERNAL_P (rtl
))
11400 tree decl
= SYMBOL_REF_DECL (rtl
);
11402 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
11404 expansion_failed (NULL_TREE
, rtl
,
11405 "Symbol not defined in current TU.\n");
11413 /* Return true if constant RTL can be emitted in DW_OP_addr or
11414 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
11415 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
11418 const_ok_for_output (rtx rtl
)
11420 if (GET_CODE (rtl
) == SYMBOL_REF
)
11421 return const_ok_for_output_1 (&rtl
, NULL
) == 0;
11423 if (GET_CODE (rtl
) == CONST
)
11424 return for_each_rtx (&XEXP (rtl
, 0), const_ok_for_output_1
, NULL
) == 0;
11429 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
11430 if possible, NULL otherwise. */
11433 base_type_for_mode (enum machine_mode mode
, bool unsignedp
)
11435 dw_die_ref type_die
;
11436 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
11440 switch (TREE_CODE (type
))
11448 type_die
= lookup_type_die (type
);
11450 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, comp_unit_die ());
11451 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
11456 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
11457 type matching MODE, or, if MODE is narrower than or as wide as
11458 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
11461 static dw_loc_descr_ref
11462 convert_descriptor_to_mode (enum machine_mode mode
, dw_loc_descr_ref op
)
11464 enum machine_mode outer_mode
= mode
;
11465 dw_die_ref type_die
;
11466 dw_loc_descr_ref cvt
;
11468 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
11470 add_loc_descr (&op
, new_loc_descr (DW_OP_GNU_convert
, 0, 0));
11473 type_die
= base_type_for_mode (outer_mode
, 1);
11474 if (type_die
== NULL
)
11476 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11477 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11478 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11479 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11480 add_loc_descr (&op
, cvt
);
11484 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
11486 static dw_loc_descr_ref
11487 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
11488 dw_loc_descr_ref op1
)
11490 dw_loc_descr_ref ret
= op0
;
11491 add_loc_descr (&ret
, op1
);
11492 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11493 if (STORE_FLAG_VALUE
!= 1)
11495 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
11496 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
11501 /* Return location descriptor for signed comparison OP RTL. */
11503 static dw_loc_descr_ref
11504 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11505 enum machine_mode mem_mode
)
11507 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11508 dw_loc_descr_ref op0
, op1
;
11511 if (op_mode
== VOIDmode
)
11512 op_mode
= GET_MODE (XEXP (rtl
, 1));
11513 if (op_mode
== VOIDmode
)
11517 && (GET_MODE_CLASS (op_mode
) != MODE_INT
11518 || GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
))
11521 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11522 VAR_INIT_STATUS_INITIALIZED
);
11523 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11524 VAR_INIT_STATUS_INITIALIZED
);
11526 if (op0
== NULL
|| op1
== NULL
)
11529 if (GET_MODE_CLASS (op_mode
) != MODE_INT
11530 || GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11531 return compare_loc_descriptor (op
, op0
, op1
);
11533 if (GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11535 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
11536 dw_loc_descr_ref cvt
;
11538 if (type_die
== NULL
)
11540 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11541 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11542 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11543 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11544 add_loc_descr (&op0
, cvt
);
11545 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11546 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11547 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11548 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11549 add_loc_descr (&op1
, cvt
);
11550 return compare_loc_descriptor (op
, op0
, op1
);
11553 shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
11554 /* For eq/ne, if the operands are known to be zero-extended,
11555 there is no need to do the fancy shifting up. */
11556 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
11558 dw_loc_descr_ref last0
, last1
;
11559 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11561 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11563 /* deref_size zero extends, and for constants we can check
11564 whether they are zero extended or not. */
11565 if (((last0
->dw_loc_opc
== DW_OP_deref_size
11566 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11567 || (CONST_INT_P (XEXP (rtl
, 0))
11568 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
11569 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
11570 && ((last1
->dw_loc_opc
== DW_OP_deref_size
11571 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
11572 || (CONST_INT_P (XEXP (rtl
, 1))
11573 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
11574 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
11575 return compare_loc_descriptor (op
, op0
, op1
);
11577 /* EQ/NE comparison against constant in narrower type than
11578 DWARF2_ADDR_SIZE can be performed either as
11579 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
11582 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
11583 DW_OP_{eq,ne}. Pick whatever is shorter. */
11584 if (CONST_INT_P (XEXP (rtl
, 1))
11585 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
11586 && (size_of_int_loc_descriptor (shift
) + 1
11587 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
)
11588 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
11589 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11590 & GET_MODE_MASK (op_mode
))))
11592 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
11593 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11594 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
11595 & GET_MODE_MASK (op_mode
));
11596 return compare_loc_descriptor (op
, op0
, op1
);
11599 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11600 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11601 if (CONST_INT_P (XEXP (rtl
, 1)))
11602 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
);
11605 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11606 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11608 return compare_loc_descriptor (op
, op0
, op1
);
11611 /* Return location descriptor for unsigned comparison OP RTL. */
11613 static dw_loc_descr_ref
11614 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
11615 enum machine_mode mem_mode
)
11617 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
11618 dw_loc_descr_ref op0
, op1
;
11620 if (op_mode
== VOIDmode
)
11621 op_mode
= GET_MODE (XEXP (rtl
, 1));
11622 if (op_mode
== VOIDmode
)
11624 if (GET_MODE_CLASS (op_mode
) != MODE_INT
)
11627 if (dwarf_strict
&& GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
11630 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
11631 VAR_INIT_STATUS_INITIALIZED
);
11632 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
11633 VAR_INIT_STATUS_INITIALIZED
);
11635 if (op0
== NULL
|| op1
== NULL
)
11638 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
11640 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
11641 dw_loc_descr_ref last0
, last1
;
11642 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
11644 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
11646 if (CONST_INT_P (XEXP (rtl
, 0)))
11647 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
11648 /* deref_size zero extends, so no need to mask it again. */
11649 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
11650 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11652 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11653 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11655 if (CONST_INT_P (XEXP (rtl
, 1)))
11656 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
11657 /* deref_size zero extends, so no need to mask it again. */
11658 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
11659 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11661 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11662 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11665 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11667 HOST_WIDE_INT bias
= 1;
11668 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11669 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11670 if (CONST_INT_P (XEXP (rtl
, 1)))
11671 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
11672 + INTVAL (XEXP (rtl
, 1)));
11674 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
11677 return compare_loc_descriptor (op
, op0
, op1
);
11680 /* Return location descriptor for {U,S}{MIN,MAX}. */
11682 static dw_loc_descr_ref
11683 minmax_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11684 enum machine_mode mem_mode
)
11686 enum dwarf_location_atom op
;
11687 dw_loc_descr_ref op0
, op1
, ret
;
11688 dw_loc_descr_ref bra_node
, drop_node
;
11691 && (GET_MODE_CLASS (mode
) != MODE_INT
11692 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
))
11695 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11696 VAR_INIT_STATUS_INITIALIZED
);
11697 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11698 VAR_INIT_STATUS_INITIALIZED
);
11700 if (op0
== NULL
|| op1
== NULL
)
11703 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
11704 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
11705 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
11706 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
11708 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11710 HOST_WIDE_INT mask
= GET_MODE_MASK (mode
);
11711 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11712 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11713 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11714 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11716 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
11718 HOST_WIDE_INT bias
= 1;
11719 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11720 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11721 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11724 else if (GET_MODE_CLASS (mode
) == MODE_INT
11725 && GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11727 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (mode
)) * BITS_PER_UNIT
;
11728 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11729 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11730 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11731 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11733 else if (GET_MODE_CLASS (mode
) == MODE_INT
11734 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11736 dw_die_ref type_die
= base_type_for_mode (mode
, 0);
11737 dw_loc_descr_ref cvt
;
11738 if (type_die
== NULL
)
11740 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11741 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11742 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11743 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11744 add_loc_descr (&op0
, cvt
);
11745 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11746 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11747 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11748 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11749 add_loc_descr (&op1
, cvt
);
11752 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
11757 add_loc_descr (&ret
, op1
);
11758 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11759 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
11760 add_loc_descr (&ret
, bra_node
);
11761 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11762 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
11763 add_loc_descr (&ret
, drop_node
);
11764 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11765 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
11766 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
11767 && GET_MODE_CLASS (mode
) == MODE_INT
11768 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11769 ret
= convert_descriptor_to_mode (mode
, ret
);
11773 /* Helper function for mem_loc_descriptor. Perform OP binary op,
11774 but after converting arguments to type_die, afterwards
11775 convert back to unsigned. */
11777 static dw_loc_descr_ref
11778 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
11779 enum machine_mode mode
, enum machine_mode mem_mode
)
11781 dw_loc_descr_ref cvt
, op0
, op1
;
11783 if (type_die
== NULL
)
11785 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11786 VAR_INIT_STATUS_INITIALIZED
);
11787 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11788 VAR_INIT_STATUS_INITIALIZED
);
11789 if (op0
== NULL
|| op1
== NULL
)
11791 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11792 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11793 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11794 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11795 add_loc_descr (&op0
, cvt
);
11796 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11797 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11798 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11799 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11800 add_loc_descr (&op1
, cvt
);
11801 add_loc_descr (&op0
, op1
);
11802 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
11803 return convert_descriptor_to_mode (mode
, op0
);
11806 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
11807 const0 is DW_OP_lit0 or corresponding typed constant,
11808 const1 is DW_OP_lit1 or corresponding typed constant
11809 and constMSB is constant with just the MSB bit set
11811 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11812 L1: const0 DW_OP_swap
11813 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
11814 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11819 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11820 L1: const0 DW_OP_swap
11821 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11822 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11827 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
11828 L1: const1 DW_OP_swap
11829 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11830 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11834 static dw_loc_descr_ref
11835 clz_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11836 enum machine_mode mem_mode
)
11838 dw_loc_descr_ref op0
, ret
, tmp
;
11839 HOST_WIDE_INT valv
;
11840 dw_loc_descr_ref l1jump
, l1label
;
11841 dw_loc_descr_ref l2jump
, l2label
;
11842 dw_loc_descr_ref l3jump
, l3label
;
11843 dw_loc_descr_ref l4jump
, l4label
;
11846 if (GET_MODE_CLASS (mode
) != MODE_INT
11847 || GET_MODE (XEXP (rtl
, 0)) != mode
11848 || (GET_CODE (rtl
) == CLZ
11849 && GET_MODE_BITSIZE (mode
) > HOST_BITS_PER_DOUBLE_INT
))
11852 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11853 VAR_INIT_STATUS_INITIALIZED
);
11857 if (GET_CODE (rtl
) == CLZ
)
11859 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11860 valv
= GET_MODE_BITSIZE (mode
);
11862 else if (GET_CODE (rtl
) == FFS
)
11864 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11865 valv
= GET_MODE_BITSIZE (mode
);
11866 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11867 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11868 add_loc_descr (&ret
, l1jump
);
11869 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
11870 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
11871 VAR_INIT_STATUS_INITIALIZED
);
11874 add_loc_descr (&ret
, tmp
);
11875 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11876 add_loc_descr (&ret
, l4jump
);
11877 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
11878 ? const1_rtx
: const0_rtx
,
11880 VAR_INIT_STATUS_INITIALIZED
);
11881 if (l1label
== NULL
)
11883 add_loc_descr (&ret
, l1label
);
11884 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11885 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
11886 add_loc_descr (&ret
, l2label
);
11887 if (GET_CODE (rtl
) != CLZ
)
11889 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
11890 msb
= GEN_INT ((unsigned HOST_WIDE_INT
) 1
11891 << (GET_MODE_BITSIZE (mode
) - 1));
11893 msb
= immed_double_const (0, (unsigned HOST_WIDE_INT
) 1
11894 << (GET_MODE_BITSIZE (mode
)
11895 - HOST_BITS_PER_WIDE_INT
- 1), mode
);
11896 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
11897 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
11898 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
11899 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
11901 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
11902 VAR_INIT_STATUS_INITIALIZED
);
11905 add_loc_descr (&ret
, tmp
);
11906 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
11907 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11908 add_loc_descr (&ret
, l3jump
);
11909 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11910 VAR_INIT_STATUS_INITIALIZED
);
11913 add_loc_descr (&ret
, tmp
);
11914 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
11915 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
11916 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11917 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
11918 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11919 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11920 add_loc_descr (&ret
, l2jump
);
11921 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
11922 add_loc_descr (&ret
, l3label
);
11923 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
11924 add_loc_descr (&ret
, l4label
);
11925 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11926 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
11927 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11928 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
11929 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11930 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
11931 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11932 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
11936 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
11937 const1 is DW_OP_lit1 or corresponding typed constant):
11939 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
11940 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
11944 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
11945 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
11948 static dw_loc_descr_ref
11949 popcount_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11950 enum machine_mode mem_mode
)
11952 dw_loc_descr_ref op0
, ret
, tmp
;
11953 dw_loc_descr_ref l1jump
, l1label
;
11954 dw_loc_descr_ref l2jump
, l2label
;
11956 if (GET_MODE_CLASS (mode
) != MODE_INT
11957 || GET_MODE (XEXP (rtl
, 0)) != mode
)
11960 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11961 VAR_INIT_STATUS_INITIALIZED
);
11965 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
11966 VAR_INIT_STATUS_INITIALIZED
);
11969 add_loc_descr (&ret
, tmp
);
11970 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11971 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
11972 add_loc_descr (&ret
, l1label
);
11973 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11974 add_loc_descr (&ret
, l2jump
);
11975 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11976 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
11977 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11978 VAR_INIT_STATUS_INITIALIZED
);
11981 add_loc_descr (&ret
, tmp
);
11982 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
11983 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
11984 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
11985 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11986 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11987 VAR_INIT_STATUS_INITIALIZED
);
11988 add_loc_descr (&ret
, tmp
);
11989 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
11990 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11991 add_loc_descr (&ret
, l1jump
);
11992 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
11993 add_loc_descr (&ret
, l2label
);
11994 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11995 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
11996 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11997 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12001 /* BSWAP (constS is initial shift count, either 56 or 24):
12003 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
12004 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
12005 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
12006 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
12007 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
12009 static dw_loc_descr_ref
12010 bswap_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12011 enum machine_mode mem_mode
)
12013 dw_loc_descr_ref op0
, ret
, tmp
;
12014 dw_loc_descr_ref l1jump
, l1label
;
12015 dw_loc_descr_ref l2jump
, l2label
;
12017 if (GET_MODE_CLASS (mode
) != MODE_INT
12018 || BITS_PER_UNIT
!= 8
12019 || (GET_MODE_BITSIZE (mode
) != 32
12020 && GET_MODE_BITSIZE (mode
) != 64))
12023 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12024 VAR_INIT_STATUS_INITIALIZED
);
12029 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12031 VAR_INIT_STATUS_INITIALIZED
);
12034 add_loc_descr (&ret
, tmp
);
12035 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12036 VAR_INIT_STATUS_INITIALIZED
);
12039 add_loc_descr (&ret
, tmp
);
12040 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
12041 add_loc_descr (&ret
, l1label
);
12042 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
12044 VAR_INIT_STATUS_INITIALIZED
);
12045 add_loc_descr (&ret
, tmp
);
12046 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
12047 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12048 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12049 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
12050 VAR_INIT_STATUS_INITIALIZED
);
12053 add_loc_descr (&ret
, tmp
);
12054 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
12055 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
12056 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12057 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12058 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12059 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
12060 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
12061 VAR_INIT_STATUS_INITIALIZED
);
12062 add_loc_descr (&ret
, tmp
);
12063 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
12064 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
12065 add_loc_descr (&ret
, l2jump
);
12066 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
12067 VAR_INIT_STATUS_INITIALIZED
);
12068 add_loc_descr (&ret
, tmp
);
12069 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
12070 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12071 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
12072 add_loc_descr (&ret
, l1jump
);
12073 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
12074 add_loc_descr (&ret
, l2label
);
12075 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12076 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
12077 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12078 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
12079 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12080 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
12084 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
12085 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12086 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
12087 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
12089 ROTATERT is similar:
12090 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
12091 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12092 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
12094 static dw_loc_descr_ref
12095 rotate_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12096 enum machine_mode mem_mode
)
12098 rtx rtlop1
= XEXP (rtl
, 1);
12099 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
12102 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12105 if (GET_MODE (rtlop1
) != VOIDmode
12106 && GET_MODE_BITSIZE (GET_MODE (rtlop1
)) < GET_MODE_BITSIZE (mode
))
12107 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12108 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12109 VAR_INIT_STATUS_INITIALIZED
);
12110 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12111 VAR_INIT_STATUS_INITIALIZED
);
12112 if (op0
== NULL
|| op1
== NULL
)
12114 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
12115 for (i
= 0; i
< 2; i
++)
12117 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
12118 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
12120 VAR_INIT_STATUS_INITIALIZED
);
12121 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12122 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
12124 : HOST_BITS_PER_WIDE_INT
== 64
12125 ? DW_OP_const8u
: DW_OP_constu
,
12126 GET_MODE_MASK (mode
), 0);
12129 if (mask
[i
] == NULL
)
12131 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
12134 add_loc_descr (&ret
, op1
);
12135 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12136 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
12137 if (GET_CODE (rtl
) == ROTATERT
)
12139 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12140 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12141 GET_MODE_BITSIZE (mode
), 0));
12143 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
12144 if (mask
[0] != NULL
)
12145 add_loc_descr (&ret
, mask
[0]);
12146 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
12147 if (mask
[1] != NULL
)
12149 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12150 add_loc_descr (&ret
, mask
[1]);
12151 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
12153 if (GET_CODE (rtl
) == ROTATE
)
12155 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
12156 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
12157 GET_MODE_BITSIZE (mode
), 0));
12159 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
12160 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
12164 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
12165 for DEBUG_PARAMETER_REF RTL. */
12167 static dw_loc_descr_ref
12168 parameter_ref_descriptor (rtx rtl
)
12170 dw_loc_descr_ref ret
;
12175 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
12176 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
12177 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
12180 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12181 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
12182 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12186 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
12187 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
12192 /* The following routine converts the RTL for a variable or parameter
12193 (resident in memory) into an equivalent Dwarf representation of a
12194 mechanism for getting the address of that same variable onto the top of a
12195 hypothetical "address evaluation" stack.
12197 When creating memory location descriptors, we are effectively transforming
12198 the RTL for a memory-resident object into its Dwarf postfix expression
12199 equivalent. This routine recursively descends an RTL tree, turning
12200 it into Dwarf postfix code as it goes.
12202 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
12204 MEM_MODE is the mode of the memory reference, needed to handle some
12205 autoincrement addressing modes.
12207 Return 0 if we can't represent the location. */
12210 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
,
12211 enum machine_mode mem_mode
,
12212 enum var_init_status initialized
)
12214 dw_loc_descr_ref mem_loc_result
= NULL
;
12215 enum dwarf_location_atom op
;
12216 dw_loc_descr_ref op0
, op1
;
12217 rtx inner
= NULL_RTX
;
12219 if (mode
== VOIDmode
)
12220 mode
= GET_MODE (rtl
);
12222 /* Note that for a dynamically sized array, the location we will generate a
12223 description of here will be the lowest numbered location which is
12224 actually within the array. That's *not* necessarily the same as the
12225 zeroth element of the array. */
12227 rtl
= targetm
.delegitimize_address (rtl
);
12229 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
12232 switch (GET_CODE (rtl
))
12237 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
12240 /* The case of a subreg may arise when we have a local (register)
12241 variable or a formal (register) parameter which doesn't quite fill
12242 up an entire register. For now, just assume that it is
12243 legitimate to make the Dwarf info refer to the whole register which
12244 contains the given subreg. */
12245 if (!subreg_lowpart_p (rtl
))
12247 inner
= SUBREG_REG (rtl
);
12249 if (inner
== NULL_RTX
)
12250 inner
= XEXP (rtl
, 0);
12251 if (GET_MODE_CLASS (mode
) == MODE_INT
12252 && GET_MODE_CLASS (GET_MODE (inner
)) == MODE_INT
12253 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12254 #ifdef POINTERS_EXTEND_UNSIGNED
12255 || (mode
== Pmode
&& mem_mode
!= VOIDmode
)
12258 && GET_MODE_SIZE (GET_MODE (inner
)) <= DWARF2_ADDR_SIZE
)
12260 mem_loc_result
= mem_loc_descriptor (inner
,
12262 mem_mode
, initialized
);
12267 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (inner
)))
12269 if (GET_MODE_SIZE (mode
) != GET_MODE_SIZE (GET_MODE (inner
))
12270 && (GET_MODE_CLASS (mode
) != MODE_INT
12271 || GET_MODE_CLASS (GET_MODE (inner
)) != MODE_INT
))
12275 dw_die_ref type_die
;
12276 dw_loc_descr_ref cvt
;
12278 mem_loc_result
= mem_loc_descriptor (inner
,
12280 mem_mode
, initialized
);
12281 if (mem_loc_result
== NULL
)
12283 type_die
= base_type_for_mode (mode
,
12284 GET_MODE_CLASS (mode
) == MODE_INT
);
12285 if (type_die
== NULL
)
12287 mem_loc_result
= NULL
;
12290 if (GET_MODE_SIZE (mode
)
12291 != GET_MODE_SIZE (GET_MODE (inner
)))
12292 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12294 cvt
= new_loc_descr (DW_OP_GNU_reinterpret
, 0, 0);
12295 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12296 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12297 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12298 add_loc_descr (&mem_loc_result
, cvt
);
12303 if (GET_MODE_CLASS (mode
) != MODE_INT
12304 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12305 && rtl
!= arg_pointer_rtx
12306 && rtl
!= frame_pointer_rtx
12307 #ifdef POINTERS_EXTEND_UNSIGNED
12308 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12312 dw_die_ref type_die
;
12313 unsigned int dbx_regnum
;
12317 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
12319 type_die
= base_type_for_mode (mode
,
12320 GET_MODE_CLASS (mode
) == MODE_INT
);
12321 if (type_die
== NULL
)
12324 dbx_regnum
= dbx_reg_number (rtl
);
12325 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12327 mem_loc_result
= new_loc_descr (DW_OP_GNU_regval_type
,
12329 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12330 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12331 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12334 /* Whenever a register number forms a part of the description of the
12335 method for calculating the (dynamic) address of a memory resident
12336 object, DWARF rules require the register number be referred to as
12337 a "base register". This distinction is not based in any way upon
12338 what category of register the hardware believes the given register
12339 belongs to. This is strictly DWARF terminology we're dealing with
12340 here. Note that in cases where the location of a memory-resident
12341 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12342 OP_CONST (0)) the actual DWARF location descriptor that we generate
12343 may just be OP_BASEREG (basereg). This may look deceptively like
12344 the object in question was allocated to a register (rather than in
12345 memory) so DWARF consumers need to be aware of the subtle
12346 distinction between OP_REG and OP_BASEREG. */
12347 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
12348 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
12349 else if (stack_realign_drap
12351 && crtl
->args
.internal_arg_pointer
== rtl
12352 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
12354 /* If RTL is internal_arg_pointer, which has been optimized
12355 out, use DRAP instead. */
12356 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
12357 VAR_INIT_STATUS_INITIALIZED
);
12363 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12365 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12366 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12369 else if (GET_CODE (rtl
) == ZERO_EXTEND
12370 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12371 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
12372 < HOST_BITS_PER_WIDE_INT
12373 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
12374 to expand zero extend as two shifts instead of
12376 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= 4)
12378 enum machine_mode imode
= GET_MODE (XEXP (rtl
, 0));
12379 mem_loc_result
= op0
;
12380 add_loc_descr (&mem_loc_result
,
12381 int_loc_descriptor (GET_MODE_MASK (imode
)));
12382 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
12384 else if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12386 int shift
= DWARF2_ADDR_SIZE
12387 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
12388 shift
*= BITS_PER_UNIT
;
12389 if (GET_CODE (rtl
) == SIGN_EXTEND
)
12393 mem_loc_result
= op0
;
12394 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12395 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
12396 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
12397 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12399 else if (!dwarf_strict
)
12401 dw_die_ref type_die1
, type_die2
;
12402 dw_loc_descr_ref cvt
;
12404 type_die1
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
12405 GET_CODE (rtl
) == ZERO_EXTEND
);
12406 if (type_die1
== NULL
)
12408 type_die2
= base_type_for_mode (mode
, 1);
12409 if (type_die2
== NULL
)
12411 mem_loc_result
= op0
;
12412 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12413 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12414 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
12415 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12416 add_loc_descr (&mem_loc_result
, cvt
);
12417 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12418 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12419 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
12420 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12421 add_loc_descr (&mem_loc_result
, cvt
);
12427 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
12428 if (new_rtl
!= rtl
)
12430 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
12432 if (mem_loc_result
!= NULL
)
12433 return mem_loc_result
;
12436 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
12437 get_address_mode (rtl
), mode
,
12438 VAR_INIT_STATUS_INITIALIZED
);
12439 if (mem_loc_result
== NULL
)
12440 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
12441 if (mem_loc_result
!= NULL
)
12443 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12444 || GET_MODE_CLASS (mode
) != MODE_INT
)
12446 dw_die_ref type_die
;
12447 dw_loc_descr_ref deref
;
12452 = base_type_for_mode (mode
, GET_MODE_CLASS (mode
) == MODE_INT
);
12453 if (type_die
== NULL
)
12455 deref
= new_loc_descr (DW_OP_GNU_deref_type
,
12456 GET_MODE_SIZE (mode
), 0);
12457 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
12458 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
12459 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
12460 add_loc_descr (&mem_loc_result
, deref
);
12462 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
12463 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
12465 add_loc_descr (&mem_loc_result
,
12466 new_loc_descr (DW_OP_deref_size
,
12467 GET_MODE_SIZE (mode
), 0));
12472 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
12475 /* Some ports can transform a symbol ref into a label ref, because
12476 the symbol ref is too far away and has to be dumped into a constant
12480 if (GET_MODE_CLASS (mode
) != MODE_INT
12481 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
12482 #ifdef POINTERS_EXTEND_UNSIGNED
12483 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
12487 if (GET_CODE (rtl
) == SYMBOL_REF
12488 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
12490 dw_loc_descr_ref temp
;
12492 /* If this is not defined, we have no way to emit the data. */
12493 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
12496 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
12498 mem_loc_result
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
12499 add_loc_descr (&mem_loc_result
, temp
);
12504 if (!const_ok_for_output (rtl
))
12508 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
12509 vec_safe_push (used_rtx_array
, rtl
);
12515 case DEBUG_IMPLICIT_PTR
:
12516 expansion_failed (NULL_TREE
, rtl
,
12517 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
12523 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
12525 if (GET_MODE_CLASS (mode
) != MODE_INT
12526 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12527 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12528 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12531 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
12532 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
12534 op0
= one_reg_loc_descriptor (dbx_regnum
,
12535 VAR_INIT_STATUS_INITIALIZED
);
12538 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
12539 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
12541 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
12542 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12543 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
12547 gcc_unreachable ();
12550 mem_loc_result
= new_loc_descr (DW_OP_GNU_entry_value
, 0, 0);
12551 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12552 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
12555 case DEBUG_PARAMETER_REF
:
12556 mem_loc_result
= parameter_ref_descriptor (rtl
);
12560 /* Extract the PLUS expression nested inside and fall into
12561 PLUS code below. */
12562 rtl
= XEXP (rtl
, 1);
12567 /* Turn these into a PLUS expression and fall into the PLUS code
12569 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
12570 gen_int_mode (GET_CODE (rtl
) == PRE_INC
12571 ? GET_MODE_UNIT_SIZE (mem_mode
)
12572 : -GET_MODE_UNIT_SIZE (mem_mode
),
12575 /* ... fall through ... */
12579 if (is_based_loc (rtl
)
12580 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12581 || XEXP (rtl
, 0) == arg_pointer_rtx
12582 || XEXP (rtl
, 0) == frame_pointer_rtx
)
12583 && GET_MODE_CLASS (mode
) == MODE_INT
)
12584 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
12585 INTVAL (XEXP (rtl
, 1)),
12586 VAR_INIT_STATUS_INITIALIZED
);
12589 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12590 VAR_INIT_STATUS_INITIALIZED
);
12591 if (mem_loc_result
== 0)
12594 if (CONST_INT_P (XEXP (rtl
, 1))
12595 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
12596 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
12599 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12600 VAR_INIT_STATUS_INITIALIZED
);
12603 add_loc_descr (&mem_loc_result
, op1
);
12604 add_loc_descr (&mem_loc_result
,
12605 new_loc_descr (DW_OP_plus
, 0, 0));
12610 /* If a pseudo-reg is optimized away, it is possible for it to
12611 be replaced with a MEM containing a multiply or shift. */
12622 && GET_MODE_CLASS (mode
) == MODE_INT
12623 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
12625 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12626 base_type_for_mode (mode
, 0),
12650 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12652 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12653 VAR_INIT_STATUS_INITIALIZED
);
12655 rtx rtlop1
= XEXP (rtl
, 1);
12656 if (GET_MODE (rtlop1
) != VOIDmode
12657 && GET_MODE_BITSIZE (GET_MODE (rtlop1
))
12658 < GET_MODE_BITSIZE (mode
))
12659 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12660 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12661 VAR_INIT_STATUS_INITIALIZED
);
12664 if (op0
== 0 || op1
== 0)
12667 mem_loc_result
= op0
;
12668 add_loc_descr (&mem_loc_result
, op1
);
12669 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12685 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12686 VAR_INIT_STATUS_INITIALIZED
);
12687 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12688 VAR_INIT_STATUS_INITIALIZED
);
12690 if (op0
== 0 || op1
== 0)
12693 mem_loc_result
= op0
;
12694 add_loc_descr (&mem_loc_result
, op1
);
12695 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12699 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
&& !dwarf_strict
)
12701 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
12702 base_type_for_mode (mode
, 0),
12707 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12708 VAR_INIT_STATUS_INITIALIZED
);
12709 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12710 VAR_INIT_STATUS_INITIALIZED
);
12712 if (op0
== 0 || op1
== 0)
12715 mem_loc_result
= op0
;
12716 add_loc_descr (&mem_loc_result
, op1
);
12717 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12718 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12719 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
12720 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
12721 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
12725 if (!dwarf_strict
&& GET_MODE_CLASS (mode
) == MODE_INT
)
12727 if (GET_MODE_CLASS (mode
) > DWARF2_ADDR_SIZE
)
12732 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12733 base_type_for_mode (mode
, 1),
12751 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12752 VAR_INIT_STATUS_INITIALIZED
);
12757 mem_loc_result
= op0
;
12758 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12762 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12763 #ifdef POINTERS_EXTEND_UNSIGNED
12765 && mem_mode
!= VOIDmode
12766 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
12770 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12774 && (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
12775 || GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_DOUBLE_INT
))
12777 dw_die_ref type_die
= base_type_for_mode (mode
, 1);
12778 enum machine_mode amode
;
12779 if (type_die
== NULL
)
12781 amode
= mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
,
12783 if (INTVAL (rtl
) >= 0
12784 && amode
!= BLKmode
12785 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
12786 /* const DW_OP_GNU_convert <XXX> vs.
12787 DW_OP_GNU_const_type <XXX, 1, const>. */
12788 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
12789 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode
))
12791 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12792 op0
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12793 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12794 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12795 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12796 add_loc_descr (&mem_loc_result
, op0
);
12797 return mem_loc_result
;
12799 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0,
12801 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12802 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12803 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12804 if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12805 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
12808 mem_loc_result
->dw_loc_oprnd2
.val_class
12809 = dw_val_class_const_double
;
12810 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12811 = double_int::from_shwi (INTVAL (rtl
));
12819 dw_die_ref type_die
;
12821 /* Note that a CONST_DOUBLE rtx could represent either an integer
12822 or a floating-point constant. A CONST_DOUBLE is used whenever
12823 the constant requires more than one word in order to be
12824 adequately represented. We output CONST_DOUBLEs as blocks. */
12825 if (mode
== VOIDmode
12826 || (GET_MODE (rtl
) == VOIDmode
12827 && GET_MODE_BITSIZE (mode
) != HOST_BITS_PER_DOUBLE_INT
))
12829 type_die
= base_type_for_mode (mode
,
12830 GET_MODE_CLASS (mode
) == MODE_INT
);
12831 if (type_die
== NULL
)
12833 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
12834 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12835 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12836 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12837 if (SCALAR_FLOAT_MODE_P (mode
))
12839 unsigned int length
= GET_MODE_SIZE (mode
);
12840 unsigned char *array
12841 = (unsigned char*) ggc_alloc_atomic (length
);
12843 insert_float (rtl
, array
);
12844 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
12845 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
12846 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
12847 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
12851 mem_loc_result
->dw_loc_oprnd2
.val_class
12852 = dw_val_class_const_double
;
12853 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12854 = rtx_to_double_int (rtl
);
12860 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
12864 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
12868 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
12872 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
12876 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
12880 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
12884 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
12888 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
12892 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
12896 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
12901 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12906 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
12911 if (CONST_INT_P (XEXP (rtl
, 1))
12912 && CONST_INT_P (XEXP (rtl
, 2))
12913 && ((unsigned) INTVAL (XEXP (rtl
, 1))
12914 + (unsigned) INTVAL (XEXP (rtl
, 2))
12915 <= GET_MODE_BITSIZE (mode
))
12916 && GET_MODE_CLASS (mode
) == MODE_INT
12917 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12918 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
12921 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12922 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12925 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
12929 mem_loc_result
= op0
;
12930 size
= INTVAL (XEXP (rtl
, 1));
12931 shift
= INTVAL (XEXP (rtl
, 2));
12932 if (BITS_BIG_ENDIAN
)
12933 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
12935 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
12937 add_loc_descr (&mem_loc_result
,
12938 int_loc_descriptor (DWARF2_ADDR_SIZE
12940 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
12942 if (size
!= (int) DWARF2_ADDR_SIZE
)
12944 add_loc_descr (&mem_loc_result
,
12945 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
12946 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12953 dw_loc_descr_ref op2
, bra_node
, drop_node
;
12954 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
12955 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
12956 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
12957 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12958 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12959 VAR_INIT_STATUS_INITIALIZED
);
12960 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
12961 VAR_INIT_STATUS_INITIALIZED
);
12962 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
12965 mem_loc_result
= op1
;
12966 add_loc_descr (&mem_loc_result
, op2
);
12967 add_loc_descr (&mem_loc_result
, op0
);
12968 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
12969 add_loc_descr (&mem_loc_result
, bra_node
);
12970 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
12971 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
12972 add_loc_descr (&mem_loc_result
, drop_node
);
12973 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12974 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
12979 case FLOAT_TRUNCATE
:
12981 case UNSIGNED_FLOAT
:
12986 dw_die_ref type_die
;
12987 dw_loc_descr_ref cvt
;
12989 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12990 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12993 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl
, 0))) == MODE_INT
12994 && (GET_CODE (rtl
) == FLOAT
12995 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)))
12996 <= DWARF2_ADDR_SIZE
))
12998 type_die
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
12999 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
13000 if (type_die
== NULL
)
13002 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13003 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13004 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13005 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13006 add_loc_descr (&op0
, cvt
);
13008 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
13009 if (type_die
== NULL
)
13011 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
13012 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13013 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13014 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13015 add_loc_descr (&op0
, cvt
);
13016 if (GET_MODE_CLASS (mode
) == MODE_INT
13017 && (GET_CODE (rtl
) == FIX
13018 || GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
))
13020 op0
= convert_descriptor_to_mode (mode
, op0
);
13024 mem_loc_result
= op0
;
13031 mem_loc_result
= clz_loc_descriptor (rtl
, mode
, mem_mode
);
13036 mem_loc_result
= popcount_loc_descriptor (rtl
, mode
, mem_mode
);
13040 mem_loc_result
= bswap_loc_descriptor (rtl
, mode
, mem_mode
);
13045 mem_loc_result
= rotate_loc_descriptor (rtl
, mode
, mem_mode
);
13049 /* In theory, we could implement the above. */
13050 /* DWARF cannot represent the unsigned compare operations
13075 case FRACT_CONVERT
:
13076 case UNSIGNED_FRACT_CONVERT
:
13078 case UNSIGNED_SAT_FRACT
:
13084 case VEC_DUPLICATE
:
13088 case STRICT_LOW_PART
:
13093 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13094 can't express it in the debug info. This can happen e.g. with some
13099 resolve_one_addr (&rtl
, NULL
);
13103 #ifdef ENABLE_CHECKING
13104 print_rtl (stderr
, rtl
);
13105 gcc_unreachable ();
13111 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13112 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13114 return mem_loc_result
;
13117 /* Return a descriptor that describes the concatenation of two locations.
13118 This is typically a complex variable. */
13120 static dw_loc_descr_ref
13121 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
13123 dw_loc_descr_ref cc_loc_result
= NULL
;
13124 dw_loc_descr_ref x0_ref
13125 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13126 dw_loc_descr_ref x1_ref
13127 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13129 if (x0_ref
== 0 || x1_ref
== 0)
13132 cc_loc_result
= x0_ref
;
13133 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
13135 add_loc_descr (&cc_loc_result
, x1_ref
);
13136 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
13138 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13139 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13141 return cc_loc_result
;
13144 /* Return a descriptor that describes the concatenation of N
13147 static dw_loc_descr_ref
13148 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
13151 dw_loc_descr_ref cc_loc_result
= NULL
;
13152 unsigned int n
= XVECLEN (concatn
, 0);
13154 for (i
= 0; i
< n
; ++i
)
13156 dw_loc_descr_ref ref
;
13157 rtx x
= XVECEXP (concatn
, 0, i
);
13159 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
13163 add_loc_descr (&cc_loc_result
, ref
);
13164 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
13167 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13168 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13170 return cc_loc_result
;
13173 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
13174 for DEBUG_IMPLICIT_PTR RTL. */
13176 static dw_loc_descr_ref
13177 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
13179 dw_loc_descr_ref ret
;
13184 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
13185 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
13186 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
13187 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
13188 ret
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
13189 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13192 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13193 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
13194 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13198 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
13199 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
13204 /* Output a proper Dwarf location descriptor for a variable or parameter
13205 which is either allocated in a register or in a memory location. For a
13206 register, we just generate an OP_REG and the register number. For a
13207 memory location we provide a Dwarf postfix expression describing how to
13208 generate the (dynamic) address of the object onto the address stack.
13210 MODE is mode of the decl if this loc_descriptor is going to be used in
13211 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13212 allowed, VOIDmode otherwise.
13214 If we don't know how to describe it, return 0. */
13216 static dw_loc_descr_ref
13217 loc_descriptor (rtx rtl
, enum machine_mode mode
,
13218 enum var_init_status initialized
)
13220 dw_loc_descr_ref loc_result
= NULL
;
13222 switch (GET_CODE (rtl
))
13225 /* The case of a subreg may arise when we have a local (register)
13226 variable or a formal (register) parameter which doesn't quite fill
13227 up an entire register. For now, just assume that it is
13228 legitimate to make the Dwarf info refer to the whole register which
13229 contains the given subreg. */
13230 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
13231 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
13232 GET_MODE (SUBREG_REG (rtl
)), initialized
);
13238 loc_result
= reg_loc_descriptor (rtl
, initialized
);
13242 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
13243 GET_MODE (rtl
), initialized
);
13244 if (loc_result
== NULL
)
13245 loc_result
= tls_mem_loc_descriptor (rtl
);
13246 if (loc_result
== NULL
)
13248 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
13249 if (new_rtl
!= rtl
)
13250 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
13255 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
13260 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
13265 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
13267 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
13268 if (GET_CODE (loc
) == EXPR_LIST
)
13269 loc
= XEXP (loc
, 0);
13270 loc_result
= loc_descriptor (loc
, mode
, initialized
);
13274 rtl
= XEXP (rtl
, 1);
13279 rtvec par_elems
= XVEC (rtl
, 0);
13280 int num_elem
= GET_NUM_ELEM (par_elems
);
13281 enum machine_mode mode
;
13284 /* Create the first one, so we have something to add to. */
13285 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
13286 VOIDmode
, initialized
);
13287 if (loc_result
== NULL
)
13289 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
13290 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13291 for (i
= 1; i
< num_elem
; i
++)
13293 dw_loc_descr_ref temp
;
13295 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
13296 VOIDmode
, initialized
);
13299 add_loc_descr (&loc_result
, temp
);
13300 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
13301 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
13307 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
13308 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
13313 if (mode
== VOIDmode
)
13314 mode
= GET_MODE (rtl
);
13316 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13318 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13320 /* Note that a CONST_DOUBLE rtx could represent either an integer
13321 or a floating-point constant. A CONST_DOUBLE is used whenever
13322 the constant requires more than one word in order to be
13323 adequately represented. We output CONST_DOUBLEs as blocks. */
13324 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13325 GET_MODE_SIZE (mode
), 0);
13326 if (SCALAR_FLOAT_MODE_P (mode
))
13328 unsigned int length
= GET_MODE_SIZE (mode
);
13329 unsigned char *array
13330 = (unsigned char*) ggc_alloc_atomic (length
);
13332 insert_float (rtl
, array
);
13333 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13334 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
13335 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
13336 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13340 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
13341 loc_result
->dw_loc_oprnd2
.v
.val_double
13342 = rtx_to_double_int (rtl
);
13348 if (mode
== VOIDmode
)
13349 mode
= GET_MODE (rtl
);
13351 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
13353 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
13354 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
13355 unsigned char *array
= (unsigned char *)
13356 ggc_alloc_atomic (length
* elt_size
);
13360 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
13361 switch (GET_MODE_CLASS (mode
))
13363 case MODE_VECTOR_INT
:
13364 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13366 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13367 double_int val
= rtx_to_double_int (elt
);
13369 if (elt_size
<= sizeof (HOST_WIDE_INT
))
13370 insert_int (val
.to_shwi (), elt_size
, p
);
13373 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
13374 insert_double (val
, p
);
13379 case MODE_VECTOR_FLOAT
:
13380 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
13382 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
13383 insert_float (elt
, p
);
13388 gcc_unreachable ();
13391 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13392 length
* elt_size
, 0);
13393 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
13394 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
13395 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
13396 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
13401 if (mode
== VOIDmode
13402 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
13403 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
13404 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
13406 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
13411 if (!const_ok_for_output (rtl
))
13414 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
13415 && (dwarf_version
>= 4 || !dwarf_strict
))
13417 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
13418 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13419 vec_safe_push (used_rtx_array
, rtl
);
13423 case DEBUG_IMPLICIT_PTR
:
13424 loc_result
= implicit_ptr_descriptor (rtl
, 0);
13428 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
13429 && CONST_INT_P (XEXP (rtl
, 1)))
13432 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
13438 if ((GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE (rtl
) == mode
13439 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
13440 && dwarf_version
>= 4)
13441 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
13443 /* Value expression. */
13444 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
13446 add_loc_descr (&loc_result
,
13447 new_loc_descr (DW_OP_stack_value
, 0, 0));
13455 /* We need to figure out what section we should use as the base for the
13456 address ranges where a given location is valid.
13457 1. If this particular DECL has a section associated with it, use that.
13458 2. If this function has a section associated with it, use that.
13459 3. Otherwise, use the text section.
13460 XXX: If you split a variable across multiple sections, we won't notice. */
13462 static const char *
13463 secname_for_decl (const_tree decl
)
13465 const char *secname
;
13467 if (VAR_OR_FUNCTION_DECL_P (decl
) && DECL_SECTION_NAME (decl
))
13469 tree sectree
= DECL_SECTION_NAME (decl
);
13470 secname
= TREE_STRING_POINTER (sectree
);
13472 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
13474 tree sectree
= DECL_SECTION_NAME (current_function_decl
);
13475 secname
= TREE_STRING_POINTER (sectree
);
13477 else if (cfun
&& in_cold_section_p
)
13478 secname
= crtl
->subsections
.cold_section_label
;
13480 secname
= text_section_label
;
13485 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13488 decl_by_reference_p (tree decl
)
13490 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
13491 || TREE_CODE (decl
) == VAR_DECL
)
13492 && DECL_BY_REFERENCE (decl
));
13495 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13498 static dw_loc_descr_ref
13499 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
13500 enum var_init_status initialized
)
13502 int have_address
= 0;
13503 dw_loc_descr_ref descr
;
13504 enum machine_mode mode
;
13506 if (want_address
!= 2)
13508 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
13510 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13512 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13513 if (GET_CODE (varloc
) == EXPR_LIST
)
13514 varloc
= XEXP (varloc
, 0);
13515 mode
= GET_MODE (varloc
);
13516 if (MEM_P (varloc
))
13518 rtx addr
= XEXP (varloc
, 0);
13519 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
13520 mode
, initialized
);
13525 rtx x
= avoid_constant_pool_reference (varloc
);
13527 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
13532 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
13539 if (GET_CODE (varloc
) == VAR_LOCATION
)
13540 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
13542 mode
= DECL_MODE (loc
);
13543 descr
= loc_descriptor (varloc
, mode
, initialized
);
13550 if (want_address
== 2 && !have_address
13551 && (dwarf_version
>= 4 || !dwarf_strict
))
13553 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
13555 expansion_failed (loc
, NULL_RTX
,
13556 "DWARF address size mismatch");
13559 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13562 /* Show if we can't fill the request for an address. */
13563 if (want_address
&& !have_address
)
13565 expansion_failed (loc
, NULL_RTX
,
13566 "Want address and only have value");
13570 /* If we've got an address and don't want one, dereference. */
13571 if (!want_address
&& have_address
)
13573 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
13574 enum dwarf_location_atom op
;
13576 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
13578 expansion_failed (loc
, NULL_RTX
,
13579 "DWARF address size mismatch");
13582 else if (size
== DWARF2_ADDR_SIZE
)
13585 op
= DW_OP_deref_size
;
13587 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
13593 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
13594 if it is not possible. */
13596 static dw_loc_descr_ref
13597 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
13599 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
13600 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
13601 else if (dwarf_version
>= 3 || !dwarf_strict
)
13602 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
13607 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13608 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
13610 static dw_loc_descr_ref
13611 dw_sra_loc_expr (tree decl
, rtx loc
)
13614 unsigned int padsize
= 0;
13615 dw_loc_descr_ref descr
, *descr_tail
;
13616 unsigned HOST_WIDE_INT decl_size
;
13618 enum var_init_status initialized
;
13620 if (DECL_SIZE (decl
) == NULL
13621 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
13624 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
13626 descr_tail
= &descr
;
13628 for (p
= loc
; p
; p
= XEXP (p
, 1))
13630 unsigned int bitsize
= decl_piece_bitsize (p
);
13631 rtx loc_note
= *decl_piece_varloc_ptr (p
);
13632 dw_loc_descr_ref cur_descr
;
13633 dw_loc_descr_ref
*tail
, last
= NULL
;
13634 unsigned int opsize
= 0;
13636 if (loc_note
== NULL_RTX
13637 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
13639 padsize
+= bitsize
;
13642 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
13643 varloc
= NOTE_VAR_LOCATION (loc_note
);
13644 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
13645 if (cur_descr
== NULL
)
13647 padsize
+= bitsize
;
13651 /* Check that cur_descr either doesn't use
13652 DW_OP_*piece operations, or their sum is equal
13653 to bitsize. Otherwise we can't embed it. */
13654 for (tail
= &cur_descr
; *tail
!= NULL
;
13655 tail
= &(*tail
)->dw_loc_next
)
13656 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
13658 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
13662 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
13664 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
13668 if (last
!= NULL
&& opsize
!= bitsize
)
13670 padsize
+= bitsize
;
13671 /* Discard the current piece of the descriptor and release any
13672 addr_table entries it uses. */
13673 remove_loc_list_addr_table_entries (cur_descr
);
13677 /* If there is a hole, add DW_OP_*piece after empty DWARF
13678 expression, which means that those bits are optimized out. */
13681 if (padsize
> decl_size
)
13683 remove_loc_list_addr_table_entries (cur_descr
);
13684 goto discard_descr
;
13686 decl_size
-= padsize
;
13687 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
13688 if (*descr_tail
== NULL
)
13690 remove_loc_list_addr_table_entries (cur_descr
);
13691 goto discard_descr
;
13693 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13696 *descr_tail
= cur_descr
;
13698 if (bitsize
> decl_size
)
13699 goto discard_descr
;
13700 decl_size
-= bitsize
;
13703 HOST_WIDE_INT offset
= 0;
13704 if (GET_CODE (varloc
) == VAR_LOCATION
13705 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13707 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13708 if (GET_CODE (varloc
) == EXPR_LIST
)
13709 varloc
= XEXP (varloc
, 0);
13713 if (GET_CODE (varloc
) == CONST
13714 || GET_CODE (varloc
) == SIGN_EXTEND
13715 || GET_CODE (varloc
) == ZERO_EXTEND
)
13716 varloc
= XEXP (varloc
, 0);
13717 else if (GET_CODE (varloc
) == SUBREG
)
13718 varloc
= SUBREG_REG (varloc
);
13723 /* DW_OP_bit_size offset should be zero for register
13724 or implicit location descriptions and empty location
13725 descriptions, but for memory addresses needs big endian
13727 if (MEM_P (varloc
))
13729 unsigned HOST_WIDE_INT memsize
13730 = MEM_SIZE (varloc
) * BITS_PER_UNIT
;
13731 if (memsize
!= bitsize
)
13733 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
13734 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
13735 goto discard_descr
;
13736 if (memsize
< bitsize
)
13737 goto discard_descr
;
13738 if (BITS_BIG_ENDIAN
)
13739 offset
= memsize
- bitsize
;
13743 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
13744 if (*descr_tail
== NULL
)
13745 goto discard_descr
;
13746 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13750 /* If there were any non-empty expressions, add padding till the end of
13752 if (descr
!= NULL
&& decl_size
!= 0)
13754 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
13755 if (*descr_tail
== NULL
)
13756 goto discard_descr
;
13761 /* Discard the descriptor and release any addr_table entries it uses. */
13762 remove_loc_list_addr_table_entries (descr
);
13766 /* Return the dwarf representation of the location list LOC_LIST of
13767 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
13770 static dw_loc_list_ref
13771 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
13773 const char *endname
, *secname
;
13775 enum var_init_status initialized
;
13776 struct var_loc_node
*node
;
13777 dw_loc_descr_ref descr
;
13778 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
13779 dw_loc_list_ref list
= NULL
;
13780 dw_loc_list_ref
*listp
= &list
;
13782 /* Now that we know what section we are using for a base,
13783 actually construct the list of locations.
13784 The first location information is what is passed to the
13785 function that creates the location list, and the remaining
13786 locations just get added on to that list.
13787 Note that we only know the start address for a location
13788 (IE location changes), so to build the range, we use
13789 the range [current location start, next location start].
13790 This means we have to special case the last node, and generate
13791 a range of [last location start, end of function label]. */
13793 secname
= secname_for_decl (decl
);
13795 for (node
= loc_list
->first
; node
; node
= node
->next
)
13796 if (GET_CODE (node
->loc
) == EXPR_LIST
13797 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
13799 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13801 /* This requires DW_OP_{,bit_}piece, which is not usable
13802 inside DWARF expressions. */
13803 if (want_address
!= 2)
13805 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13811 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13812 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13813 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
13817 bool range_across_switch
= false;
13818 /* If section switch happens in between node->label
13819 and node->next->label (or end of function) and
13820 we can't emit it as a single entry list,
13821 emit two ranges, first one ending at the end
13822 of first partition and second one starting at the
13823 beginning of second partition. */
13824 if (node
== loc_list
->last_before_switch
13825 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
13826 && current_function_decl
)
13828 endname
= cfun
->fde
->dw_fde_end
;
13829 range_across_switch
= true;
13831 /* The variable has a location between NODE->LABEL and
13832 NODE->NEXT->LABEL. */
13833 else if (node
->next
)
13834 endname
= node
->next
->label
;
13835 /* If the variable has a location at the last label
13836 it keeps its location until the end of function. */
13837 else if (!current_function_decl
)
13838 endname
= text_end_label
;
13841 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
13842 current_function_funcdef_no
);
13843 endname
= ggc_strdup (label_id
);
13846 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
13847 if (TREE_CODE (decl
) == PARM_DECL
13848 && node
== loc_list
->first
13849 && NOTE_P (node
->loc
)
13850 && strcmp (node
->label
, endname
) == 0)
13851 (*listp
)->force
= true;
13852 listp
= &(*listp
)->dw_loc_next
;
13854 if (range_across_switch
)
13856 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13857 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13860 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13861 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13862 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
13865 gcc_assert (descr
);
13866 /* The variable has a location between NODE->LABEL and
13867 NODE->NEXT->LABEL. */
13869 endname
= node
->next
->label
;
13871 endname
= cfun
->fde
->dw_fde_second_end
;
13872 *listp
= new_loc_list (descr
,
13873 cfun
->fde
->dw_fde_second_begin
,
13875 listp
= &(*listp
)->dw_loc_next
;
13880 /* Try to avoid the overhead of a location list emitting a location
13881 expression instead, but only if we didn't have more than one
13882 location entry in the first place. If some entries were not
13883 representable, we don't want to pretend a single entry that was
13884 applies to the entire scope in which the variable is
13886 if (list
&& loc_list
->first
->next
)
13892 /* Return if the loc_list has only single element and thus can be represented
13893 as location description. */
13896 single_element_loc_list_p (dw_loc_list_ref list
)
13898 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
13899 return !list
->ll_symbol
;
13902 /* To each location in list LIST add loc descr REF. */
13905 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
13907 dw_loc_descr_ref copy
;
13908 add_loc_descr (&list
->expr
, ref
);
13909 list
= list
->dw_loc_next
;
13912 copy
= ggc_alloc_dw_loc_descr_node ();
13913 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
13914 add_loc_descr (&list
->expr
, copy
);
13915 while (copy
->dw_loc_next
)
13917 dw_loc_descr_ref new_copy
= ggc_alloc_dw_loc_descr_node ();
13918 memcpy (new_copy
, copy
->dw_loc_next
, sizeof (dw_loc_descr_node
));
13919 copy
->dw_loc_next
= new_copy
;
13922 list
= list
->dw_loc_next
;
13926 /* Given two lists RET and LIST
13927 produce location list that is result of adding expression in LIST
13928 to expression in RET on each position in program.
13929 Might be destructive on both RET and LIST.
13931 TODO: We handle only simple cases of RET or LIST having at most one
13932 element. General case would inolve sorting the lists in program order
13933 and merging them that will need some additional work.
13934 Adding that will improve quality of debug info especially for SRA-ed
13938 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
13947 if (!list
->dw_loc_next
)
13949 add_loc_descr_to_each (*ret
, list
->expr
);
13952 if (!(*ret
)->dw_loc_next
)
13954 add_loc_descr_to_each (list
, (*ret
)->expr
);
13958 expansion_failed (NULL_TREE
, NULL_RTX
,
13959 "Don't know how to merge two non-trivial"
13960 " location lists.\n");
13965 /* LOC is constant expression. Try a luck, look it up in constant
13966 pool and return its loc_descr of its address. */
13968 static dw_loc_descr_ref
13969 cst_pool_loc_descr (tree loc
)
13971 /* Get an RTL for this, if something has been emitted. */
13972 rtx rtl
= lookup_constant_def (loc
);
13974 if (!rtl
|| !MEM_P (rtl
))
13979 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
13981 /* TODO: We might get more coverage if we was actually delaying expansion
13982 of all expressions till end of compilation when constant pools are fully
13984 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
13986 expansion_failed (loc
, NULL_RTX
,
13987 "CST value in contant pool but not marked.");
13990 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
13991 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
13994 /* Return dw_loc_list representing address of addr_expr LOC
13995 by looking for inner INDIRECT_REF expression and turning
13996 it into simple arithmetics. */
13998 static dw_loc_list_ref
13999 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
)
14002 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14003 enum machine_mode mode
;
14004 int unsignedp
, volatilep
= 0;
14005 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14007 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
14008 &bitsize
, &bitpos
, &offset
, &mode
,
14009 &unsignedp
, &volatilep
, false);
14011 if (bitpos
% BITS_PER_UNIT
)
14013 expansion_failed (loc
, NULL_RTX
, "bitfield access");
14016 if (!INDIRECT_REF_P (obj
))
14018 expansion_failed (obj
,
14019 NULL_RTX
, "no indirect ref in inner refrence");
14022 if (!offset
&& !bitpos
)
14023 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1);
14025 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
14026 && (dwarf_version
>= 4 || !dwarf_strict
))
14028 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0);
14033 /* Variable offset. */
14034 list_ret1
= loc_list_from_tree (offset
, 0);
14035 if (list_ret1
== 0)
14037 add_loc_list (&list_ret
, list_ret1
);
14040 add_loc_descr_to_each (list_ret
,
14041 new_loc_descr (DW_OP_plus
, 0, 0));
14043 bytepos
= bitpos
/ BITS_PER_UNIT
;
14045 add_loc_descr_to_each (list_ret
,
14046 new_loc_descr (DW_OP_plus_uconst
,
14048 else if (bytepos
< 0)
14049 loc_list_plus_const (list_ret
, bytepos
);
14050 add_loc_descr_to_each (list_ret
,
14051 new_loc_descr (DW_OP_stack_value
, 0, 0));
14057 /* Generate Dwarf location list representing LOC.
14058 If WANT_ADDRESS is false, expression computing LOC will be computed
14059 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14060 if WANT_ADDRESS is 2, expression computing address useable in location
14061 will be returned (i.e. DW_OP_reg can be used
14062 to refer to register values). */
14064 static dw_loc_list_ref
14065 loc_list_from_tree (tree loc
, int want_address
)
14067 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
14068 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14069 int have_address
= 0;
14070 enum dwarf_location_atom op
;
14072 /* ??? Most of the time we do not take proper care for sign/zero
14073 extending the values properly. Hopefully this won't be a real
14076 switch (TREE_CODE (loc
))
14079 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
14082 case PLACEHOLDER_EXPR
:
14083 /* This case involves extracting fields from an object to determine the
14084 position of other fields. We don't try to encode this here. The
14085 only user of this is Ada, which encodes the needed information using
14086 the names of types. */
14087 expansion_failed (loc
, NULL_RTX
, "PLACEHOLDER_EXPR");
14091 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
14092 /* There are no opcodes for these operations. */
14095 case PREINCREMENT_EXPR
:
14096 case PREDECREMENT_EXPR
:
14097 case POSTINCREMENT_EXPR
:
14098 case POSTDECREMENT_EXPR
:
14099 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
14100 /* There are no opcodes for these operations. */
14104 /* If we already want an address, see if there is INDIRECT_REF inside
14105 e.g. for &this->field. */
14108 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
14109 (loc
, want_address
== 2);
14112 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
14113 && (ret
= cst_pool_loc_descr (loc
)))
14116 /* Otherwise, process the argument and look for the address. */
14117 if (!list_ret
&& !ret
)
14118 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 1);
14122 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
14128 if (DECL_THREAD_LOCAL_P (loc
))
14131 enum dwarf_location_atom tls_op
;
14132 enum dtprel_bool dtprel
= dtprel_false
;
14134 if (targetm
.have_tls
)
14136 /* If this is not defined, we have no way to emit the
14138 if (!targetm
.asm_out
.output_dwarf_dtprel
)
14141 /* The way DW_OP_GNU_push_tls_address is specified, we
14142 can only look up addresses of objects in the current
14143 module. We used DW_OP_addr as first op, but that's
14144 wrong, because DW_OP_addr is relocated by the debug
14145 info consumer, while DW_OP_GNU_push_tls_address
14146 operand shouldn't be. */
14147 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
14149 dtprel
= dtprel_true
;
14150 tls_op
= DW_OP_GNU_push_tls_address
;
14154 if (!targetm
.emutls
.debug_form_tls_address
14155 || !(dwarf_version
>= 3 || !dwarf_strict
))
14157 /* We stuffed the control variable into the DECL_VALUE_EXPR
14158 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
14159 no longer appear in gimple code. We used the control
14160 variable in specific so that we could pick it up here. */
14161 loc
= DECL_VALUE_EXPR (loc
);
14162 tls_op
= DW_OP_form_tls_address
;
14165 rtl
= rtl_for_decl_location (loc
);
14166 if (rtl
== NULL_RTX
)
14171 rtl
= XEXP (rtl
, 0);
14172 if (! CONSTANT_P (rtl
))
14175 ret
= new_addr_loc_descr (rtl
, dtprel
);
14176 ret1
= new_loc_descr (tls_op
, 0, 0);
14177 add_loc_descr (&ret
, ret1
);
14186 if (DECL_HAS_VALUE_EXPR_P (loc
))
14187 return loc_list_from_tree (DECL_VALUE_EXPR (loc
),
14191 case FUNCTION_DECL
:
14194 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
14196 if (loc_list
&& loc_list
->first
)
14198 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
14199 have_address
= want_address
!= 0;
14202 rtl
= rtl_for_decl_location (loc
);
14203 if (rtl
== NULL_RTX
)
14205 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
14208 else if (CONST_INT_P (rtl
))
14210 HOST_WIDE_INT val
= INTVAL (rtl
);
14211 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14212 val
&= GET_MODE_MASK (DECL_MODE (loc
));
14213 ret
= int_loc_descriptor (val
);
14215 else if (GET_CODE (rtl
) == CONST_STRING
)
14217 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
14220 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
14221 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
14224 enum machine_mode mode
, mem_mode
;
14226 /* Certain constructs can only be represented at top-level. */
14227 if (want_address
== 2)
14229 ret
= loc_descriptor (rtl
, VOIDmode
,
14230 VAR_INIT_STATUS_INITIALIZED
);
14235 mode
= GET_MODE (rtl
);
14236 mem_mode
= VOIDmode
;
14240 mode
= get_address_mode (rtl
);
14241 rtl
= XEXP (rtl
, 0);
14244 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
14245 VAR_INIT_STATUS_INITIALIZED
);
14248 expansion_failed (loc
, rtl
,
14249 "failed to produce loc descriptor for rtl");
14256 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
14260 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14264 case COMPOUND_EXPR
:
14265 return loc_list_from_tree (TREE_OPERAND (loc
, 1), want_address
);
14268 case VIEW_CONVERT_EXPR
:
14271 return loc_list_from_tree (TREE_OPERAND (loc
, 0), want_address
);
14273 case COMPONENT_REF
:
14274 case BIT_FIELD_REF
:
14276 case ARRAY_RANGE_REF
:
14277 case REALPART_EXPR
:
14278 case IMAGPART_EXPR
:
14281 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14282 enum machine_mode mode
;
14283 int unsignedp
, volatilep
= 0;
14285 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
14286 &unsignedp
, &volatilep
, false);
14288 gcc_assert (obj
!= loc
);
14290 list_ret
= loc_list_from_tree (obj
,
14292 && !bitpos
&& !offset
? 2 : 1);
14293 /* TODO: We can extract value of the small expression via shifting even
14294 for nonzero bitpos. */
14297 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
14299 expansion_failed (loc
, NULL_RTX
,
14300 "bitfield access");
14304 if (offset
!= NULL_TREE
)
14306 /* Variable offset. */
14307 list_ret1
= loc_list_from_tree (offset
, 0);
14308 if (list_ret1
== 0)
14310 add_loc_list (&list_ret
, list_ret1
);
14313 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
14316 bytepos
= bitpos
/ BITS_PER_UNIT
;
14318 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
14319 else if (bytepos
< 0)
14320 loc_list_plus_const (list_ret
, bytepos
);
14327 if ((want_address
|| !tree_fits_shwi_p (loc
))
14328 && (ret
= cst_pool_loc_descr (loc
)))
14330 else if (want_address
== 2
14331 && tree_fits_shwi_p (loc
)
14332 && (ret
= address_of_int_loc_descriptor
14333 (int_size_in_bytes (TREE_TYPE (loc
)),
14334 tree_to_shwi (loc
))))
14336 else if (tree_fits_shwi_p (loc
))
14337 ret
= int_loc_descriptor (tree_to_shwi (loc
));
14340 expansion_failed (loc
, NULL_RTX
,
14341 "Integer operand is not host integer");
14350 if ((ret
= cst_pool_loc_descr (loc
)))
14353 /* We can construct small constants here using int_loc_descriptor. */
14354 expansion_failed (loc
, NULL_RTX
,
14355 "constructor or constant not in constant pool");
14358 case TRUTH_AND_EXPR
:
14359 case TRUTH_ANDIF_EXPR
:
14364 case TRUTH_XOR_EXPR
:
14369 case TRUTH_OR_EXPR
:
14370 case TRUTH_ORIF_EXPR
:
14375 case FLOOR_DIV_EXPR
:
14376 case CEIL_DIV_EXPR
:
14377 case ROUND_DIV_EXPR
:
14378 case TRUNC_DIV_EXPR
:
14379 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14388 case FLOOR_MOD_EXPR
:
14389 case CEIL_MOD_EXPR
:
14390 case ROUND_MOD_EXPR
:
14391 case TRUNC_MOD_EXPR
:
14392 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
14397 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14398 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14399 if (list_ret
== 0 || list_ret1
== 0)
14402 add_loc_list (&list_ret
, list_ret1
);
14405 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14406 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
14407 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
14408 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14409 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14421 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
14424 case POINTER_PLUS_EXPR
:
14426 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
14428 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14432 loc_list_plus_const (list_ret
, tree_to_shwi (TREE_OPERAND (loc
, 1)));
14440 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14447 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14454 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14461 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
14476 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14477 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
14478 if (list_ret
== 0 || list_ret1
== 0)
14481 add_loc_list (&list_ret
, list_ret1
);
14484 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14487 case TRUTH_NOT_EXPR
:
14501 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14505 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
14511 const enum tree_code code
=
14512 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
14514 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
14515 build2 (code
, integer_type_node
,
14516 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
14517 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
14520 /* ... fall through ... */
14524 dw_loc_descr_ref lhs
14525 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
14526 dw_loc_list_ref rhs
14527 = loc_list_from_tree (TREE_OPERAND (loc
, 2), 0);
14528 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
14530 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
14531 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
14534 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14535 add_loc_descr_to_each (list_ret
, bra_node
);
14537 add_loc_list (&list_ret
, rhs
);
14538 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14539 add_loc_descr_to_each (list_ret
, jump_node
);
14541 add_loc_descr_to_each (list_ret
, lhs
);
14542 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14543 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
14545 /* ??? Need a node to point the skip at. Use a nop. */
14546 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14547 add_loc_descr_to_each (list_ret
, tmp
);
14548 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14549 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14553 case FIX_TRUNC_EXPR
:
14557 /* Leave front-end specific codes as simply unknown. This comes
14558 up, for instance, with the C STMT_EXPR. */
14559 if ((unsigned int) TREE_CODE (loc
)
14560 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
14562 expansion_failed (loc
, NULL_RTX
,
14563 "language specific tree node");
14567 #ifdef ENABLE_CHECKING
14568 /* Otherwise this is a generic code; we should just lists all of
14569 these explicitly. We forgot one. */
14570 gcc_unreachable ();
14572 /* In a release build, we want to degrade gracefully: better to
14573 generate incomplete debugging information than to crash. */
14578 if (!ret
&& !list_ret
)
14581 if (want_address
== 2 && !have_address
14582 && (dwarf_version
>= 4 || !dwarf_strict
))
14584 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
14586 expansion_failed (loc
, NULL_RTX
,
14587 "DWARF address size mismatch");
14591 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14593 add_loc_descr_to_each (list_ret
,
14594 new_loc_descr (DW_OP_stack_value
, 0, 0));
14597 /* Show if we can't fill the request for an address. */
14598 if (want_address
&& !have_address
)
14600 expansion_failed (loc
, NULL_RTX
,
14601 "Want address and only have value");
14605 gcc_assert (!ret
|| !list_ret
);
14607 /* If we've got an address and don't want one, dereference. */
14608 if (!want_address
&& have_address
)
14610 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
14612 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
14614 expansion_failed (loc
, NULL_RTX
,
14615 "DWARF address size mismatch");
14618 else if (size
== DWARF2_ADDR_SIZE
)
14621 op
= DW_OP_deref_size
;
14624 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
14626 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
14629 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
14634 /* Same as above but return only single location expression. */
14635 static dw_loc_descr_ref
14636 loc_descriptor_from_tree (tree loc
, int want_address
)
14638 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
);
14641 if (ret
->dw_loc_next
)
14643 expansion_failed (loc
, NULL_RTX
,
14644 "Location list where only loc descriptor needed");
14650 /* Given a value, round it up to the lowest multiple of `boundary'
14651 which is not less than the value itself. */
14653 static inline HOST_WIDE_INT
14654 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
14656 return (((value
+ boundary
- 1) / boundary
) * boundary
);
14659 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
14660 pointer to the declared type for the relevant field variable, or return
14661 `integer_type_node' if the given node turns out to be an
14662 ERROR_MARK node. */
14665 field_type (const_tree decl
)
14669 if (TREE_CODE (decl
) == ERROR_MARK
)
14670 return integer_type_node
;
14672 type
= DECL_BIT_FIELD_TYPE (decl
);
14673 if (type
== NULL_TREE
)
14674 type
= TREE_TYPE (decl
);
14679 /* Given a pointer to a tree node, return the alignment in bits for
14680 it, or else return BITS_PER_WORD if the node actually turns out to
14681 be an ERROR_MARK node. */
14683 static inline unsigned
14684 simple_type_align_in_bits (const_tree type
)
14686 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
14689 static inline unsigned
14690 simple_decl_align_in_bits (const_tree decl
)
14692 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
14695 /* Return the result of rounding T up to ALIGN. */
14697 static inline double_int
14698 round_up_to_align (double_int t
, unsigned int align
)
14700 double_int alignd
= double_int::from_uhwi (align
);
14702 t
+= double_int_minus_one
;
14703 t
= t
.div (alignd
, true, TRUNC_DIV_EXPR
);
14708 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
14709 lowest addressed byte of the "containing object" for the given FIELD_DECL,
14710 or return 0 if we are unable to determine what that offset is, either
14711 because the argument turns out to be a pointer to an ERROR_MARK node, or
14712 because the offset is actually variable. (We can't handle the latter case
14715 static HOST_WIDE_INT
14716 field_byte_offset (const_tree decl
)
14718 double_int object_offset_in_bits
;
14719 double_int object_offset_in_bytes
;
14720 double_int bitpos_int
;
14722 if (TREE_CODE (decl
) == ERROR_MARK
)
14725 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
14727 /* We cannot yet cope with fields whose positions are variable, so
14728 for now, when we see such things, we simply return 0. Someday, we may
14729 be able to handle such cases, but it will be damn difficult. */
14730 if (TREE_CODE (bit_position (decl
)) != INTEGER_CST
)
14733 bitpos_int
= tree_to_double_int (bit_position (decl
));
14735 #ifdef PCC_BITFIELD_TYPE_MATTERS
14736 if (PCC_BITFIELD_TYPE_MATTERS
)
14739 tree field_size_tree
;
14740 double_int deepest_bitpos
;
14741 double_int field_size_in_bits
;
14742 unsigned int type_align_in_bits
;
14743 unsigned int decl_align_in_bits
;
14744 double_int type_size_in_bits
;
14746 type
= field_type (decl
);
14747 type_size_in_bits
= double_int_type_size_in_bits (type
);
14748 type_align_in_bits
= simple_type_align_in_bits (type
);
14750 field_size_tree
= DECL_SIZE (decl
);
14752 /* The size could be unspecified if there was an error, or for
14753 a flexible array member. */
14754 if (!field_size_tree
)
14755 field_size_tree
= bitsize_zero_node
;
14757 /* If the size of the field is not constant, use the type size. */
14758 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
14759 field_size_in_bits
= tree_to_double_int (field_size_tree
);
14761 field_size_in_bits
= type_size_in_bits
;
14763 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
14765 /* The GCC front-end doesn't make any attempt to keep track of the
14766 starting bit offset (relative to the start of the containing
14767 structure type) of the hypothetical "containing object" for a
14768 bit-field. Thus, when computing the byte offset value for the
14769 start of the "containing object" of a bit-field, we must deduce
14770 this information on our own. This can be rather tricky to do in
14771 some cases. For example, handling the following structure type
14772 definition when compiling for an i386/i486 target (which only
14773 aligns long long's to 32-bit boundaries) can be very tricky:
14775 struct S { int field1; long long field2:31; };
14777 Fortunately, there is a simple rule-of-thumb which can be used
14778 in such cases. When compiling for an i386/i486, GCC will
14779 allocate 8 bytes for the structure shown above. It decides to
14780 do this based upon one simple rule for bit-field allocation.
14781 GCC allocates each "containing object" for each bit-field at
14782 the first (i.e. lowest addressed) legitimate alignment boundary
14783 (based upon the required minimum alignment for the declared
14784 type of the field) which it can possibly use, subject to the
14785 condition that there is still enough available space remaining
14786 in the containing object (when allocated at the selected point)
14787 to fully accommodate all of the bits of the bit-field itself.
14789 This simple rule makes it obvious why GCC allocates 8 bytes for
14790 each object of the structure type shown above. When looking
14791 for a place to allocate the "containing object" for `field2',
14792 the compiler simply tries to allocate a 64-bit "containing
14793 object" at each successive 32-bit boundary (starting at zero)
14794 until it finds a place to allocate that 64- bit field such that
14795 at least 31 contiguous (and previously unallocated) bits remain
14796 within that selected 64 bit field. (As it turns out, for the
14797 example above, the compiler finds it is OK to allocate the
14798 "containing object" 64-bit field at bit-offset zero within the
14801 Here we attempt to work backwards from the limited set of facts
14802 we're given, and we try to deduce from those facts, where GCC
14803 must have believed that the containing object started (within
14804 the structure type). The value we deduce is then used (by the
14805 callers of this routine) to generate DW_AT_location and
14806 DW_AT_bit_offset attributes for fields (both bit-fields and, in
14807 the case of DW_AT_location, regular fields as well). */
14809 /* Figure out the bit-distance from the start of the structure to
14810 the "deepest" bit of the bit-field. */
14811 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
14813 /* This is the tricky part. Use some fancy footwork to deduce
14814 where the lowest addressed bit of the containing object must
14816 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14818 /* Round up to type_align by default. This works best for
14820 object_offset_in_bits
14821 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
14823 if (object_offset_in_bits
.ugt (bitpos_int
))
14825 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
14827 /* Round up to decl_align instead. */
14828 object_offset_in_bits
14829 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
14833 #endif /* PCC_BITFIELD_TYPE_MATTERS */
14834 object_offset_in_bits
= bitpos_int
;
14836 object_offset_in_bytes
14837 = object_offset_in_bits
.div (double_int::from_uhwi (BITS_PER_UNIT
),
14838 true, TRUNC_DIV_EXPR
);
14839 return object_offset_in_bytes
.to_shwi ();
14842 /* The following routines define various Dwarf attributes and any data
14843 associated with them. */
14845 /* Add a location description attribute value to a DIE.
14847 This emits location attributes suitable for whole variables and
14848 whole parameters. Note that the location attributes for struct fields are
14849 generated by the routine `data_member_location_attribute' below. */
14852 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
14853 dw_loc_list_ref descr
)
14857 if (single_element_loc_list_p (descr
))
14858 add_AT_loc (die
, attr_kind
, descr
->expr
);
14860 add_AT_loc_list (die
, attr_kind
, descr
);
14863 /* Add DW_AT_accessibility attribute to DIE if needed. */
14866 add_accessibility_attribute (dw_die_ref die
, tree decl
)
14868 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
14869 children, otherwise the default is DW_ACCESS_public. In DWARF2
14870 the default has always been DW_ACCESS_public. */
14871 if (TREE_PROTECTED (decl
))
14872 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
14873 else if (TREE_PRIVATE (decl
))
14875 if (dwarf_version
== 2
14876 || die
->die_parent
== NULL
14877 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
14878 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
14880 else if (dwarf_version
> 2
14882 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
14883 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
14886 /* Attach the specialized form of location attribute used for data members of
14887 struct and union types. In the special case of a FIELD_DECL node which
14888 represents a bit-field, the "offset" part of this special location
14889 descriptor must indicate the distance in bytes from the lowest-addressed
14890 byte of the containing struct or union type to the lowest-addressed byte of
14891 the "containing object" for the bit-field. (See the `field_byte_offset'
14894 For any given bit-field, the "containing object" is a hypothetical object
14895 (of some integral or enum type) within which the given bit-field lives. The
14896 type of this hypothetical "containing object" is always the same as the
14897 declared type of the individual bit-field itself (for GCC anyway... the
14898 DWARF spec doesn't actually mandate this). Note that it is the size (in
14899 bytes) of the hypothetical "containing object" which will be given in the
14900 DW_AT_byte_size attribute for this bit-field. (See the
14901 `byte_size_attribute' function below.) It is also used when calculating the
14902 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
14903 function below.) */
14906 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
14908 HOST_WIDE_INT offset
;
14909 dw_loc_descr_ref loc_descr
= 0;
14911 if (TREE_CODE (decl
) == TREE_BINFO
)
14913 /* We're working on the TAG_inheritance for a base class. */
14914 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
14916 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
14917 aren't at a fixed offset from all (sub)objects of the same
14918 type. We need to extract the appropriate offset from our
14919 vtable. The following dwarf expression means
14921 BaseAddr = ObAddr + *((*ObAddr) - Offset)
14923 This is specific to the V3 ABI, of course. */
14925 dw_loc_descr_ref tmp
;
14927 /* Make a copy of the object address. */
14928 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
14929 add_loc_descr (&loc_descr
, tmp
);
14931 /* Extract the vtable address. */
14932 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
14933 add_loc_descr (&loc_descr
, tmp
);
14935 /* Calculate the address of the offset. */
14936 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
14937 gcc_assert (offset
< 0);
14939 tmp
= int_loc_descriptor (-offset
);
14940 add_loc_descr (&loc_descr
, tmp
);
14941 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
14942 add_loc_descr (&loc_descr
, tmp
);
14944 /* Extract the offset. */
14945 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
14946 add_loc_descr (&loc_descr
, tmp
);
14948 /* Add it to the object address. */
14949 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
14950 add_loc_descr (&loc_descr
, tmp
);
14953 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
14956 offset
= field_byte_offset (decl
);
14960 if (dwarf_version
> 2)
14962 /* Don't need to output a location expression, just the constant. */
14964 add_AT_int (die
, DW_AT_data_member_location
, offset
);
14966 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
14971 enum dwarf_location_atom op
;
14973 /* The DWARF2 standard says that we should assume that the structure
14974 address is already on the stack, so we can specify a structure
14975 field address by using DW_OP_plus_uconst. */
14976 op
= DW_OP_plus_uconst
;
14977 loc_descr
= new_loc_descr (op
, offset
, 0);
14981 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
14984 /* Writes integer values to dw_vec_const array. */
14987 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
14991 *dest
++ = val
& 0xff;
14997 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
14999 static HOST_WIDE_INT
15000 extract_int (const unsigned char *src
, unsigned int size
)
15002 HOST_WIDE_INT val
= 0;
15008 val
|= *--src
& 0xff;
15014 /* Writes double_int values to dw_vec_const array. */
15017 insert_double (double_int val
, unsigned char *dest
)
15019 unsigned char *p0
= dest
;
15020 unsigned char *p1
= dest
+ sizeof (HOST_WIDE_INT
);
15022 if (WORDS_BIG_ENDIAN
)
15028 insert_int ((HOST_WIDE_INT
) val
.low
, sizeof (HOST_WIDE_INT
), p0
);
15029 insert_int ((HOST_WIDE_INT
) val
.high
, sizeof (HOST_WIDE_INT
), p1
);
15032 /* Writes floating point values to dw_vec_const array. */
15035 insert_float (const_rtx rtl
, unsigned char *array
)
15037 REAL_VALUE_TYPE rv
;
15041 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
15042 real_to_target (val
, &rv
, GET_MODE (rtl
));
15044 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15045 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
15047 insert_int (val
[i
], 4, array
);
15052 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15053 does not have a "location" either in memory or in a register. These
15054 things can arise in GNU C when a constant is passed as an actual parameter
15055 to an inlined function. They can also arise in C++ where declared
15056 constants do not necessarily get memory "homes". */
15059 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
15061 switch (GET_CODE (rtl
))
15065 HOST_WIDE_INT val
= INTVAL (rtl
);
15068 add_AT_int (die
, DW_AT_const_value
, val
);
15070 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
15075 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15076 floating-point constant. A CONST_DOUBLE is used whenever the
15077 constant requires more than one word in order to be adequately
15080 enum machine_mode mode
= GET_MODE (rtl
);
15082 if (SCALAR_FLOAT_MODE_P (mode
))
15084 unsigned int length
= GET_MODE_SIZE (mode
);
15085 unsigned char *array
= (unsigned char *) ggc_alloc_atomic (length
);
15087 insert_float (rtl
, array
);
15088 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
15091 add_AT_double (die
, DW_AT_const_value
,
15092 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
15098 enum machine_mode mode
= GET_MODE (rtl
);
15099 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
15100 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
15101 unsigned char *array
= (unsigned char *) ggc_alloc_atomic
15102 (length
* elt_size
);
15106 switch (GET_MODE_CLASS (mode
))
15108 case MODE_VECTOR_INT
:
15109 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15111 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15112 double_int val
= rtx_to_double_int (elt
);
15114 if (elt_size
<= sizeof (HOST_WIDE_INT
))
15115 insert_int (val
.to_shwi (), elt_size
, p
);
15118 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
15119 insert_double (val
, p
);
15124 case MODE_VECTOR_FLOAT
:
15125 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
15127 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
15128 insert_float (elt
, p
);
15133 gcc_unreachable ();
15136 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
15141 if (dwarf_version
>= 4 || !dwarf_strict
)
15143 dw_loc_descr_ref loc_result
;
15144 resolve_one_addr (&rtl
, NULL
);
15146 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15147 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
15148 add_AT_loc (die
, DW_AT_location
, loc_result
);
15149 vec_safe_push (used_rtx_array
, rtl
);
15155 if (CONSTANT_P (XEXP (rtl
, 0)))
15156 return add_const_value_attribute (die
, XEXP (rtl
, 0));
15159 if (!const_ok_for_output (rtl
))
15162 if (dwarf_version
>= 4 || !dwarf_strict
)
15167 /* In cases where an inlined instance of an inline function is passed
15168 the address of an `auto' variable (which is local to the caller) we
15169 can get a situation where the DECL_RTL of the artificial local
15170 variable (for the inlining) which acts as a stand-in for the
15171 corresponding formal parameter (of the inline function) will look
15172 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15173 exactly a compile-time constant expression, but it isn't the address
15174 of the (artificial) local variable either. Rather, it represents the
15175 *value* which the artificial local variable always has during its
15176 lifetime. We currently have no way to represent such quasi-constant
15177 values in Dwarf, so for now we just punt and generate nothing. */
15185 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
15186 && MEM_READONLY_P (rtl
)
15187 && GET_MODE (rtl
) == BLKmode
)
15189 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
15195 /* No other kinds of rtx should be possible here. */
15196 gcc_unreachable ();
15201 /* Determine whether the evaluation of EXPR references any variables
15202 or functions which aren't otherwise used (and therefore may not be
15205 reference_to_unused (tree
* tp
, int * walk_subtrees
,
15206 void * data ATTRIBUTE_UNUSED
)
15208 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
15209 *walk_subtrees
= 0;
15211 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
15212 && ! TREE_ASM_WRITTEN (*tp
))
15214 /* ??? The C++ FE emits debug information for using decls, so
15215 putting gcc_unreachable here falls over. See PR31899. For now
15216 be conservative. */
15217 else if (!cgraph_global_info_ready
15218 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
15220 else if (TREE_CODE (*tp
) == VAR_DECL
)
15222 varpool_node
*node
= varpool_get_node (*tp
);
15223 if (!node
|| !node
->definition
)
15226 else if (TREE_CODE (*tp
) == FUNCTION_DECL
15227 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
15229 /* The call graph machinery must have finished analyzing,
15230 optimizing and gimplifying the CU by now.
15231 So if *TP has no call graph node associated
15232 to it, it means *TP will not be emitted. */
15233 if (!cgraph_get_node (*tp
))
15236 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
15242 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15243 for use in a later add_const_value_attribute call. */
15246 rtl_for_decl_init (tree init
, tree type
)
15248 rtx rtl
= NULL_RTX
;
15252 /* If a variable is initialized with a string constant without embedded
15253 zeros, build CONST_STRING. */
15254 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
15256 tree enttype
= TREE_TYPE (type
);
15257 tree domain
= TYPE_DOMAIN (type
);
15258 enum machine_mode mode
= TYPE_MODE (enttype
);
15260 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
15262 && integer_zerop (TYPE_MIN_VALUE (domain
))
15263 && compare_tree_int (TYPE_MAX_VALUE (domain
),
15264 TREE_STRING_LENGTH (init
) - 1) == 0
15265 && ((size_t) TREE_STRING_LENGTH (init
)
15266 == strlen (TREE_STRING_POINTER (init
)) + 1))
15268 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
15269 ggc_strdup (TREE_STRING_POINTER (init
)));
15270 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
15271 MEM_READONLY_P (rtl
) = 1;
15274 /* Other aggregates, and complex values, could be represented using
15276 else if (AGGREGATE_TYPE_P (type
)
15277 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
15278 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
15279 || TREE_CODE (type
) == COMPLEX_TYPE
)
15281 /* Vectors only work if their mode is supported by the target.
15282 FIXME: generic vectors ought to work too. */
15283 else if (TREE_CODE (type
) == VECTOR_TYPE
15284 && !VECTOR_MODE_P (TYPE_MODE (type
)))
15286 /* If the initializer is something that we know will expand into an
15287 immediate RTL constant, expand it now. We must be careful not to
15288 reference variables which won't be output. */
15289 else if (initializer_constant_valid_p (init
, type
)
15290 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
15292 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15294 if (TREE_CODE (type
) == VECTOR_TYPE
)
15295 switch (TREE_CODE (init
))
15300 if (TREE_CONSTANT (init
))
15302 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
15303 bool constant_p
= true;
15305 unsigned HOST_WIDE_INT ix
;
15307 /* Even when ctor is constant, it might contain non-*_CST
15308 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15309 belong into VECTOR_CST nodes. */
15310 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
15311 if (!CONSTANT_CLASS_P (value
))
15313 constant_p
= false;
15319 init
= build_vector_from_ctor (type
, elts
);
15329 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
15331 /* If expand_expr returns a MEM, it wasn't immediate. */
15332 gcc_assert (!rtl
|| !MEM_P (rtl
));
15338 /* Generate RTL for the variable DECL to represent its location. */
15341 rtl_for_decl_location (tree decl
)
15345 /* Here we have to decide where we are going to say the parameter "lives"
15346 (as far as the debugger is concerned). We only have a couple of
15347 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15349 DECL_RTL normally indicates where the parameter lives during most of the
15350 activation of the function. If optimization is enabled however, this
15351 could be either NULL or else a pseudo-reg. Both of those cases indicate
15352 that the parameter doesn't really live anywhere (as far as the code
15353 generation parts of GCC are concerned) during most of the function's
15354 activation. That will happen (for example) if the parameter is never
15355 referenced within the function.
15357 We could just generate a location descriptor here for all non-NULL
15358 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15359 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15360 where DECL_RTL is NULL or is a pseudo-reg.
15362 Note however that we can only get away with using DECL_INCOMING_RTL as
15363 a backup substitute for DECL_RTL in certain limited cases. In cases
15364 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15365 we can be sure that the parameter was passed using the same type as it is
15366 declared to have within the function, and that its DECL_INCOMING_RTL
15367 points us to a place where a value of that type is passed.
15369 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15370 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15371 because in these cases DECL_INCOMING_RTL points us to a value of some
15372 type which is *different* from the type of the parameter itself. Thus,
15373 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15374 such cases, the debugger would end up (for example) trying to fetch a
15375 `float' from a place which actually contains the first part of a
15376 `double'. That would lead to really incorrect and confusing
15377 output at debug-time.
15379 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15380 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15381 are a couple of exceptions however. On little-endian machines we can
15382 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15383 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15384 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15385 when (on a little-endian machine) a non-prototyped function has a
15386 parameter declared to be of type `short' or `char'. In such cases,
15387 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15388 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15389 passed `int' value. If the debugger then uses that address to fetch
15390 a `short' or a `char' (on a little-endian machine) the result will be
15391 the correct data, so we allow for such exceptional cases below.
15393 Note that our goal here is to describe the place where the given formal
15394 parameter lives during most of the function's activation (i.e. between the
15395 end of the prologue and the start of the epilogue). We'll do that as best
15396 as we can. Note however that if the given formal parameter is modified
15397 sometime during the execution of the function, then a stack backtrace (at
15398 debug-time) will show the function as having been called with the *new*
15399 value rather than the value which was originally passed in. This happens
15400 rarely enough that it is not a major problem, but it *is* a problem, and
15401 I'd like to fix it.
15403 A future version of dwarf2out.c may generate two additional attributes for
15404 any given DW_TAG_formal_parameter DIE which will describe the "passed
15405 type" and the "passed location" for the given formal parameter in addition
15406 to the attributes we now generate to indicate the "declared type" and the
15407 "active location" for each parameter. This additional set of attributes
15408 could be used by debuggers for stack backtraces. Separately, note that
15409 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15410 This happens (for example) for inlined-instances of inline function formal
15411 parameters which are never referenced. This really shouldn't be
15412 happening. All PARM_DECL nodes should get valid non-NULL
15413 DECL_INCOMING_RTL values. FIXME. */
15415 /* Use DECL_RTL as the "location" unless we find something better. */
15416 rtl
= DECL_RTL_IF_SET (decl
);
15418 /* When generating abstract instances, ignore everything except
15419 constants, symbols living in memory, and symbols living in
15420 fixed registers. */
15421 if (! reload_completed
)
15424 && (CONSTANT_P (rtl
)
15426 && CONSTANT_P (XEXP (rtl
, 0)))
15428 && TREE_CODE (decl
) == VAR_DECL
15429 && TREE_STATIC (decl
))))
15431 rtl
= targetm
.delegitimize_address (rtl
);
15436 else if (TREE_CODE (decl
) == PARM_DECL
)
15438 if (rtl
== NULL_RTX
15439 || is_pseudo_reg (rtl
)
15441 && is_pseudo_reg (XEXP (rtl
, 0))
15442 && DECL_INCOMING_RTL (decl
)
15443 && MEM_P (DECL_INCOMING_RTL (decl
))
15444 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
15446 tree declared_type
= TREE_TYPE (decl
);
15447 tree passed_type
= DECL_ARG_TYPE (decl
);
15448 enum machine_mode dmode
= TYPE_MODE (declared_type
);
15449 enum machine_mode pmode
= TYPE_MODE (passed_type
);
15451 /* This decl represents a formal parameter which was optimized out.
15452 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15453 all cases where (rtl == NULL_RTX) just below. */
15454 if (dmode
== pmode
)
15455 rtl
= DECL_INCOMING_RTL (decl
);
15456 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
15457 && SCALAR_INT_MODE_P (dmode
)
15458 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
15459 && DECL_INCOMING_RTL (decl
))
15461 rtx inc
= DECL_INCOMING_RTL (decl
);
15464 else if (MEM_P (inc
))
15466 if (BYTES_BIG_ENDIAN
)
15467 rtl
= adjust_address_nv (inc
, dmode
,
15468 GET_MODE_SIZE (pmode
)
15469 - GET_MODE_SIZE (dmode
));
15476 /* If the parm was passed in registers, but lives on the stack, then
15477 make a big endian correction if the mode of the type of the
15478 parameter is not the same as the mode of the rtl. */
15479 /* ??? This is the same series of checks that are made in dbxout.c before
15480 we reach the big endian correction code there. It isn't clear if all
15481 of these checks are necessary here, but keeping them all is the safe
15483 else if (MEM_P (rtl
)
15484 && XEXP (rtl
, 0) != const0_rtx
15485 && ! CONSTANT_P (XEXP (rtl
, 0))
15486 /* Not passed in memory. */
15487 && !MEM_P (DECL_INCOMING_RTL (decl
))
15488 /* Not passed by invisible reference. */
15489 && (!REG_P (XEXP (rtl
, 0))
15490 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
15491 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
15492 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
15493 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
15496 /* Big endian correction check. */
15497 && BYTES_BIG_ENDIAN
15498 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
15499 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
15502 enum machine_mode addr_mode
= get_address_mode (rtl
);
15503 int offset
= (UNITS_PER_WORD
15504 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
15506 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15507 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
15510 else if (TREE_CODE (decl
) == VAR_DECL
15513 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
15514 && BYTES_BIG_ENDIAN
)
15516 enum machine_mode addr_mode
= get_address_mode (rtl
);
15517 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
15518 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
15520 /* If a variable is declared "register" yet is smaller than
15521 a register, then if we store the variable to memory, it
15522 looks like we're storing a register-sized value, when in
15523 fact we are not. We need to adjust the offset of the
15524 storage location to reflect the actual value's bytes,
15525 else gdb will not be able to display it. */
15527 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
15528 plus_constant (addr_mode
, XEXP (rtl
, 0),
15532 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15533 and will have been substituted directly into all expressions that use it.
15534 C does not have such a concept, but C++ and other languages do. */
15535 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
15536 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
15539 rtl
= targetm
.delegitimize_address (rtl
);
15541 /* If we don't look past the constant pool, we risk emitting a
15542 reference to a constant pool entry that isn't referenced from
15543 code, and thus is not emitted. */
15545 rtl
= avoid_constant_pool_reference (rtl
);
15547 /* Try harder to get a rtl. If this symbol ends up not being emitted
15548 in the current CU, resolve_addr will remove the expression referencing
15550 if (rtl
== NULL_RTX
15551 && TREE_CODE (decl
) == VAR_DECL
15552 && !DECL_EXTERNAL (decl
)
15553 && TREE_STATIC (decl
)
15554 && DECL_NAME (decl
)
15555 && !DECL_HARD_REGISTER (decl
)
15556 && DECL_MODE (decl
) != VOIDmode
)
15558 rtl
= make_decl_rtl_for_debug (decl
);
15560 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
15561 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
15568 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15569 returned. If so, the decl for the COMMON block is returned, and the
15570 value is the offset into the common block for the symbol. */
15573 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
15575 tree val_expr
, cvar
;
15576 enum machine_mode mode
;
15577 HOST_WIDE_INT bitsize
, bitpos
;
15579 int unsignedp
, volatilep
= 0;
15581 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15582 it does not have a value (the offset into the common area), or if it
15583 is thread local (as opposed to global) then it isn't common, and shouldn't
15584 be handled as such. */
15585 if (TREE_CODE (decl
) != VAR_DECL
15586 || !TREE_STATIC (decl
)
15587 || !DECL_HAS_VALUE_EXPR_P (decl
)
15591 val_expr
= DECL_VALUE_EXPR (decl
);
15592 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
15595 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
,
15596 &mode
, &unsignedp
, &volatilep
, true);
15598 if (cvar
== NULL_TREE
15599 || TREE_CODE (cvar
) != VAR_DECL
15600 || DECL_ARTIFICIAL (cvar
)
15601 || !TREE_PUBLIC (cvar
))
15605 if (offset
!= NULL
)
15607 if (!tree_fits_shwi_p (offset
))
15609 *value
= tree_to_shwi (offset
);
15612 *value
+= bitpos
/ BITS_PER_UNIT
;
15617 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
15618 data attribute for a variable or a parameter. We generate the
15619 DW_AT_const_value attribute only in those cases where the given variable
15620 or parameter does not have a true "location" either in memory or in a
15621 register. This can happen (for example) when a constant is passed as an
15622 actual argument in a call to an inline function. (It's possible that
15623 these things can crop up in other ways also.) Note that one type of
15624 constant value which can be passed into an inlined function is a constant
15625 pointer. This can happen for example if an actual argument in an inlined
15626 function call evaluates to a compile-time constant address.
15628 CACHE_P is true if it is worth caching the location list for DECL,
15629 so that future calls can reuse it rather than regenerate it from scratch.
15630 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
15631 since we will need to refer to them each time the function is inlined. */
15634 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
,
15635 enum dwarf_attribute attr
)
15638 dw_loc_list_ref list
;
15639 var_loc_list
*loc_list
;
15640 cached_dw_loc_list
*cache
;
15643 if (TREE_CODE (decl
) == ERROR_MARK
)
15646 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
15647 || TREE_CODE (decl
) == RESULT_DECL
);
15649 /* Try to get some constant RTL for this decl, and use that as the value of
15652 rtl
= rtl_for_decl_location (decl
);
15653 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15654 && add_const_value_attribute (die
, rtl
))
15657 /* See if we have single element location list that is equivalent to
15658 a constant value. That way we are better to use add_const_value_attribute
15659 rather than expanding constant value equivalent. */
15660 loc_list
= lookup_decl_loc (decl
);
15663 && loc_list
->first
->next
== NULL
15664 && NOTE_P (loc_list
->first
->loc
)
15665 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
15666 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
15668 struct var_loc_node
*node
;
15670 node
= loc_list
->first
;
15671 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
15672 if (GET_CODE (rtl
) == EXPR_LIST
)
15673 rtl
= XEXP (rtl
, 0);
15674 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15675 && add_const_value_attribute (die
, rtl
))
15678 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
15679 list several times. See if we've already cached the contents. */
15681 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
15685 cache
= (cached_dw_loc_list
*)
15686 htab_find_with_hash (cached_dw_loc_list_table
, decl
, DECL_UID (decl
));
15688 list
= cache
->loc_list
;
15692 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2);
15693 /* It is usually worth caching this result if the decl is from
15694 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
15695 if (cache_p
&& list
&& list
->dw_loc_next
)
15697 slot
= htab_find_slot_with_hash (cached_dw_loc_list_table
, decl
,
15698 DECL_UID (decl
), INSERT
);
15699 cache
= ggc_alloc_cleared_cached_dw_loc_list ();
15700 cache
->decl_id
= DECL_UID (decl
);
15701 cache
->loc_list
= list
;
15707 add_AT_location_description (die
, attr
, list
);
15710 /* None of that worked, so it must not really have a location;
15711 try adding a constant value attribute from the DECL_INITIAL. */
15712 return tree_add_const_value_attribute_for_decl (die
, decl
);
15715 /* Add VARIABLE and DIE into deferred locations list. */
15718 defer_location (tree variable
, dw_die_ref die
)
15720 deferred_locations entry
;
15721 entry
.variable
= variable
;
15723 vec_safe_push (deferred_locations_list
, entry
);
15726 /* Helper function for tree_add_const_value_attribute. Natively encode
15727 initializer INIT into an array. Return true if successful. */
15730 native_encode_initializer (tree init
, unsigned char *array
, int size
)
15734 if (init
== NULL_TREE
)
15738 switch (TREE_CODE (init
))
15741 type
= TREE_TYPE (init
);
15742 if (TREE_CODE (type
) == ARRAY_TYPE
)
15744 tree enttype
= TREE_TYPE (type
);
15745 enum machine_mode mode
= TYPE_MODE (enttype
);
15747 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
15749 if (int_size_in_bytes (type
) != size
)
15751 if (size
> TREE_STRING_LENGTH (init
))
15753 memcpy (array
, TREE_STRING_POINTER (init
),
15754 TREE_STRING_LENGTH (init
));
15755 memset (array
+ TREE_STRING_LENGTH (init
),
15756 '\0', size
- TREE_STRING_LENGTH (init
));
15759 memcpy (array
, TREE_STRING_POINTER (init
), size
);
15764 type
= TREE_TYPE (init
);
15765 if (int_size_in_bytes (type
) != size
)
15767 if (TREE_CODE (type
) == ARRAY_TYPE
)
15769 HOST_WIDE_INT min_index
;
15770 unsigned HOST_WIDE_INT cnt
;
15771 int curpos
= 0, fieldsize
;
15772 constructor_elt
*ce
;
15774 if (TYPE_DOMAIN (type
) == NULL_TREE
15775 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
15778 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
15779 if (fieldsize
<= 0)
15782 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
15783 memset (array
, '\0', size
);
15784 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15786 tree val
= ce
->value
;
15787 tree index
= ce
->index
;
15789 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15790 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
15793 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
15798 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
15801 curpos
= pos
+ fieldsize
;
15802 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15804 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
15805 - tree_to_shwi (TREE_OPERAND (index
, 0));
15806 while (count
-- > 0)
15809 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
15810 curpos
+= fieldsize
;
15813 gcc_assert (curpos
<= size
);
15817 else if (TREE_CODE (type
) == RECORD_TYPE
15818 || TREE_CODE (type
) == UNION_TYPE
)
15820 tree field
= NULL_TREE
;
15821 unsigned HOST_WIDE_INT cnt
;
15822 constructor_elt
*ce
;
15824 if (int_size_in_bytes (type
) != size
)
15827 if (TREE_CODE (type
) == RECORD_TYPE
)
15828 field
= TYPE_FIELDS (type
);
15830 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15832 tree val
= ce
->value
;
15833 int pos
, fieldsize
;
15835 if (ce
->index
!= 0)
15841 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
15844 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
15845 && TYPE_DOMAIN (TREE_TYPE (field
))
15846 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
15848 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
15849 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
15851 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
15852 pos
= int_byte_position (field
);
15853 gcc_assert (pos
+ fieldsize
<= size
);
15855 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
15861 case VIEW_CONVERT_EXPR
:
15862 case NON_LVALUE_EXPR
:
15863 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
15865 return native_encode_expr (init
, array
, size
) == size
;
15869 /* Attach a DW_AT_const_value attribute to DIE. The value of the
15870 attribute is the const value T. */
15873 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
15876 tree type
= TREE_TYPE (t
);
15879 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
15883 gcc_assert (!DECL_P (init
));
15885 rtl
= rtl_for_decl_init (init
, type
);
15887 return add_const_value_attribute (die
, rtl
);
15888 /* If the host and target are sane, try harder. */
15889 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
15890 && initializer_constant_valid_p (init
, type
))
15892 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
15893 if (size
> 0 && (int) size
== size
)
15895 unsigned char *array
= (unsigned char *)
15896 ggc_alloc_cleared_atomic (size
);
15898 if (native_encode_initializer (init
, array
, size
))
15900 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
15909 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
15910 attribute is the const value of T, where T is an integral constant
15911 variable with static storage duration
15912 (so it can't be a PARM_DECL or a RESULT_DECL). */
15915 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
15919 || (TREE_CODE (decl
) != VAR_DECL
15920 && TREE_CODE (decl
) != CONST_DECL
)
15921 || (TREE_CODE (decl
) == VAR_DECL
15922 && !TREE_STATIC (decl
)))
15925 if (TREE_READONLY (decl
)
15926 && ! TREE_THIS_VOLATILE (decl
)
15927 && DECL_INITIAL (decl
))
15932 /* Don't add DW_AT_const_value if abstract origin already has one. */
15933 if (get_AT (var_die
, DW_AT_const_value
))
15936 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
15939 /* Convert the CFI instructions for the current function into a
15940 location list. This is used for DW_AT_frame_base when we targeting
15941 a dwarf2 consumer that does not support the dwarf3
15942 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
15945 static dw_loc_list_ref
15946 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
15950 dw_loc_list_ref list
, *list_tail
;
15952 dw_cfa_location last_cfa
, next_cfa
;
15953 const char *start_label
, *last_label
, *section
;
15954 dw_cfa_location remember
;
15957 gcc_assert (fde
!= NULL
);
15959 section
= secname_for_decl (current_function_decl
);
15963 memset (&next_cfa
, 0, sizeof (next_cfa
));
15964 next_cfa
.reg
= INVALID_REGNUM
;
15965 remember
= next_cfa
;
15967 start_label
= fde
->dw_fde_begin
;
15969 /* ??? Bald assumption that the CIE opcode list does not contain
15970 advance opcodes. */
15971 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
15972 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
15974 last_cfa
= next_cfa
;
15975 last_label
= start_label
;
15977 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
15979 /* If the first partition contained no CFI adjustments, the
15980 CIE opcodes apply to the whole first partition. */
15981 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15982 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
15983 list_tail
=&(*list_tail
)->dw_loc_next
;
15984 start_label
= last_label
= fde
->dw_fde_second_begin
;
15987 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
15989 switch (cfi
->dw_cfi_opc
)
15991 case DW_CFA_set_loc
:
15992 case DW_CFA_advance_loc1
:
15993 case DW_CFA_advance_loc2
:
15994 case DW_CFA_advance_loc4
:
15995 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
15997 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15998 start_label
, last_label
, section
);
16000 list_tail
= &(*list_tail
)->dw_loc_next
;
16001 last_cfa
= next_cfa
;
16002 start_label
= last_label
;
16004 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
16007 case DW_CFA_advance_loc
:
16008 /* The encoding is complex enough that we should never emit this. */
16009 gcc_unreachable ();
16012 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16015 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
16017 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16019 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16020 start_label
, last_label
, section
);
16022 list_tail
= &(*list_tail
)->dw_loc_next
;
16023 last_cfa
= next_cfa
;
16024 start_label
= last_label
;
16026 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16027 start_label
, fde
->dw_fde_end
, section
);
16028 list_tail
= &(*list_tail
)->dw_loc_next
;
16029 start_label
= last_label
= fde
->dw_fde_second_begin
;
16033 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16035 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16036 start_label
, last_label
, section
);
16037 list_tail
= &(*list_tail
)->dw_loc_next
;
16038 start_label
= last_label
;
16041 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
16043 fde
->dw_fde_second_begin
16044 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
16047 if (list
&& list
->dw_loc_next
)
16053 /* Compute a displacement from the "steady-state frame pointer" to the
16054 frame base (often the same as the CFA), and store it in
16055 frame_pointer_fb_offset. OFFSET is added to the displacement
16056 before the latter is negated. */
16059 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
16063 #ifdef FRAME_POINTER_CFA_OFFSET
16064 reg
= frame_pointer_rtx
;
16065 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
16067 reg
= arg_pointer_rtx
;
16068 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
16071 elim
= (ira_use_lra_p
16072 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
16073 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
16074 if (GET_CODE (elim
) == PLUS
)
16076 offset
+= INTVAL (XEXP (elim
, 1));
16077 elim
= XEXP (elim
, 0);
16080 frame_pointer_fb_offset
= -offset
;
16082 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
16083 in which to eliminate. This is because it's stack pointer isn't
16084 directly accessible as a register within the ISA. To work around
16085 this, assume that while we cannot provide a proper value for
16086 frame_pointer_fb_offset, we won't need one either. */
16087 frame_pointer_fb_offset_valid
16088 = ((SUPPORTS_STACK_ALIGNMENT
16089 && (elim
== hard_frame_pointer_rtx
16090 || elim
== stack_pointer_rtx
))
16091 || elim
== (frame_pointer_needed
16092 ? hard_frame_pointer_rtx
16093 : stack_pointer_rtx
));
16096 /* Generate a DW_AT_name attribute given some string value to be included as
16097 the value of the attribute. */
16100 add_name_attribute (dw_die_ref die
, const char *name_string
)
16102 if (name_string
!= NULL
&& *name_string
!= 0)
16104 if (demangle_name_func
)
16105 name_string
= (*demangle_name_func
) (name_string
);
16107 add_AT_string (die
, DW_AT_name
, name_string
);
16111 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
16112 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
16113 of TYPE accordingly.
16115 ??? This is a temporary measure until after we're able to generate
16116 regular DWARF for the complex Ada type system. */
16119 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
16120 dw_die_ref context_die
)
16123 dw_die_ref dtype_die
;
16125 if (!lang_hooks
.types
.descriptive_type
)
16128 dtype
= lang_hooks
.types
.descriptive_type (type
);
16132 dtype_die
= lookup_type_die (dtype
);
16135 gen_type_die (dtype
, context_die
);
16136 dtype_die
= lookup_type_die (dtype
);
16137 gcc_assert (dtype_die
);
16140 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
16143 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
16145 static const char *
16146 comp_dir_string (void)
16150 static const char *cached_wd
= NULL
;
16152 if (cached_wd
!= NULL
)
16155 wd
= get_src_pwd ();
16159 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
16163 wdlen
= strlen (wd
);
16164 wd1
= (char *) ggc_alloc_atomic (wdlen
+ 2);
16166 wd1
[wdlen
] = DIR_SEPARATOR
;
16167 wd1
[wdlen
+ 1] = 0;
16171 cached_wd
= remap_debug_filename (wd
);
16175 /* Generate a DW_AT_comp_dir attribute for DIE. */
16178 add_comp_dir_attribute (dw_die_ref die
)
16180 const char * wd
= comp_dir_string ();
16182 add_AT_string (die
, DW_AT_comp_dir
, wd
);
16185 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16189 lower_bound_default (void)
16191 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
16196 case DW_LANG_C_plus_plus
:
16198 case DW_LANG_ObjC_plus_plus
:
16201 case DW_LANG_Fortran77
:
16202 case DW_LANG_Fortran90
:
16203 case DW_LANG_Fortran95
:
16207 case DW_LANG_Python
:
16208 return dwarf_version
>= 4 ? 0 : -1;
16209 case DW_LANG_Ada95
:
16210 case DW_LANG_Ada83
:
16211 case DW_LANG_Cobol74
:
16212 case DW_LANG_Cobol85
:
16213 case DW_LANG_Pascal83
:
16214 case DW_LANG_Modula2
:
16216 return dwarf_version
>= 4 ? 1 : -1;
16222 /* Given a tree node describing an array bound (either lower or upper) output
16223 a representation for that bound. */
16226 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
16228 switch (TREE_CODE (bound
))
16233 /* All fixed-bounds are represented by INTEGER_CST nodes. */
16236 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (bound
));
16239 /* Use the default if possible. */
16240 if (bound_attr
== DW_AT_lower_bound
16241 && tree_fits_shwi_p (bound
)
16242 && (dflt
= lower_bound_default ()) != -1
16243 && tree_to_shwi (bound
) == dflt
)
16246 /* Otherwise represent the bound as an unsigned value with the
16247 precision of its type. The precision and signedness of the
16248 type will be necessary to re-interpret it unambiguously. */
16249 else if (prec
< HOST_BITS_PER_WIDE_INT
)
16251 unsigned HOST_WIDE_INT mask
16252 = ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
16253 add_AT_unsigned (subrange_die
, bound_attr
,
16254 TREE_INT_CST_LOW (bound
) & mask
);
16256 else if (prec
== HOST_BITS_PER_WIDE_INT
16257 || TREE_INT_CST_HIGH (bound
) == 0)
16258 add_AT_unsigned (subrange_die
, bound_attr
,
16259 TREE_INT_CST_LOW (bound
));
16261 add_AT_double (subrange_die
, bound_attr
, TREE_INT_CST_HIGH (bound
),
16262 TREE_INT_CST_LOW (bound
));
16267 case VIEW_CONVERT_EXPR
:
16268 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
16278 dw_die_ref decl_die
= lookup_decl_die (bound
);
16280 /* ??? Can this happen, or should the variable have been bound
16281 first? Probably it can, since I imagine that we try to create
16282 the types of parameters in the order in which they exist in
16283 the list, and won't have created a forward reference to a
16284 later parameter. */
16285 if (decl_die
!= NULL
)
16287 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16295 /* Otherwise try to create a stack operation procedure to
16296 evaluate the value of the array bound. */
16298 dw_die_ref ctx
, decl_die
;
16299 dw_loc_list_ref list
;
16301 list
= loc_list_from_tree (bound
, 2);
16302 if (list
== NULL
|| single_element_loc_list_p (list
))
16304 /* If DW_AT_*bound is not a reference nor constant, it is
16305 a DWARF expression rather than location description.
16306 For that loc_list_from_tree (bound, 0) is needed.
16307 If that fails to give a single element list,
16308 fall back to outputting this as a reference anyway. */
16309 dw_loc_list_ref list2
= loc_list_from_tree (bound
, 0);
16310 if (list2
&& single_element_loc_list_p (list2
))
16312 add_AT_loc (subrange_die
, bound_attr
, list2
->expr
);
16319 if (current_function_decl
== 0)
16320 ctx
= comp_unit_die ();
16322 ctx
= lookup_decl_die (current_function_decl
);
16324 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
16325 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
16326 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
16327 add_AT_location_description (decl_die
, DW_AT_location
, list
);
16328 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
16334 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16335 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16336 Note that the block of subscript information for an array type also
16337 includes information about the element type of the given array type. */
16340 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
16342 unsigned dimension_number
;
16344 dw_die_ref subrange_die
;
16346 for (dimension_number
= 0;
16347 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
16348 type
= TREE_TYPE (type
), dimension_number
++)
16350 tree domain
= TYPE_DOMAIN (type
);
16352 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
16355 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16356 and (in GNU C only) variable bounds. Handle all three forms
16358 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
16360 if (use_upc_dwarf2_extensions
&& TYPE_HAS_THREADS_FACTOR (type
))
16362 add_AT_flag (subrange_die
, DW_AT_upc_threads_scaled
, 1);
16367 /* We have an array type with specified bounds. */
16368 lower
= TYPE_MIN_VALUE (domain
);
16369 upper
= TYPE_MAX_VALUE (domain
);
16371 /* Define the index type. */
16372 if (TREE_TYPE (domain
))
16374 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16375 TREE_TYPE field. We can't emit debug info for this
16376 because it is an unnamed integral type. */
16377 if (TREE_CODE (domain
) == INTEGER_TYPE
16378 && TYPE_NAME (domain
) == NULL_TREE
16379 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
16380 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
16383 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
16387 /* ??? If upper is NULL, the array has unspecified length,
16388 but it does have a lower bound. This happens with Fortran
16390 Since the debugger is definitely going to need to know N
16391 to produce useful results, go ahead and output the lower
16392 bound solo, and hope the debugger can cope. */
16394 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
16396 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
16399 /* Otherwise we have an array type with an unspecified length. The
16400 DWARF-2 spec does not say how to handle this; let's just leave out the
16405 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
16408 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
16410 dw_die_ref decl_die
;
16411 HOST_WIDE_INT size
;
16413 switch (TREE_CODE (tree_node
))
16418 case ENUMERAL_TYPE
:
16421 case QUAL_UNION_TYPE
:
16422 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
16423 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
16425 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
16428 size
= int_size_in_bytes (tree_node
);
16431 /* For a data member of a struct or union, the DW_AT_byte_size is
16432 generally given as the number of bytes normally allocated for an
16433 object of the *declared* type of the member itself. This is true
16434 even for bit-fields. */
16435 size
= int_size_in_bytes (field_type (tree_node
));
16438 gcc_unreachable ();
16441 /* Note that `size' might be -1 when we get to this point. If it is, that
16442 indicates that the byte size of the entity in question is variable. We
16443 have no good way of expressing this fact in Dwarf at the present time,
16444 when location description was not used by the caller code instead. */
16446 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
16449 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16450 which specifies the distance in bits from the highest order bit of the
16451 "containing object" for the bit-field to the highest order bit of the
16454 For any given bit-field, the "containing object" is a hypothetical object
16455 (of some integral or enum type) within which the given bit-field lives. The
16456 type of this hypothetical "containing object" is always the same as the
16457 declared type of the individual bit-field itself. The determination of the
16458 exact location of the "containing object" for a bit-field is rather
16459 complicated. It's handled by the `field_byte_offset' function (above).
16461 Note that it is the size (in bytes) of the hypothetical "containing object"
16462 which will be given in the DW_AT_byte_size attribute for this bit-field.
16463 (See `byte_size_attribute' above). */
16466 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
16468 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
16469 tree type
= DECL_BIT_FIELD_TYPE (decl
);
16470 HOST_WIDE_INT bitpos_int
;
16471 HOST_WIDE_INT highest_order_object_bit_offset
;
16472 HOST_WIDE_INT highest_order_field_bit_offset
;
16473 HOST_WIDE_INT bit_offset
;
16475 /* Must be a field and a bit field. */
16476 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
16478 /* We can't yet handle bit-fields whose offsets are variable, so if we
16479 encounter such things, just return without generating any attribute
16480 whatsoever. Likewise for variable or too large size. */
16481 if (! tree_fits_shwi_p (bit_position (decl
))
16482 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
16485 bitpos_int
= int_bit_position (decl
);
16487 /* Note that the bit offset is always the distance (in bits) from the
16488 highest-order bit of the "containing object" to the highest-order bit of
16489 the bit-field itself. Since the "high-order end" of any object or field
16490 is different on big-endian and little-endian machines, the computation
16491 below must take account of these differences. */
16492 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
16493 highest_order_field_bit_offset
= bitpos_int
;
16495 if (! BYTES_BIG_ENDIAN
)
16497 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
16498 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
16502 = (! BYTES_BIG_ENDIAN
16503 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
16504 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
16506 if (bit_offset
< 0)
16507 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
16509 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
16512 /* For a FIELD_DECL node which represents a bit field, output an attribute
16513 which specifies the length in bits of the given field. */
16516 add_bit_size_attribute (dw_die_ref die
, tree decl
)
16518 /* Must be a field and a bit field. */
16519 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
16520 && DECL_BIT_FIELD_TYPE (decl
));
16522 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
16523 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
16526 /* If the compiled language is ANSI C, then add a 'prototyped'
16527 attribute, if arg types are given for the parameters of a function. */
16530 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
16532 if (get_AT_unsigned (comp_unit_die (), DW_AT_language
) == DW_LANG_C89
16533 && prototype_p (func_type
))
16534 add_AT_flag (die
, DW_AT_prototyped
, 1);
16537 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
16538 by looking in either the type declaration or object declaration
16541 static inline dw_die_ref
16542 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
16544 dw_die_ref origin_die
= NULL
;
16546 if (TREE_CODE (origin
) != FUNCTION_DECL
)
16548 /* We may have gotten separated from the block for the inlined
16549 function, if we're in an exception handler or some such; make
16550 sure that the abstract function has been written out.
16552 Doing this for nested functions is wrong, however; functions are
16553 distinct units, and our context might not even be inline. */
16557 fn
= TYPE_STUB_DECL (fn
);
16559 fn
= decl_function_context (fn
);
16561 dwarf2out_abstract_function (fn
);
16564 if (DECL_P (origin
))
16565 origin_die
= lookup_decl_die (origin
);
16566 else if (TYPE_P (origin
))
16567 origin_die
= lookup_type_die (origin
);
16569 /* XXX: Functions that are never lowered don't always have correct block
16570 trees (in the case of java, they simply have no block tree, in some other
16571 languages). For these functions, there is nothing we can really do to
16572 output correct debug info for inlined functions in all cases. Rather
16573 than die, we'll just produce deficient debug info now, in that we will
16574 have variables without a proper abstract origin. In the future, when all
16575 functions are lowered, we should re-add a gcc_assert (origin_die)
16579 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
16583 /* We do not currently support the pure_virtual attribute. */
16586 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
16588 if (DECL_VINDEX (func_decl
))
16590 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
16592 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
16593 add_AT_loc (die
, DW_AT_vtable_elem_location
,
16594 new_loc_descr (DW_OP_constu
,
16595 tree_to_shwi (DECL_VINDEX (func_decl
)),
16598 /* GNU extension: Record what type this method came from originally. */
16599 if (debug_info_level
> DINFO_LEVEL_TERSE
16600 && DECL_CONTEXT (func_decl
))
16601 add_AT_die_ref (die
, DW_AT_containing_type
,
16602 lookup_type_die (DECL_CONTEXT (func_decl
)));
16606 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
16607 given decl. This used to be a vendor extension until after DWARF 4
16608 standardized it. */
16611 add_linkage_attr (dw_die_ref die
, tree decl
)
16613 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
16615 /* Mimic what assemble_name_raw does with a leading '*'. */
16616 if (name
[0] == '*')
16619 if (dwarf_version
>= 4)
16620 add_AT_string (die
, DW_AT_linkage_name
, name
);
16622 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
16625 /* Add source coordinate attributes for the given decl. */
16628 add_src_coords_attributes (dw_die_ref die
, tree decl
)
16630 expanded_location s
;
16632 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
16634 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
16635 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
16636 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
16639 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
16642 add_linkage_name (dw_die_ref die
, tree decl
)
16644 if (debug_info_level
> DINFO_LEVEL_TERSE
16645 && (TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
16646 && TREE_PUBLIC (decl
)
16647 && !DECL_ABSTRACT (decl
)
16648 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
16649 && die
->die_tag
!= DW_TAG_member
)
16651 /* Defer until we have an assembler name set. */
16652 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
16654 limbo_die_node
*asm_name
;
16656 asm_name
= ggc_alloc_cleared_limbo_die_node ();
16657 asm_name
->die
= die
;
16658 asm_name
->created_for
= decl
;
16659 asm_name
->next
= deferred_asm_name
;
16660 deferred_asm_name
= asm_name
;
16662 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
16663 add_linkage_attr (die
, decl
);
16667 /* Add a DW_AT_name attribute and source coordinate attribute for the
16668 given decl, but only if it actually has a name. */
16671 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
16675 decl_name
= DECL_NAME (decl
);
16676 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
16678 const char *name
= dwarf2_name (decl
, 0);
16680 add_name_attribute (die
, name
);
16681 if (! DECL_ARTIFICIAL (decl
))
16682 add_src_coords_attributes (die
, decl
);
16684 add_linkage_name (die
, decl
);
16687 #ifdef VMS_DEBUGGING_INFO
16688 /* Get the function's name, as described by its RTL. This may be different
16689 from the DECL_NAME name used in the source file. */
16690 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
16692 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
16693 XEXP (DECL_RTL (decl
), 0), false);
16694 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
16696 #endif /* VMS_DEBUGGING_INFO */
16699 #ifdef VMS_DEBUGGING_INFO
16700 /* Output the debug main pointer die for VMS */
16703 dwarf2out_vms_debug_main_pointer (void)
16705 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
16708 /* Allocate the VMS debug main subprogram die. */
16709 die
= ggc_alloc_cleared_die_node ();
16710 die
->die_tag
= DW_TAG_subprogram
;
16711 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
16712 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
16713 current_function_funcdef_no
);
16714 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
16716 /* Make it the first child of comp_unit_die (). */
16717 die
->die_parent
= comp_unit_die ();
16718 if (comp_unit_die ()->die_child
)
16720 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
16721 comp_unit_die ()->die_child
->die_sib
= die
;
16725 die
->die_sib
= die
;
16726 comp_unit_die ()->die_child
= die
;
16729 #endif /* VMS_DEBUGGING_INFO */
16731 /* Push a new declaration scope. */
16734 push_decl_scope (tree scope
)
16736 vec_safe_push (decl_scope_table
, scope
);
16739 /* Pop a declaration scope. */
16742 pop_decl_scope (void)
16744 decl_scope_table
->pop ();
16747 /* walk_tree helper function for uses_local_type, below. */
16750 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
16753 *walk_subtrees
= 0;
16756 tree name
= TYPE_NAME (*tp
);
16757 if (name
&& DECL_P (name
) && decl_function_context (name
))
16763 /* If TYPE involves a function-local type (including a local typedef to a
16764 non-local type), returns that type; otherwise returns NULL_TREE. */
16767 uses_local_type (tree type
)
16769 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
16773 /* Return the DIE for the scope that immediately contains this type.
16774 Non-named types that do not involve a function-local type get global
16775 scope. Named types nested in namespaces or other types get their
16776 containing scope. All other types (i.e. function-local named types) get
16777 the current active scope. */
16780 scope_die_for (tree t
, dw_die_ref context_die
)
16782 dw_die_ref scope_die
= NULL
;
16783 tree containing_scope
;
16785 /* Non-types always go in the current scope. */
16786 gcc_assert (TYPE_P (t
));
16788 /* Use the scope of the typedef, rather than the scope of the type
16790 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
16791 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
16793 containing_scope
= TYPE_CONTEXT (t
);
16795 /* Use the containing namespace if there is one. */
16796 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
16798 if (context_die
== lookup_decl_die (containing_scope
))
16800 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
16801 context_die
= get_context_die (containing_scope
);
16803 containing_scope
= NULL_TREE
;
16806 /* Ignore function type "scopes" from the C frontend. They mean that
16807 a tagged type is local to a parmlist of a function declarator, but
16808 that isn't useful to DWARF. */
16809 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
16810 containing_scope
= NULL_TREE
;
16812 if (SCOPE_FILE_SCOPE_P (containing_scope
))
16814 /* If T uses a local type keep it local as well, to avoid references
16815 to function-local DIEs from outside the function. */
16816 if (current_function_decl
&& uses_local_type (t
))
16817 scope_die
= context_die
;
16819 scope_die
= comp_unit_die ();
16821 else if (TYPE_P (containing_scope
))
16823 /* For types, we can just look up the appropriate DIE. */
16824 if (debug_info_level
> DINFO_LEVEL_TERSE
)
16825 scope_die
= get_context_die (containing_scope
);
16828 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
16829 if (scope_die
== NULL
)
16830 scope_die
= comp_unit_die ();
16834 scope_die
= context_die
;
16839 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
16842 local_scope_p (dw_die_ref context_die
)
16844 for (; context_die
; context_die
= context_die
->die_parent
)
16845 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
16846 || context_die
->die_tag
== DW_TAG_subprogram
)
16852 /* Returns nonzero if CONTEXT_DIE is a class. */
16855 class_scope_p (dw_die_ref context_die
)
16857 return (context_die
16858 && (context_die
->die_tag
== DW_TAG_structure_type
16859 || context_die
->die_tag
== DW_TAG_class_type
16860 || context_die
->die_tag
== DW_TAG_interface_type
16861 || context_die
->die_tag
== DW_TAG_union_type
));
16864 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
16865 whether or not to treat a DIE in this context as a declaration. */
16868 class_or_namespace_scope_p (dw_die_ref context_die
)
16870 return (class_scope_p (context_die
)
16871 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
16874 /* Many forms of DIEs require a "type description" attribute. This
16875 routine locates the proper "type descriptor" die for the type given
16876 by 'type', and adds a DW_AT_type attribute below the given die. */
16879 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
16880 int decl_volatile
, dw_die_ref context_die
)
16882 enum tree_code code
= TREE_CODE (type
);
16883 dw_die_ref type_die
= NULL
;
16886 /* ??? If this type is an unnamed subrange type of an integral, floating-point
16887 or fixed-point type, use the inner type. This is because we have no
16888 support for unnamed types in base_type_die. This can happen if this is
16889 an Ada subrange type. Correct solution is emit a subrange type die. */
16890 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
16891 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
16892 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
16894 if (code
== ERROR_MARK
16895 /* Handle a special case. For functions whose return type is void, we
16896 generate *no* type attribute. (Note that no object may have type
16897 `void', so this only applies to function return types). */
16898 || code
== VOID_TYPE
)
16901 type_quals
= TYPE_QUALS (type
)
16902 | (decl_const
* TYPE_QUAL_CONST
)
16903 | (decl_volatile
* TYPE_QUAL_VOLATILE
);
16904 type_die
= modified_type_die (type
, type_quals
, context_die
);
16906 if (type_die
!= NULL
)
16907 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
16910 /* Given an object die, add the calling convention attribute for the
16911 function call type. */
16913 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
16915 enum dwarf_calling_convention value
= DW_CC_normal
;
16917 value
= ((enum dwarf_calling_convention
)
16918 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
16921 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
16923 /* DWARF 2 doesn't provide a way to identify a program's source-level
16924 entry point. DW_AT_calling_convention attributes are only meant
16925 to describe functions' calling conventions. However, lacking a
16926 better way to signal the Fortran main program, we used this for
16927 a long time, following existing custom. Now, DWARF 4 has
16928 DW_AT_main_subprogram, which we add below, but some tools still
16929 rely on the old way, which we thus keep. */
16930 value
= DW_CC_program
;
16932 if (dwarf_version
>= 4 || !dwarf_strict
)
16933 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
16936 /* Only add the attribute if the backend requests it, and
16937 is not DW_CC_normal. */
16938 if (value
&& (value
!= DW_CC_normal
))
16939 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
16942 /* Given a tree pointer to a struct, class, union, or enum type node, return
16943 a pointer to the (string) tag name for the given type, or zero if the type
16944 was declared without a tag. */
16946 static const char *
16947 type_tag (const_tree type
)
16949 const char *name
= 0;
16951 if (TYPE_NAME (type
) != 0)
16955 /* Find the IDENTIFIER_NODE for the type name. */
16956 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
16957 && !TYPE_NAMELESS (type
))
16958 t
= TYPE_NAME (type
);
16960 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
16961 a TYPE_DECL node, regardless of whether or not a `typedef' was
16963 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
16964 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
16966 /* We want to be extra verbose. Don't call dwarf_name if
16967 DECL_NAME isn't set. The default hook for decl_printable_name
16968 doesn't like that, and in this context it's correct to return
16969 0, instead of "<anonymous>" or the like. */
16970 if (DECL_NAME (TYPE_NAME (type
))
16971 && !DECL_NAMELESS (TYPE_NAME (type
)))
16972 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
16975 /* Now get the name as a string, or invent one. */
16976 if (!name
&& t
!= 0)
16977 name
= IDENTIFIER_POINTER (t
);
16980 return (name
== 0 || *name
== '\0') ? 0 : name
;
16983 /* Return the type associated with a data member, make a special check
16984 for bit field types. */
16987 member_declared_type (const_tree member
)
16989 return (DECL_BIT_FIELD_TYPE (member
)
16990 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
16993 /* Get the decl's label, as described by its RTL. This may be different
16994 from the DECL_NAME name used in the source file. */
16997 static const char *
16998 decl_start_label (tree decl
)
17001 const char *fnname
;
17003 x
= DECL_RTL (decl
);
17004 gcc_assert (MEM_P (x
));
17007 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
17009 fnname
= XSTR (x
, 0);
17014 /* These routines generate the internal representation of the DIE's for
17015 the compilation unit. Debugging information is collected by walking
17016 the declaration trees passed in from dwarf2out_decl(). */
17019 gen_array_type_die (tree type
, dw_die_ref context_die
)
17021 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17022 dw_die_ref array_die
;
17024 /* GNU compilers represent multidimensional array types as sequences of one
17025 dimensional array types whose element types are themselves array types.
17026 We sometimes squish that down to a single array_type DIE with multiple
17027 subscripts in the Dwarf debugging info. The draft Dwarf specification
17028 say that we are allowed to do this kind of compression in C, because
17029 there is no difference between an array of arrays and a multidimensional
17030 array. We don't do this for Ada to remain as close as possible to the
17031 actual representation, which is especially important against the language
17032 flexibilty wrt arrays of variable size. */
17034 bool collapse_nested_arrays
= !is_ada ();
17037 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17038 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17039 if (TYPE_STRING_FLAG (type
)
17040 && TREE_CODE (type
) == ARRAY_TYPE
17042 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
17044 HOST_WIDE_INT size
;
17046 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
17047 add_name_attribute (array_die
, type_tag (type
));
17048 equate_type_number_to_die (type
, array_die
);
17049 size
= int_size_in_bytes (type
);
17051 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17052 else if (TYPE_DOMAIN (type
) != NULL_TREE
17053 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
17054 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
17056 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
17057 dw_loc_list_ref loc
= loc_list_from_tree (szdecl
, 2);
17059 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
17060 if (loc
&& size
> 0)
17062 add_AT_location_description (array_die
, DW_AT_string_length
, loc
);
17063 if (size
!= DWARF2_ADDR_SIZE
)
17064 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17070 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17071 add_name_attribute (array_die
, type_tag (type
));
17072 equate_type_number_to_die (type
, array_die
);
17074 if (TREE_CODE (type
) == VECTOR_TYPE
)
17075 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
17077 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17079 && TREE_CODE (type
) == ARRAY_TYPE
17080 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
17081 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
17082 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17085 /* We default the array ordering. SDB will probably do
17086 the right things even if DW_AT_ordering is not present. It's not even
17087 an issue until we start to get into multidimensional arrays anyway. If
17088 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17089 then we'll have to put the DW_AT_ordering attribute back in. (But if
17090 and when we find out that we need to put these in, we will only do so
17091 for multidimensional arrays. */
17092 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
17095 if (TREE_CODE (type
) == VECTOR_TYPE
)
17097 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
17098 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17099 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
);
17100 add_bound_info (subrange_die
, DW_AT_upper_bound
,
17101 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
17104 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
17106 /* Add representation of the type of the elements of this array type and
17107 emit the corresponding DIE if we haven't done it already. */
17108 element_type
= TREE_TYPE (type
);
17109 if (collapse_nested_arrays
)
17110 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
17112 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
17114 element_type
= TREE_TYPE (element_type
);
17117 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
17119 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
17120 if (TYPE_ARTIFICIAL (type
))
17121 add_AT_flag (array_die
, DW_AT_artificial
, 1);
17123 if (get_AT (array_die
, DW_AT_name
))
17124 add_pubtype (type
, array_die
);
17127 static dw_loc_descr_ref
17128 descr_info_loc (tree val
, tree base_decl
)
17130 HOST_WIDE_INT size
;
17131 dw_loc_descr_ref loc
, loc2
;
17132 enum dwarf_location_atom op
;
17134 if (val
== base_decl
)
17135 return new_loc_descr (DW_OP_push_object_address
, 0, 0);
17137 switch (TREE_CODE (val
))
17140 return descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17142 return loc_descriptor_from_tree (val
, 0);
17144 if (tree_fits_shwi_p (val
))
17145 return int_loc_descriptor (tree_to_shwi (val
));
17148 size
= int_size_in_bytes (TREE_TYPE (val
));
17151 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17154 if (size
== DWARF2_ADDR_SIZE
)
17155 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref
, 0, 0));
17157 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref_size
, size
, 0));
17159 case POINTER_PLUS_EXPR
:
17161 if (tree_fits_uhwi_p (TREE_OPERAND (val
, 1))
17162 && tree_to_uhwi (TREE_OPERAND (val
, 1)) < 16384)
17164 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17167 loc_descr_plus_const (&loc
, tree_to_shwi (TREE_OPERAND (val
, 1)));
17173 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17176 loc2
= descr_info_loc (TREE_OPERAND (val
, 1), base_decl
);
17179 add_loc_descr (&loc
, loc2
);
17180 add_loc_descr (&loc2
, new_loc_descr (op
, 0, 0));
17202 add_descr_info_field (dw_die_ref die
, enum dwarf_attribute attr
,
17203 tree val
, tree base_decl
)
17205 dw_loc_descr_ref loc
;
17207 if (tree_fits_shwi_p (val
))
17209 add_AT_unsigned (die
, attr
, tree_to_shwi (val
));
17213 loc
= descr_info_loc (val
, base_decl
);
17217 add_AT_loc (die
, attr
, loc
);
17220 /* This routine generates DIE for array with hidden descriptor, details
17221 are filled into *info by a langhook. */
17224 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
17225 dw_die_ref context_die
)
17227 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17228 dw_die_ref array_die
;
17231 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17232 add_name_attribute (array_die
, type_tag (type
));
17233 equate_type_number_to_die (type
, array_die
);
17235 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17237 && info
->ndimensions
>= 2)
17238 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17240 if (info
->data_location
)
17241 add_descr_info_field (array_die
, DW_AT_data_location
, info
->data_location
,
17243 if (info
->associated
)
17244 add_descr_info_field (array_die
, DW_AT_associated
, info
->associated
,
17246 if (info
->allocated
)
17247 add_descr_info_field (array_die
, DW_AT_allocated
, info
->allocated
,
17250 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
17252 dw_die_ref subrange_die
17253 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17255 if (info
->dimen
[dim
].lower_bound
)
17257 /* If it is the default value, omit it. */
17260 if (tree_fits_shwi_p (info
->dimen
[dim
].lower_bound
)
17261 && (dflt
= lower_bound_default ()) != -1
17262 && tree_to_shwi (info
->dimen
[dim
].lower_bound
) == dflt
)
17265 add_descr_info_field (subrange_die
, DW_AT_lower_bound
,
17266 info
->dimen
[dim
].lower_bound
,
17269 if (info
->dimen
[dim
].upper_bound
)
17270 add_descr_info_field (subrange_die
, DW_AT_upper_bound
,
17271 info
->dimen
[dim
].upper_bound
,
17273 if (info
->dimen
[dim
].stride
)
17274 add_descr_info_field (subrange_die
, DW_AT_byte_stride
,
17275 info
->dimen
[dim
].stride
,
17279 gen_type_die (info
->element_type
, context_die
);
17280 add_type_attribute (array_die
, info
->element_type
, 0, 0, context_die
);
17282 if (get_AT (array_die
, DW_AT_name
))
17283 add_pubtype (type
, array_die
);
17288 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
17290 tree origin
= decl_ultimate_origin (decl
);
17291 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
17293 if (origin
!= NULL
)
17294 add_abstract_origin_attribute (decl_die
, origin
);
17297 add_name_and_src_coords_attributes (decl_die
, decl
);
17298 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
17299 0, 0, context_die
);
17302 if (DECL_ABSTRACT (decl
))
17303 equate_decl_number_to_die (decl
, decl_die
);
17305 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
17309 /* Walk through the list of incomplete types again, trying once more to
17310 emit full debugging info for them. */
17313 retry_incomplete_types (void)
17317 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
17318 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
17319 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
17322 /* Determine what tag to use for a record type. */
17324 static enum dwarf_tag
17325 record_type_tag (tree type
)
17327 if (! lang_hooks
.types
.classify_record
)
17328 return DW_TAG_structure_type
;
17330 switch (lang_hooks
.types
.classify_record (type
))
17332 case RECORD_IS_STRUCT
:
17333 return DW_TAG_structure_type
;
17335 case RECORD_IS_CLASS
:
17336 return DW_TAG_class_type
;
17338 case RECORD_IS_INTERFACE
:
17339 if (dwarf_version
>= 3 || !dwarf_strict
)
17340 return DW_TAG_interface_type
;
17341 return DW_TAG_structure_type
;
17344 gcc_unreachable ();
17348 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17349 include all of the information about the enumeration values also. Each
17350 enumerated type name/value is listed as a child of the enumerated type
17354 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
17356 dw_die_ref type_die
= lookup_type_die (type
);
17358 if (type_die
== NULL
)
17360 type_die
= new_die (DW_TAG_enumeration_type
,
17361 scope_die_for (type
, context_die
), type
);
17362 equate_type_number_to_die (type
, type_die
);
17363 add_name_attribute (type_die
, type_tag (type
));
17364 if (dwarf_version
>= 4 || !dwarf_strict
)
17366 if (ENUM_IS_SCOPED (type
))
17367 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
17368 if (ENUM_IS_OPAQUE (type
))
17369 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17372 else if (! TYPE_SIZE (type
))
17375 remove_AT (type_die
, DW_AT_declaration
);
17377 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17378 given enum type is incomplete, do not generate the DW_AT_byte_size
17379 attribute or the DW_AT_element_list attribute. */
17380 if (TYPE_SIZE (type
))
17384 TREE_ASM_WRITTEN (type
) = 1;
17385 add_byte_size_attribute (type_die
, type
);
17386 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
17388 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
17389 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
17392 /* If the first reference to this type was as the return type of an
17393 inline function, then it may not have a parent. Fix this now. */
17394 if (type_die
->die_parent
== NULL
)
17395 add_child_die (scope_die_for (type
, context_die
), type_die
);
17397 for (link
= TYPE_VALUES (type
);
17398 link
!= NULL
; link
= TREE_CHAIN (link
))
17400 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
17401 tree value
= TREE_VALUE (link
);
17403 add_name_attribute (enum_die
,
17404 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
17406 if (TREE_CODE (value
) == CONST_DECL
)
17407 value
= DECL_INITIAL (value
);
17409 if (simple_type_size_in_bits (TREE_TYPE (value
))
17410 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
17411 /* DWARF2 does not provide a way of indicating whether or
17412 not enumeration constants are signed or unsigned. GDB
17413 always assumes the values are signed, so we output all
17414 values as if they were signed. That means that
17415 enumeration constants with very large unsigned values
17416 will appear to have negative values in the debugger.
17418 TODO: the above comment is wrong, DWARF2 does provide
17419 DW_FORM_sdata/DW_FORM_udata to represent signed/unsigned data.
17420 This should be re-worked to use correct signed/unsigned
17421 int/double tags for all cases, instead of always treating as
17423 add_AT_int (enum_die
, DW_AT_const_value
, TREE_INT_CST_LOW (value
));
17425 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
17427 add_AT_double (enum_die
, DW_AT_const_value
,
17428 TREE_INT_CST_HIGH (value
), TREE_INT_CST_LOW (value
));
17431 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
17432 if (TYPE_ARTIFICIAL (type
))
17433 add_AT_flag (type_die
, DW_AT_artificial
, 1);
17436 add_AT_flag (type_die
, DW_AT_declaration
, 1);
17438 add_pubtype (type
, type_die
);
17443 /* Generate a DIE to represent either a real live formal parameter decl or to
17444 represent just the type of some formal parameter position in some function
17447 Note that this routine is a bit unusual because its argument may be a
17448 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17449 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17450 node. If it's the former then this function is being called to output a
17451 DIE to represent a formal parameter object (or some inlining thereof). If
17452 it's the latter, then this function is only being called to output a
17453 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17454 argument type of some subprogram type.
17455 If EMIT_NAME_P is true, name and source coordinate attributes
17459 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
17460 dw_die_ref context_die
)
17462 tree node_or_origin
= node
? node
: origin
;
17463 tree ultimate_origin
;
17464 dw_die_ref parm_die
17465 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
17467 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
17469 case tcc_declaration
:
17470 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
17471 if (node
|| ultimate_origin
)
17472 origin
= ultimate_origin
;
17473 if (origin
!= NULL
)
17474 add_abstract_origin_attribute (parm_die
, origin
);
17475 else if (emit_name_p
)
17476 add_name_and_src_coords_attributes (parm_die
, node
);
17478 || (! DECL_ABSTRACT (node_or_origin
)
17479 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
17480 decl_function_context
17481 (node_or_origin
))))
17483 tree type
= TREE_TYPE (node_or_origin
);
17484 if (decl_by_reference_p (node_or_origin
))
17485 add_type_attribute (parm_die
, TREE_TYPE (type
), 0, 0,
17488 add_type_attribute (parm_die
, type
,
17489 TREE_READONLY (node_or_origin
),
17490 TREE_THIS_VOLATILE (node_or_origin
),
17493 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
17494 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17496 if (node
&& node
!= origin
)
17497 equate_decl_number_to_die (node
, parm_die
);
17498 if (! DECL_ABSTRACT (node_or_origin
))
17499 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
17500 node
== NULL
, DW_AT_location
);
17505 /* We were called with some kind of a ..._TYPE node. */
17506 add_type_attribute (parm_die
, node_or_origin
, 0, 0, context_die
);
17510 gcc_unreachable ();
17516 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17517 children DW_TAG_formal_parameter DIEs representing the arguments of the
17520 PARM_PACK must be a function parameter pack.
17521 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17522 must point to the subsequent arguments of the function PACK_ARG belongs to.
17523 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17524 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17525 following the last one for which a DIE was generated. */
17528 gen_formal_parameter_pack_die (tree parm_pack
,
17530 dw_die_ref subr_die
,
17534 dw_die_ref parm_pack_die
;
17536 gcc_assert (parm_pack
17537 && lang_hooks
.function_parameter_pack_p (parm_pack
)
17540 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
17541 add_src_coords_attributes (parm_pack_die
, parm_pack
);
17543 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
17545 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
17548 gen_formal_parameter_die (arg
, NULL
,
17549 false /* Don't emit name attribute. */,
17554 return parm_pack_die
;
17557 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17558 at the end of an (ANSI prototyped) formal parameters list. */
17561 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
17563 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
17566 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17567 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17568 parameters as specified in some function type specification (except for
17569 those which appear as part of a function *definition*). */
17572 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
17575 tree formal_type
= NULL
;
17576 tree first_parm_type
;
17579 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
17581 arg
= DECL_ARGUMENTS (function_or_method_type
);
17582 function_or_method_type
= TREE_TYPE (function_or_method_type
);
17587 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
17589 /* Make our first pass over the list of formal parameter types and output a
17590 DW_TAG_formal_parameter DIE for each one. */
17591 for (link
= first_parm_type
; link
; )
17593 dw_die_ref parm_die
;
17595 formal_type
= TREE_VALUE (link
);
17596 if (formal_type
== void_type_node
)
17599 /* Output a (nameless) DIE to represent the formal parameter itself. */
17600 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
17601 true /* Emit name attribute. */,
17603 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
17604 && link
== first_parm_type
)
17606 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17607 if (dwarf_version
>= 3 || !dwarf_strict
)
17608 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
17610 else if (arg
&& DECL_ARTIFICIAL (arg
))
17611 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
17613 link
= TREE_CHAIN (link
);
17615 arg
= DECL_CHAIN (arg
);
17618 /* If this function type has an ellipsis, add a
17619 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
17620 if (formal_type
!= void_type_node
)
17621 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
17623 /* Make our second (and final) pass over the list of formal parameter types
17624 and output DIEs to represent those types (as necessary). */
17625 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
17626 link
&& TREE_VALUE (link
);
17627 link
= TREE_CHAIN (link
))
17628 gen_type_die (TREE_VALUE (link
), context_die
);
17631 /* We want to generate the DIE for TYPE so that we can generate the
17632 die for MEMBER, which has been defined; we will need to refer back
17633 to the member declaration nested within TYPE. If we're trying to
17634 generate minimal debug info for TYPE, processing TYPE won't do the
17635 trick; we need to attach the member declaration by hand. */
17638 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
17640 gen_type_die (type
, context_die
);
17642 /* If we're trying to avoid duplicate debug info, we may not have
17643 emitted the member decl for this function. Emit it now. */
17644 if (TYPE_STUB_DECL (type
)
17645 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
17646 && ! lookup_decl_die (member
))
17648 dw_die_ref type_die
;
17649 gcc_assert (!decl_ultimate_origin (member
));
17651 push_decl_scope (type
);
17652 type_die
= lookup_type_die_strip_naming_typedef (type
);
17653 if (TREE_CODE (member
) == FUNCTION_DECL
)
17654 gen_subprogram_die (member
, type_die
);
17655 else if (TREE_CODE (member
) == FIELD_DECL
)
17657 /* Ignore the nameless fields that are used to skip bits but handle
17658 C++ anonymous unions and structs. */
17659 if (DECL_NAME (member
) != NULL_TREE
17660 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
17661 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
17663 gen_type_die (member_declared_type (member
), type_die
);
17664 gen_field_die (member
, type_die
);
17668 gen_variable_die (member
, NULL_TREE
, type_die
);
17674 /* Forward declare these functions, because they are mutually recursive
17675 with their set_block_* pairing functions. */
17676 static void set_decl_origin_self (tree
);
17677 static void set_decl_abstract_flags (tree
, int);
17679 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
17680 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
17681 that it points to the node itself, thus indicating that the node is its
17682 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
17683 the given node is NULL, recursively descend the decl/block tree which
17684 it is the root of, and for each other ..._DECL or BLOCK node contained
17685 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
17686 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
17687 values to point to themselves. */
17690 set_block_origin_self (tree stmt
)
17692 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
17694 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
17699 for (local_decl
= BLOCK_VARS (stmt
);
17700 local_decl
!= NULL_TREE
;
17701 local_decl
= DECL_CHAIN (local_decl
))
17702 if (! DECL_EXTERNAL (local_decl
))
17703 set_decl_origin_self (local_decl
); /* Potential recursion. */
17709 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17710 subblock
!= NULL_TREE
;
17711 subblock
= BLOCK_CHAIN (subblock
))
17712 set_block_origin_self (subblock
); /* Recurse. */
17717 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
17718 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
17719 node to so that it points to the node itself, thus indicating that the
17720 node represents its own (abstract) origin. Additionally, if the
17721 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
17722 the decl/block tree of which the given node is the root of, and for
17723 each other ..._DECL or BLOCK node contained therein whose
17724 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
17725 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
17726 point to themselves. */
17729 set_decl_origin_self (tree decl
)
17731 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
17733 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
17734 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17738 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17739 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
17740 if (DECL_INITIAL (decl
) != NULL_TREE
17741 && DECL_INITIAL (decl
) != error_mark_node
)
17742 set_block_origin_self (DECL_INITIAL (decl
));
17747 /* Given a pointer to some BLOCK node, and a boolean value to set the
17748 "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
17749 the given block, and for all local decls and all local sub-blocks
17750 (recursively) which are contained therein. */
17753 set_block_abstract_flags (tree stmt
, int setting
)
17759 BLOCK_ABSTRACT (stmt
) = setting
;
17761 for (local_decl
= BLOCK_VARS (stmt
);
17762 local_decl
!= NULL_TREE
;
17763 local_decl
= DECL_CHAIN (local_decl
))
17764 if (! DECL_EXTERNAL (local_decl
))
17765 set_decl_abstract_flags (local_decl
, setting
);
17767 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
17769 local_decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
17770 if ((TREE_CODE (local_decl
) == VAR_DECL
&& !TREE_STATIC (local_decl
))
17771 || TREE_CODE (local_decl
) == PARM_DECL
)
17772 set_decl_abstract_flags (local_decl
, setting
);
17775 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
17776 subblock
!= NULL_TREE
;
17777 subblock
= BLOCK_CHAIN (subblock
))
17778 set_block_abstract_flags (subblock
, setting
);
17781 /* Given a pointer to some ..._DECL node, and a boolean value to set the
17782 "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
17783 given decl, and (in the case where the decl is a FUNCTION_DECL) also
17784 set the abstract flags for all of the parameters, local vars, local
17785 blocks and sub-blocks (recursively) to the same setting. */
17788 set_decl_abstract_flags (tree decl
, int setting
)
17790 DECL_ABSTRACT (decl
) = setting
;
17791 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17795 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
17796 DECL_ABSTRACT (arg
) = setting
;
17797 if (DECL_INITIAL (decl
) != NULL_TREE
17798 && DECL_INITIAL (decl
) != error_mark_node
)
17799 set_block_abstract_flags (DECL_INITIAL (decl
), setting
);
17803 /* Generate the DWARF2 info for the "abstract" instance of a function which we
17804 may later generate inlined and/or out-of-line instances of. */
17807 dwarf2out_abstract_function (tree decl
)
17809 dw_die_ref old_die
;
17813 htab_t old_decl_loc_table
;
17814 htab_t old_cached_dw_loc_list_table
;
17815 int old_call_site_count
, old_tail_call_site_count
;
17816 struct call_arg_loc_node
*old_call_arg_locations
;
17818 /* Make sure we have the actual abstract inline, not a clone. */
17819 decl
= DECL_ORIGIN (decl
);
17821 old_die
= lookup_decl_die (decl
);
17822 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
17823 /* We've already generated the abstract instance. */
17826 /* We can be called while recursively when seeing block defining inlined subroutine
17827 DIE. Be sure to not clobber the outer location table nor use it or we would
17828 get locations in abstract instantces. */
17829 old_decl_loc_table
= decl_loc_table
;
17830 decl_loc_table
= NULL
;
17831 old_cached_dw_loc_list_table
= cached_dw_loc_list_table
;
17832 cached_dw_loc_list_table
= NULL
;
17833 old_call_arg_locations
= call_arg_locations
;
17834 call_arg_locations
= NULL
;
17835 old_call_site_count
= call_site_count
;
17836 call_site_count
= -1;
17837 old_tail_call_site_count
= tail_call_site_count
;
17838 tail_call_site_count
= -1;
17840 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
17841 we don't get confused by DECL_ABSTRACT. */
17842 if (debug_info_level
> DINFO_LEVEL_TERSE
)
17844 context
= decl_class_context (decl
);
17846 gen_type_die_for_member
17847 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die ());
17850 /* Pretend we've just finished compiling this function. */
17851 save_fn
= current_function_decl
;
17852 current_function_decl
= decl
;
17854 was_abstract
= DECL_ABSTRACT (decl
);
17855 set_decl_abstract_flags (decl
, 1);
17856 dwarf2out_decl (decl
);
17857 if (! was_abstract
)
17858 set_decl_abstract_flags (decl
, 0);
17860 current_function_decl
= save_fn
;
17861 decl_loc_table
= old_decl_loc_table
;
17862 cached_dw_loc_list_table
= old_cached_dw_loc_list_table
;
17863 call_arg_locations
= old_call_arg_locations
;
17864 call_site_count
= old_call_site_count
;
17865 tail_call_site_count
= old_tail_call_site_count
;
17868 /* Helper function of premark_used_types() which gets called through
17871 Marks the DIE of a given type in *SLOT as perennial, so it never gets
17872 marked as unused by prune_unused_types. */
17875 premark_used_types_helper (void **slot
, void *data ATTRIBUTE_UNUSED
)
17880 type
= (tree
) *slot
;
17881 die
= lookup_type_die (type
);
17883 die
->die_perennial_p
= 1;
17887 /* Helper function of premark_types_used_by_global_vars which gets called
17888 through htab_traverse.
17890 Marks the DIE of a given type in *SLOT as perennial, so it never gets
17891 marked as unused by prune_unused_types. The DIE of the type is marked
17892 only if the global variable using the type will actually be emitted. */
17895 premark_types_used_by_global_vars_helper (void **slot
,
17896 void *data ATTRIBUTE_UNUSED
)
17898 struct types_used_by_vars_entry
*entry
;
17901 entry
= (struct types_used_by_vars_entry
*) *slot
;
17902 gcc_assert (entry
->type
!= NULL
17903 && entry
->var_decl
!= NULL
);
17904 die
= lookup_type_die (entry
->type
);
17907 /* Ask cgraph if the global variable really is to be emitted.
17908 If yes, then we'll keep the DIE of ENTRY->TYPE. */
17909 varpool_node
*node
= varpool_get_node (entry
->var_decl
);
17910 if (node
&& node
->definition
)
17912 die
->die_perennial_p
= 1;
17913 /* Keep the parent DIEs as well. */
17914 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
17915 die
->die_perennial_p
= 1;
17921 /* Mark all members of used_types_hash as perennial. */
17924 premark_used_types (struct function
*fun
)
17926 if (fun
&& fun
->used_types_hash
)
17927 htab_traverse (fun
->used_types_hash
, premark_used_types_helper
, NULL
);
17930 /* Mark all members of types_used_by_vars_entry as perennial. */
17933 premark_types_used_by_global_vars (void)
17935 if (types_used_by_vars_hash
)
17936 htab_traverse (types_used_by_vars_hash
,
17937 premark_types_used_by_global_vars_helper
, NULL
);
17940 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
17941 for CA_LOC call arg loc node. */
17944 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
17945 struct call_arg_loc_node
*ca_loc
)
17947 dw_die_ref stmt_die
= NULL
, die
;
17948 tree block
= ca_loc
->block
;
17951 && block
!= DECL_INITIAL (decl
)
17952 && TREE_CODE (block
) == BLOCK
)
17954 if (block_map
.length () > BLOCK_NUMBER (block
))
17955 stmt_die
= block_map
[BLOCK_NUMBER (block
)];
17958 block
= BLOCK_SUPERCONTEXT (block
);
17960 if (stmt_die
== NULL
)
17961 stmt_die
= subr_die
;
17962 die
= new_die (DW_TAG_GNU_call_site
, stmt_die
, NULL_TREE
);
17963 add_AT_lbl_id (die
, DW_AT_low_pc
, ca_loc
->label
);
17964 if (ca_loc
->tail_call_p
)
17965 add_AT_flag (die
, DW_AT_GNU_tail_call
, 1);
17966 if (ca_loc
->symbol_ref
)
17968 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
17970 add_AT_die_ref (die
, DW_AT_abstract_origin
, tdie
);
17972 add_AT_addr (die
, DW_AT_abstract_origin
, ca_loc
->symbol_ref
, false);
17977 /* Generate a DIE to represent a declared function (either file-scope or
17981 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
17983 tree origin
= decl_ultimate_origin (decl
);
17984 dw_die_ref subr_die
;
17986 dw_die_ref old_die
= lookup_decl_die (decl
);
17987 int declaration
= (current_function_decl
!= decl
17988 || class_or_namespace_scope_p (context_die
));
17990 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
17992 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
17993 started to generate the abstract instance of an inline, decided to output
17994 its containing class, and proceeded to emit the declaration of the inline
17995 from the member list for the class. If so, DECLARATION takes priority;
17996 we'll get back to the abstract instance when done with the class. */
17998 /* The class-scope declaration DIE must be the primary DIE. */
17999 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
18002 gcc_assert (!old_die
);
18005 /* Now that the C++ front end lazily declares artificial member fns, we
18006 might need to retrofit the declaration into its class. */
18007 if (!declaration
&& !origin
&& !old_die
18008 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
18009 && !class_or_namespace_scope_p (context_die
)
18010 && debug_info_level
> DINFO_LEVEL_TERSE
)
18011 old_die
= force_decl_die (decl
);
18013 if (origin
!= NULL
)
18015 gcc_assert (!declaration
|| local_scope_p (context_die
));
18017 /* Fixup die_parent for the abstract instance of a nested
18018 inline function. */
18019 if (old_die
&& old_die
->die_parent
== NULL
)
18020 add_child_die (context_die
, old_die
);
18022 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18023 add_abstract_origin_attribute (subr_die
, origin
);
18024 /* This is where the actual code for a cloned function is.
18025 Let's emit linkage name attribute for it. This helps
18026 debuggers to e.g, set breakpoints into
18027 constructors/destructors when the user asks "break
18029 add_linkage_name (subr_die
, decl
);
18033 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18034 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18036 if (!get_AT_flag (old_die
, DW_AT_declaration
)
18037 /* We can have a normal definition following an inline one in the
18038 case of redefinition of GNU C extern inlines.
18039 It seems reasonable to use AT_specification in this case. */
18040 && !get_AT (old_die
, DW_AT_inline
))
18042 /* Detect and ignore this case, where we are trying to output
18043 something we have already output. */
18047 /* If the definition comes from the same place as the declaration,
18048 maybe use the old DIE. We always want the DIE for this function
18049 that has the *_pc attributes to be under comp_unit_die so the
18050 debugger can find it. We also need to do this for abstract
18051 instances of inlines, since the spec requires the out-of-line copy
18052 to have the same parent. For local class methods, this doesn't
18053 apply; we just use the old DIE. */
18054 if ((is_cu_die (old_die
->die_parent
) || context_die
== NULL
)
18055 && (DECL_ARTIFICIAL (decl
)
18056 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
18057 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
18058 == (unsigned) s
.line
))))
18060 subr_die
= old_die
;
18062 /* Clear out the declaration attribute and the formal parameters.
18063 Do not remove all children, because it is possible that this
18064 declaration die was forced using force_decl_die(). In such
18065 cases die that forced declaration die (e.g. TAG_imported_module)
18066 is one of the children that we do not want to remove. */
18067 remove_AT (subr_die
, DW_AT_declaration
);
18068 remove_AT (subr_die
, DW_AT_object_pointer
);
18069 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
18073 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18074 add_AT_specification (subr_die
, old_die
);
18075 add_pubname (decl
, subr_die
);
18076 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18077 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
18078 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18079 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
18081 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
18082 emit the real type on the definition die. */
18083 if (is_cxx() && debug_info_level
> DINFO_LEVEL_TERSE
)
18085 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
18086 if (die
== auto_die
|| die
== decltype_auto_die
)
18087 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18088 0, 0, context_die
);
18094 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18096 if (TREE_PUBLIC (decl
))
18097 add_AT_flag (subr_die
, DW_AT_external
, 1);
18099 add_name_and_src_coords_attributes (subr_die
, decl
);
18100 add_pubname (decl
, subr_die
);
18101 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18103 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
18104 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18105 0, 0, context_die
);
18108 add_pure_or_virtual_attribute (subr_die
, decl
);
18109 if (DECL_ARTIFICIAL (decl
))
18110 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18112 add_accessibility_attribute (subr_die
, decl
);
18117 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18119 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
18121 /* If this is an explicit function declaration then generate
18122 a DW_AT_explicit attribute. */
18123 if (lang_hooks
.decls
.function_decl_explicit_p (decl
)
18124 && (dwarf_version
>= 3 || !dwarf_strict
))
18125 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
18127 /* The first time we see a member function, it is in the context of
18128 the class to which it belongs. We make sure of this by emitting
18129 the class first. The next time is the definition, which is
18130 handled above. The two may come from the same source text.
18132 Note that force_decl_die() forces function declaration die. It is
18133 later reused to represent definition. */
18134 equate_decl_number_to_die (decl
, subr_die
);
18137 else if (DECL_ABSTRACT (decl
))
18139 if (DECL_DECLARED_INLINE_P (decl
))
18141 if (cgraph_function_possibly_inlined_p (decl
))
18142 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
18144 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
18148 if (cgraph_function_possibly_inlined_p (decl
))
18149 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
18151 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
18154 if (DECL_DECLARED_INLINE_P (decl
)
18155 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
18156 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18158 equate_decl_number_to_die (decl
, subr_die
);
18160 else if (!DECL_EXTERNAL (decl
))
18162 HOST_WIDE_INT cfa_fb_offset
;
18163 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
18165 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18166 equate_decl_number_to_die (decl
, subr_die
);
18168 gcc_checking_assert (fun
);
18169 if (!flag_reorder_blocks_and_partition
)
18171 dw_fde_ref fde
= fun
->fde
;
18172 if (fde
->dw_fde_begin
)
18174 /* We have already generated the labels. */
18175 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18176 fde
->dw_fde_end
, false);
18180 /* Create start/end labels and add the range. */
18181 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
18182 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
18183 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
18184 current_function_funcdef_no
);
18185 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
18186 current_function_funcdef_no
);
18187 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
18191 #if VMS_DEBUGGING_INFO
18192 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18193 Section 2.3 Prologue and Epilogue Attributes:
18194 When a breakpoint is set on entry to a function, it is generally
18195 desirable for execution to be suspended, not on the very first
18196 instruction of the function, but rather at a point after the
18197 function's frame has been set up, after any language defined local
18198 declaration processing has been completed, and before execution of
18199 the first statement of the function begins. Debuggers generally
18200 cannot properly determine where this point is. Similarly for a
18201 breakpoint set on exit from a function. The prologue and epilogue
18202 attributes allow a compiler to communicate the location(s) to use. */
18205 if (fde
->dw_fde_vms_end_prologue
)
18206 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
18207 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
18209 if (fde
->dw_fde_vms_begin_epilogue
)
18210 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
18211 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
18218 /* Generate pubnames entries for the split function code ranges. */
18219 dw_fde_ref fde
= fun
->fde
;
18221 if (fde
->dw_fde_second_begin
)
18223 if (dwarf_version
>= 3 || !dwarf_strict
)
18225 /* We should use ranges for non-contiguous code section
18226 addresses. Use the actual code range for the initial
18227 section, since the HOT/COLD labels might precede an
18228 alignment offset. */
18229 bool range_list_added
= false;
18230 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
18231 fde
->dw_fde_end
, &range_list_added
,
18233 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
18234 fde
->dw_fde_second_end
,
18235 &range_list_added
, false);
18236 if (range_list_added
)
18241 /* There is no real support in DW2 for this .. so we make
18242 a work-around. First, emit the pub name for the segment
18243 containing the function label. Then make and emit a
18244 simplified subprogram DIE for the second segment with the
18245 name pre-fixed by __hot/cold_sect_of_. We use the same
18246 linkage name for the second die so that gdb will find both
18247 sections when given "b foo". */
18248 const char *name
= NULL
;
18249 tree decl_name
= DECL_NAME (decl
);
18250 dw_die_ref seg_die
;
18252 /* Do the 'primary' section. */
18253 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
18254 fde
->dw_fde_end
, false);
18256 /* Build a minimal DIE for the secondary section. */
18257 seg_die
= new_die (DW_TAG_subprogram
,
18258 subr_die
->die_parent
, decl
);
18260 if (TREE_PUBLIC (decl
))
18261 add_AT_flag (seg_die
, DW_AT_external
, 1);
18263 if (decl_name
!= NULL
18264 && IDENTIFIER_POINTER (decl_name
) != NULL
)
18266 name
= dwarf2_name (decl
, 1);
18267 if (! DECL_ARTIFICIAL (decl
))
18268 add_src_coords_attributes (seg_die
, decl
);
18270 add_linkage_name (seg_die
, decl
);
18272 gcc_assert (name
!= NULL
);
18273 add_pure_or_virtual_attribute (seg_die
, decl
);
18274 if (DECL_ARTIFICIAL (decl
))
18275 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
18277 name
= concat ("__second_sect_of_", name
, NULL
);
18278 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
18279 fde
->dw_fde_second_end
, false);
18280 add_name_attribute (seg_die
, name
);
18281 if (want_pubnames ())
18282 add_pubname_string (name
, seg_die
);
18286 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
18290 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
18292 /* We define the "frame base" as the function's CFA. This is more
18293 convenient for several reasons: (1) It's stable across the prologue
18294 and epilogue, which makes it better than just a frame pointer,
18295 (2) With dwarf3, there exists a one-byte encoding that allows us
18296 to reference the .debug_frame data by proxy, but failing that,
18297 (3) We can at least reuse the code inspection and interpretation
18298 code that determines the CFA position at various points in the
18300 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
18302 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
18303 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
18307 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
18308 if (list
->dw_loc_next
)
18309 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
18311 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
18314 /* Compute a displacement from the "steady-state frame pointer" to
18315 the CFA. The former is what all stack slots and argument slots
18316 will reference in the rtl; the latter is what we've told the
18317 debugger about. We'll need to adjust all frame_base references
18318 by this displacement. */
18319 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
18321 if (fun
->static_chain_decl
)
18322 add_AT_location_description (subr_die
, DW_AT_static_link
,
18323 loc_list_from_tree (fun
->static_chain_decl
, 2));
18326 /* Generate child dies for template paramaters. */
18327 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18328 gen_generic_params_dies (decl
);
18330 /* Now output descriptions of the arguments for this function. This gets
18331 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18332 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18333 `...' at the end of the formal parameter list. In order to find out if
18334 there was a trailing ellipsis or not, we must instead look at the type
18335 associated with the FUNCTION_DECL. This will be a node of type
18336 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18337 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18338 an ellipsis at the end. */
18340 /* In the case where we are describing a mere function declaration, all we
18341 need to do here (and all we *can* do here) is to describe the *types* of
18342 its formal parameters. */
18343 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
18345 else if (declaration
)
18346 gen_formal_types_die (decl
, subr_die
);
18349 /* Generate DIEs to represent all known formal parameters. */
18350 tree parm
= DECL_ARGUMENTS (decl
);
18351 tree generic_decl
= lang_hooks
.decls
.get_generic_function_decl (decl
);
18352 tree generic_decl_parm
= generic_decl
18353 ? DECL_ARGUMENTS (generic_decl
)
18356 /* Now we want to walk the list of parameters of the function and
18357 emit their relevant DIEs.
18359 We consider the case of DECL being an instance of a generic function
18360 as well as it being a normal function.
18362 If DECL is an instance of a generic function we walk the
18363 parameters of the generic function declaration _and_ the parameters of
18364 DECL itself. This is useful because we want to emit specific DIEs for
18365 function parameter packs and those are declared as part of the
18366 generic function declaration. In that particular case,
18367 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18368 That DIE has children DIEs representing the set of arguments
18369 of the pack. Note that the set of pack arguments can be empty.
18370 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18373 Otherwise, we just consider the parameters of DECL. */
18374 while (generic_decl_parm
|| parm
)
18376 if (generic_decl_parm
18377 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
18378 gen_formal_parameter_pack_die (generic_decl_parm
,
18383 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, subr_die
);
18385 if (parm
== DECL_ARGUMENTS (decl
)
18386 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
18388 && (dwarf_version
>= 3 || !dwarf_strict
))
18389 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
18391 parm
= DECL_CHAIN (parm
);
18394 if (generic_decl_parm
)
18395 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
18398 /* Decide whether we need an unspecified_parameters DIE at the end.
18399 There are 2 more cases to do this for: 1) the ansi ... declaration -
18400 this is detectable when the end of the arg list is not a
18401 void_type_node 2) an unprototyped function declaration (not a
18402 definition). This just means that we have no info about the
18403 parameters at all. */
18404 if (prototype_p (TREE_TYPE (decl
)))
18406 /* This is the prototyped case, check for.... */
18407 if (stdarg_p (TREE_TYPE (decl
)))
18408 gen_unspecified_parameters_die (decl
, subr_die
);
18410 else if (DECL_INITIAL (decl
) == NULL_TREE
)
18411 gen_unspecified_parameters_die (decl
, subr_die
);
18414 /* Output Dwarf info for all of the stuff within the body of the function
18415 (if it has one - it may be just a declaration). */
18416 outer_scope
= DECL_INITIAL (decl
);
18418 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18419 a function. This BLOCK actually represents the outermost binding contour
18420 for the function, i.e. the contour in which the function's formal
18421 parameters and labels get declared. Curiously, it appears that the front
18422 end doesn't actually put the PARM_DECL nodes for the current function onto
18423 the BLOCK_VARS list for this outer scope, but are strung off of the
18424 DECL_ARGUMENTS list for the function instead.
18426 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18427 the LABEL_DECL nodes for the function however, and we output DWARF info
18428 for those in decls_for_scope. Just within the `outer_scope' there will be
18429 a BLOCK node representing the function's outermost pair of curly braces,
18430 and any blocks used for the base and member initializers of a C++
18431 constructor function. */
18432 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
18434 int call_site_note_count
= 0;
18435 int tail_call_site_note_count
= 0;
18437 /* Emit a DW_TAG_variable DIE for a named return value. */
18438 if (DECL_NAME (DECL_RESULT (decl
)))
18439 gen_decl_die (DECL_RESULT (decl
), NULL
, subr_die
);
18441 current_function_has_inlines
= 0;
18442 decls_for_scope (outer_scope
, subr_die
, 0);
18444 if (call_arg_locations
&& !dwarf_strict
)
18446 struct call_arg_loc_node
*ca_loc
;
18447 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
18449 dw_die_ref die
= NULL
;
18450 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
18453 for (arg
= NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
);
18454 arg
; arg
= next_arg
)
18456 dw_loc_descr_ref reg
, val
;
18457 enum machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
18458 dw_die_ref cdie
, tdie
= NULL
;
18460 next_arg
= XEXP (arg
, 1);
18461 if (REG_P (XEXP (XEXP (arg
, 0), 0))
18463 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
18464 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
18465 && REGNO (XEXP (XEXP (arg
, 0), 0))
18466 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
18467 next_arg
= XEXP (next_arg
, 1);
18468 if (mode
== VOIDmode
)
18470 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
18471 if (mode
== VOIDmode
)
18472 mode
= GET_MODE (XEXP (arg
, 0));
18474 if (mode
== VOIDmode
|| mode
== BLKmode
)
18476 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
18478 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18479 tloc
= XEXP (XEXP (arg
, 0), 1);
18482 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
18483 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
18485 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
18486 tlocc
= XEXP (XEXP (arg
, 0), 1);
18490 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
18491 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
18492 VAR_INIT_STATUS_INITIALIZED
);
18493 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
18495 rtx mem
= XEXP (XEXP (arg
, 0), 0);
18496 reg
= mem_loc_descriptor (XEXP (mem
, 0),
18497 get_address_mode (mem
),
18499 VAR_INIT_STATUS_INITIALIZED
);
18501 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
18502 == DEBUG_PARAMETER_REF
)
18505 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
18506 tdie
= lookup_decl_die (tdecl
);
18513 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
18514 != DEBUG_PARAMETER_REF
)
18516 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
18518 VAR_INIT_STATUS_INITIALIZED
);
18522 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18523 cdie
= new_die (DW_TAG_GNU_call_site_parameter
, die
,
18526 add_AT_loc (cdie
, DW_AT_location
, reg
);
18527 else if (tdie
!= NULL
)
18528 add_AT_die_ref (cdie
, DW_AT_abstract_origin
, tdie
);
18529 add_AT_loc (cdie
, DW_AT_GNU_call_site_value
, val
);
18530 if (next_arg
!= XEXP (arg
, 1))
18532 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
18533 if (mode
== VOIDmode
)
18534 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
18535 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
18538 VAR_INIT_STATUS_INITIALIZED
);
18540 add_AT_loc (cdie
, DW_AT_GNU_call_site_data_value
, val
);
18544 && (ca_loc
->symbol_ref
|| tloc
))
18545 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
18546 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
18548 dw_loc_descr_ref tval
= NULL
;
18550 if (tloc
!= NULL_RTX
)
18551 tval
= mem_loc_descriptor (tloc
,
18552 GET_MODE (tloc
) == VOIDmode
18553 ? Pmode
: GET_MODE (tloc
),
18555 VAR_INIT_STATUS_INITIALIZED
);
18557 add_AT_loc (die
, DW_AT_GNU_call_site_target
, tval
);
18558 else if (tlocc
!= NULL_RTX
)
18560 tval
= mem_loc_descriptor (tlocc
,
18561 GET_MODE (tlocc
) == VOIDmode
18562 ? Pmode
: GET_MODE (tlocc
),
18564 VAR_INIT_STATUS_INITIALIZED
);
18566 add_AT_loc (die
, DW_AT_GNU_call_site_target_clobbered
,
18572 call_site_note_count
++;
18573 if (ca_loc
->tail_call_p
)
18574 tail_call_site_note_count
++;
18578 call_arg_locations
= NULL
;
18579 call_arg_loc_last
= NULL
;
18580 if (tail_call_site_count
>= 0
18581 && tail_call_site_count
== tail_call_site_note_count
18584 if (call_site_count
>= 0
18585 && call_site_count
== call_site_note_count
)
18586 add_AT_flag (subr_die
, DW_AT_GNU_all_call_sites
, 1);
18588 add_AT_flag (subr_die
, DW_AT_GNU_all_tail_call_sites
, 1);
18590 call_site_count
= -1;
18591 tail_call_site_count
= -1;
18594 if (subr_die
!= old_die
)
18595 /* Add the calling convention attribute if requested. */
18596 add_calling_convention_attribute (subr_die
, decl
);
18599 /* Returns a hash value for X (which really is a die_struct). */
18602 common_block_die_table_hash (const void *x
)
18604 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18605 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
18608 /* Return nonzero if decl_id and die_parent of die_struct X is the same
18609 as decl_id and die_parent of die_struct Y. */
18612 common_block_die_table_eq (const void *x
, const void *y
)
18614 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18615 const_dw_die_ref e
= (const_dw_die_ref
) y
;
18616 return d
->decl_id
== e
->decl_id
&& d
->die_parent
== e
->die_parent
;
18619 /* Generate a DIE to represent a declared data object.
18620 Either DECL or ORIGIN must be non-null. */
18623 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
18625 HOST_WIDE_INT off
= 0;
18627 tree decl_or_origin
= decl
? decl
: origin
;
18628 tree ultimate_origin
;
18629 dw_die_ref var_die
;
18630 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
18631 dw_die_ref origin_die
;
18632 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
18633 || class_or_namespace_scope_p (context_die
));
18634 bool specialization_p
= false;
18636 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
18637 if (decl
|| ultimate_origin
)
18638 origin
= ultimate_origin
;
18639 com_decl
= fortran_common (decl_or_origin
, &off
);
18641 /* Symbol in common gets emitted as a child of the common block, in the form
18642 of a data member. */
18645 dw_die_ref com_die
;
18646 dw_loc_list_ref loc
;
18647 die_node com_die_arg
;
18649 var_die
= lookup_decl_die (decl_or_origin
);
18652 if (get_AT (var_die
, DW_AT_location
) == NULL
)
18654 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2);
18659 /* Optimize the common case. */
18660 if (single_element_loc_list_p (loc
)
18661 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18662 && loc
->expr
->dw_loc_next
== NULL
18663 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
18666 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18667 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18668 = plus_constant (GET_MODE (x
), x
, off
);
18671 loc_list_plus_const (loc
, off
);
18673 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18674 remove_AT (var_die
, DW_AT_declaration
);
18680 if (common_block_die_table
== NULL
)
18681 common_block_die_table
18682 = htab_create_ggc (10, common_block_die_table_hash
,
18683 common_block_die_table_eq
, NULL
);
18685 com_die_arg
.decl_id
= DECL_UID (com_decl
);
18686 com_die_arg
.die_parent
= context_die
;
18687 com_die
= (dw_die_ref
) htab_find (common_block_die_table
, &com_die_arg
);
18688 loc
= loc_list_from_tree (com_decl
, 2);
18689 if (com_die
== NULL
)
18692 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
18695 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
18696 add_name_and_src_coords_attributes (com_die
, com_decl
);
18699 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18700 /* Avoid sharing the same loc descriptor between
18701 DW_TAG_common_block and DW_TAG_variable. */
18702 loc
= loc_list_from_tree (com_decl
, 2);
18704 else if (DECL_EXTERNAL (decl
))
18705 add_AT_flag (com_die
, DW_AT_declaration
, 1);
18706 if (want_pubnames ())
18707 add_pubname_string (cnam
, com_die
); /* ??? needed? */
18708 com_die
->decl_id
= DECL_UID (com_decl
);
18709 slot
= htab_find_slot (common_block_die_table
, com_die
, INSERT
);
18710 *slot
= (void *) com_die
;
18712 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
18714 add_AT_location_description (com_die
, DW_AT_location
, loc
);
18715 loc
= loc_list_from_tree (com_decl
, 2);
18716 remove_AT (com_die
, DW_AT_declaration
);
18718 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
18719 add_name_and_src_coords_attributes (var_die
, decl
);
18720 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
18721 TREE_THIS_VOLATILE (decl
), context_die
);
18722 add_AT_flag (var_die
, DW_AT_external
, 1);
18727 /* Optimize the common case. */
18728 if (single_element_loc_list_p (loc
)
18729 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18730 && loc
->expr
->dw_loc_next
== NULL
18731 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
18733 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
18734 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18735 = plus_constant (GET_MODE (x
), x
, off
);
18738 loc_list_plus_const (loc
, off
);
18740 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18742 else if (DECL_EXTERNAL (decl
))
18743 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18744 equate_decl_number_to_die (decl
, var_die
);
18748 /* If the compiler emitted a definition for the DECL declaration
18749 and if we already emitted a DIE for it, don't emit a second
18750 DIE for it again. Allow re-declarations of DECLs that are
18751 inside functions, though. */
18752 if (old_die
&& declaration
&& !local_scope_p (context_die
))
18755 /* For static data members, the declaration in the class is supposed
18756 to have DW_TAG_member tag; the specification should still be
18757 DW_TAG_variable referencing the DW_TAG_member DIE. */
18758 if (declaration
&& class_scope_p (context_die
))
18759 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
18761 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
18764 if (origin
!= NULL
)
18765 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
18767 /* Loop unrolling can create multiple blocks that refer to the same
18768 static variable, so we must test for the DW_AT_declaration flag.
18770 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
18771 copy decls and set the DECL_ABSTRACT flag on them instead of
18774 ??? Duplicated blocks have been rewritten to use .debug_ranges.
18776 ??? The declare_in_namespace support causes us to get two DIEs for one
18777 variable, both of which are declarations. We want to avoid considering
18778 one to be a specification, so we must test that this DIE is not a
18780 else if (old_die
&& TREE_STATIC (decl
) && ! declaration
18781 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
18783 /* This is a definition of a C++ class level static. */
18784 add_AT_specification (var_die
, old_die
);
18785 specialization_p
= true;
18786 if (DECL_NAME (decl
))
18788 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18789 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18791 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18792 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
18794 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18795 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
18797 if (old_die
->die_tag
== DW_TAG_member
)
18798 add_linkage_name (var_die
, decl
);
18802 add_name_and_src_coords_attributes (var_die
, decl
);
18804 if ((origin
== NULL
&& !specialization_p
)
18806 && !DECL_ABSTRACT (decl_or_origin
)
18807 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
18808 decl_function_context
18809 (decl_or_origin
))))
18811 tree type
= TREE_TYPE (decl_or_origin
);
18813 if (decl_by_reference_p (decl_or_origin
))
18814 add_type_attribute (var_die
, TREE_TYPE (type
), 0, 0, context_die
);
18816 add_type_attribute (var_die
, type
, TREE_READONLY (decl_or_origin
),
18817 TREE_THIS_VOLATILE (decl_or_origin
), context_die
);
18820 if (origin
== NULL
&& !specialization_p
)
18822 if (TREE_PUBLIC (decl
))
18823 add_AT_flag (var_die
, DW_AT_external
, 1);
18825 if (DECL_ARTIFICIAL (decl
))
18826 add_AT_flag (var_die
, DW_AT_artificial
, 1);
18828 add_accessibility_attribute (var_die
, decl
);
18832 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18834 if (decl
&& (DECL_ABSTRACT (decl
) || declaration
|| old_die
== NULL
))
18835 equate_decl_number_to_die (decl
, var_die
);
18838 && (! DECL_ABSTRACT (decl_or_origin
)
18839 /* Local static vars are shared between all clones/inlines,
18840 so emit DW_AT_location on the abstract DIE if DECL_RTL is
18842 || (TREE_CODE (decl_or_origin
) == VAR_DECL
18843 && TREE_STATIC (decl_or_origin
)
18844 && DECL_RTL_SET_P (decl_or_origin
)))
18845 /* When abstract origin already has DW_AT_location attribute, no need
18846 to add it again. */
18847 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
18849 if (TREE_CODE (decl_or_origin
) == VAR_DECL
&& TREE_STATIC (decl_or_origin
)
18850 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin
)))
18851 defer_location (decl_or_origin
, var_die
);
18853 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
18854 decl
== NULL
, DW_AT_location
);
18855 add_pubname (decl_or_origin
, var_die
);
18858 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
18861 /* Generate a DIE to represent a named constant. */
18864 gen_const_die (tree decl
, dw_die_ref context_die
)
18866 dw_die_ref const_die
;
18867 tree type
= TREE_TYPE (decl
);
18869 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
18870 add_name_and_src_coords_attributes (const_die
, decl
);
18871 add_type_attribute (const_die
, type
, 1, 0, context_die
);
18872 if (TREE_PUBLIC (decl
))
18873 add_AT_flag (const_die
, DW_AT_external
, 1);
18874 if (DECL_ARTIFICIAL (decl
))
18875 add_AT_flag (const_die
, DW_AT_artificial
, 1);
18876 tree_add_const_value_attribute_for_decl (const_die
, decl
);
18879 /* Generate a DIE to represent a label identifier. */
18882 gen_label_die (tree decl
, dw_die_ref context_die
)
18884 tree origin
= decl_ultimate_origin (decl
);
18885 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
18887 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
18889 if (origin
!= NULL
)
18890 add_abstract_origin_attribute (lbl_die
, origin
);
18892 add_name_and_src_coords_attributes (lbl_die
, decl
);
18894 if (DECL_ABSTRACT (decl
))
18895 equate_decl_number_to_die (decl
, lbl_die
);
18898 insn
= DECL_RTL_IF_SET (decl
);
18900 /* Deleted labels are programmer specified labels which have been
18901 eliminated because of various optimizations. We still emit them
18902 here so that it is possible to put breakpoints on them. */
18906 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
18908 /* When optimization is enabled (via -O) some parts of the compiler
18909 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
18910 represent source-level labels which were explicitly declared by
18911 the user. This really shouldn't be happening though, so catch
18912 it if it ever does happen. */
18913 gcc_assert (!INSN_DELETED_P (insn
));
18915 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
18916 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
18920 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
18921 && CODE_LABEL_NUMBER (insn
) != -1)
18923 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
18924 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
18929 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
18930 attributes to the DIE for a block STMT, to describe where the inlined
18931 function was called from. This is similar to add_src_coords_attributes. */
18934 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
18936 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
18938 if (dwarf_version
>= 3 || !dwarf_strict
)
18940 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
18941 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
18946 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
18947 Add low_pc and high_pc attributes to the DIE for a block STMT. */
18950 add_high_low_attributes (tree stmt
, dw_die_ref die
)
18952 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
18954 if (BLOCK_FRAGMENT_CHAIN (stmt
)
18955 && (dwarf_version
>= 3 || !dwarf_strict
))
18957 tree chain
, superblock
= NULL_TREE
;
18959 dw_attr_ref attr
= NULL
;
18961 if (inlined_function_outer_scope_p (stmt
))
18963 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
18964 BLOCK_NUMBER (stmt
));
18965 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
18968 /* Optimize duplicate .debug_ranges lists or even tails of
18969 lists. If this BLOCK has same ranges as its supercontext,
18970 lookup DW_AT_ranges attribute in the supercontext (and
18971 recursively so), verify that the ranges_table contains the
18972 right values and use it instead of adding a new .debug_range. */
18973 for (chain
= stmt
, pdie
= die
;
18974 BLOCK_SAME_RANGE (chain
);
18975 chain
= BLOCK_SUPERCONTEXT (chain
))
18977 dw_attr_ref new_attr
;
18979 pdie
= pdie
->die_parent
;
18982 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
18984 new_attr
= get_AT (pdie
, DW_AT_ranges
);
18985 if (new_attr
== NULL
18986 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
18989 superblock
= BLOCK_SUPERCONTEXT (chain
);
18992 && (ranges_table
[attr
->dw_attr_val
.v
.val_offset
18993 / 2 / DWARF2_ADDR_SIZE
].num
18994 == BLOCK_NUMBER (superblock
))
18995 && BLOCK_FRAGMENT_CHAIN (superblock
))
18997 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
18998 / 2 / DWARF2_ADDR_SIZE
;
18999 unsigned long supercnt
= 0, thiscnt
= 0;
19000 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
19001 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
19004 gcc_checking_assert (ranges_table
[off
+ supercnt
].num
19005 == BLOCK_NUMBER (chain
));
19007 gcc_checking_assert (ranges_table
[off
+ supercnt
+ 1].num
== 0);
19008 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19009 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
19011 gcc_assert (supercnt
>= thiscnt
);
19012 add_AT_range_list (die
, DW_AT_ranges
,
19013 ((off
+ supercnt
- thiscnt
)
19014 * 2 * DWARF2_ADDR_SIZE
),
19019 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
), false);
19021 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19024 add_ranges (chain
);
19025 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
19032 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
19033 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19034 BLOCK_NUMBER (stmt
));
19035 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
19036 BLOCK_NUMBER (stmt
));
19037 add_AT_low_high_pc (die
, label
, label_high
, false);
19041 /* Generate a DIE for a lexical block. */
19044 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19046 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
19048 if (call_arg_locations
)
19050 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19051 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19052 block_map
[BLOCK_NUMBER (stmt
)] = stmt_die
;
19055 if (! BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
19056 add_high_low_attributes (stmt
, stmt_die
);
19058 decls_for_scope (stmt
, stmt_die
, depth
);
19061 /* Generate a DIE for an inlined subprogram. */
19064 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
19068 /* The instance of function that is effectively being inlined shall not
19070 gcc_assert (! BLOCK_ABSTRACT (stmt
));
19072 decl
= block_ultimate_origin (stmt
);
19074 /* Emit info for the abstract instance first, if we haven't yet. We
19075 must emit this even if the block is abstract, otherwise when we
19076 emit the block below (or elsewhere), we may end up trying to emit
19077 a die whose origin die hasn't been emitted, and crashing. */
19078 dwarf2out_abstract_function (decl
);
19080 if (! BLOCK_ABSTRACT (stmt
))
19082 dw_die_ref subr_die
19083 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
19085 if (call_arg_locations
)
19087 if (block_map
.length () <= BLOCK_NUMBER (stmt
))
19088 block_map
.safe_grow_cleared (BLOCK_NUMBER (stmt
) + 1);
19089 block_map
[BLOCK_NUMBER (stmt
)] = subr_die
;
19091 add_abstract_origin_attribute (subr_die
, decl
);
19092 if (TREE_ASM_WRITTEN (stmt
))
19093 add_high_low_attributes (stmt
, subr_die
);
19094 add_call_src_coords_attributes (stmt
, subr_die
);
19096 decls_for_scope (stmt
, subr_die
, depth
);
19097 current_function_has_inlines
= 1;
19101 /* Generate a DIE for a field in a record, or structure. */
19104 gen_field_die (tree decl
, dw_die_ref context_die
)
19106 dw_die_ref decl_die
;
19108 if (TREE_TYPE (decl
) == error_mark_node
)
19111 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
19112 add_name_and_src_coords_attributes (decl_die
, decl
);
19113 add_type_attribute (decl_die
, member_declared_type (decl
), 0, 0, context_die
);
19115 if (DECL_BIT_FIELD_TYPE (decl
))
19117 add_byte_size_attribute (decl_die
, decl
);
19118 add_bit_size_attribute (decl_die
, decl
);
19119 add_bit_offset_attribute (decl_die
, decl
);
19122 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
19123 add_data_member_location_attribute (decl_die
, decl
);
19125 if (DECL_ARTIFICIAL (decl
))
19126 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
19128 add_accessibility_attribute (decl_die
, decl
);
19130 /* Equate decl number to die, so that we can look up this decl later on. */
19131 equate_decl_number_to_die (decl
, decl_die
);
19135 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19136 Use modified_type_die instead.
19137 We keep this code here just in case these types of DIEs may be needed to
19138 represent certain things in other languages (e.g. Pascal) someday. */
19141 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
19144 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
19146 equate_type_number_to_die (type
, ptr_die
);
19147 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19148 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19151 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19152 Use modified_type_die instead.
19153 We keep this code here just in case these types of DIEs may be needed to
19154 represent certain things in other languages (e.g. Pascal) someday. */
19157 gen_reference_type_die (tree type
, dw_die_ref context_die
)
19159 dw_die_ref ref_die
, scope_die
= scope_die_for (type
, context_die
);
19161 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
19162 ref_die
= new_die (DW_TAG_rvalue_reference_type
, scope_die
, type
);
19164 ref_die
= new_die (DW_TAG_reference_type
, scope_die
, type
);
19166 equate_type_number_to_die (type
, ref_die
);
19167 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
19168 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19172 /* Generate a DIE for a pointer to a member type. */
19175 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
19178 = new_die (DW_TAG_ptr_to_member_type
,
19179 scope_die_for (type
, context_die
), type
);
19181 equate_type_number_to_die (type
, ptr_die
);
19182 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
19183 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
19184 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19187 typedef const char *dchar_p
; /* For DEF_VEC_P. */
19189 static char *producer_string
;
19191 /* Return a heap allocated producer string including command line options
19192 if -grecord-gcc-switches. */
19195 gen_producer_string (void)
19198 auto_vec
<dchar_p
> switches
;
19199 const char *language_string
= lang_hooks
.name
;
19200 char *producer
, *tail
;
19202 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
19203 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
19205 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
19206 switch (save_decoded_options
[j
].opt_index
)
19213 case OPT_auxbase_strip
:
19222 case OPT_SPECIAL_unknown
:
19223 case OPT_SPECIAL_ignore
:
19224 case OPT_SPECIAL_program_name
:
19225 case OPT_SPECIAL_input_file
:
19226 case OPT_grecord_gcc_switches
:
19227 case OPT_gno_record_gcc_switches
:
19228 case OPT__output_pch_
:
19229 case OPT_fdiagnostics_show_location_
:
19230 case OPT_fdiagnostics_show_option
:
19231 case OPT_fdiagnostics_show_caret
:
19232 case OPT_fdiagnostics_color_
:
19233 case OPT_fverbose_asm
:
19235 case OPT__sysroot_
:
19237 case OPT_nostdinc__
:
19238 /* Ignore these. */
19241 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
19242 & CL_NO_DWARF_RECORD
)
19244 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
19246 switch (save_decoded_options
[j
].canonical_option
[0][1])
19253 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
19260 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
19261 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
19265 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
19267 sprintf (tail
, "%s %s", language_string
, version_string
);
19270 FOR_EACH_VEC_ELT (switches
, j
, p
)
19274 memcpy (tail
+ 1, p
, len
);
19282 /* Generate the DIE for the compilation unit. */
19285 gen_compile_unit_die (const char *filename
)
19288 const char *language_string
= lang_hooks
.name
;
19291 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
19295 add_name_attribute (die
, filename
);
19296 /* Don't add cwd for <built-in>. */
19297 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
19298 add_comp_dir_attribute (die
);
19301 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
19303 /* If our producer is LTO try to figure out a common language to use
19304 from the global list of translation units. */
19305 if (strcmp (language_string
, "GNU GIMPLE") == 0)
19309 const char *common_lang
= NULL
;
19311 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
19313 if (!TRANSLATION_UNIT_LANGUAGE (t
))
19316 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
19317 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
19319 else if (strncmp (common_lang
, "GNU C", 5) == 0
19320 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
19321 /* Mixing C and C++ is ok, use C++ in that case. */
19322 common_lang
= "GNU C++";
19325 /* Fall back to C. */
19326 common_lang
= NULL
;
19332 language_string
= common_lang
;
19335 language
= DW_LANG_C89
;
19336 if (strcmp (language_string
, "GNU C++") == 0)
19337 language
= DW_LANG_C_plus_plus
;
19338 else if (strcmp (language_string
, "GNU F77") == 0)
19339 language
= DW_LANG_Fortran77
;
19340 else if (strcmp (language_string
, "GNU Pascal") == 0)
19341 language
= DW_LANG_Pascal83
;
19342 else if (use_upc_dwarf2_extensions
19343 && (strcmp (language_string
, "GNU UPC") == 0))
19344 language
= DW_LANG_Upc
;
19345 else if (dwarf_version
>= 3 || !dwarf_strict
)
19347 if (strcmp (language_string
, "GNU Ada") == 0)
19348 language
= DW_LANG_Ada95
;
19349 else if (strcmp (language_string
, "GNU Fortran") == 0)
19350 language
= DW_LANG_Fortran95
;
19351 else if (strcmp (language_string
, "GNU Java") == 0)
19352 language
= DW_LANG_Java
;
19353 else if (strcmp (language_string
, "GNU Objective-C") == 0)
19354 language
= DW_LANG_ObjC
;
19355 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
19356 language
= DW_LANG_ObjC_plus_plus
;
19357 else if (dwarf_version
>= 5 || !dwarf_strict
)
19359 if (strcmp (language_string
, "GNU Go") == 0)
19360 language
= DW_LANG_Go
;
19363 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
19364 else if (strcmp (language_string
, "GNU Fortran") == 0)
19365 language
= DW_LANG_Fortran90
;
19367 add_AT_unsigned (die
, DW_AT_language
, language
);
19371 case DW_LANG_Fortran77
:
19372 case DW_LANG_Fortran90
:
19373 case DW_LANG_Fortran95
:
19374 /* Fortran has case insensitive identifiers and the front-end
19375 lowercases everything. */
19376 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
19379 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19385 /* Generate the DIE for a base class. */
19388 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
19390 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
19392 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
19393 add_data_member_location_attribute (die
, binfo
);
19395 if (BINFO_VIRTUAL_P (binfo
))
19396 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
19398 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19399 children, otherwise the default is DW_ACCESS_public. In DWARF2
19400 the default has always been DW_ACCESS_private. */
19401 if (access
== access_public_node
)
19403 if (dwarf_version
== 2
19404 || context_die
->die_tag
== DW_TAG_class_type
)
19405 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19407 else if (access
== access_protected_node
)
19408 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19409 else if (dwarf_version
> 2
19410 && context_die
->die_tag
!= DW_TAG_class_type
)
19411 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19414 /* Generate a DIE for a class member. */
19417 gen_member_die (tree type
, dw_die_ref context_die
)
19420 tree binfo
= TYPE_BINFO (type
);
19423 /* If this is not an incomplete type, output descriptions of each of its
19424 members. Note that as we output the DIEs necessary to represent the
19425 members of this record or union type, we will also be trying to output
19426 DIEs to represent the *types* of those members. However the `type'
19427 function (above) will specifically avoid generating type DIEs for member
19428 types *within* the list of member DIEs for this (containing) type except
19429 for those types (of members) which are explicitly marked as also being
19430 members of this (containing) type themselves. The g++ front- end can
19431 force any given type to be treated as a member of some other (containing)
19432 type by setting the TYPE_CONTEXT of the given (member) type to point to
19433 the TREE node representing the appropriate (containing) type. */
19435 /* First output info about the base classes. */
19438 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
19442 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
19443 gen_inheritance_die (base
,
19444 (accesses
? (*accesses
)[i
] : access_public_node
),
19448 /* Now output info about the data members and type members. */
19449 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
19451 /* If we thought we were generating minimal debug info for TYPE
19452 and then changed our minds, some of the member declarations
19453 may have already been defined. Don't define them again, but
19454 do put them in the right order. */
19456 child
= lookup_decl_die (member
);
19458 splice_child_die (context_die
, child
);
19460 gen_decl_die (member
, NULL
, context_die
);
19463 /* Now output info about the function members (if any). */
19464 for (member
= TYPE_METHODS (type
); member
; member
= DECL_CHAIN (member
))
19466 /* Don't include clones in the member list. */
19467 if (DECL_ABSTRACT_ORIGIN (member
))
19470 child
= lookup_decl_die (member
);
19472 splice_child_die (context_die
, child
);
19474 gen_decl_die (member
, NULL
, context_die
);
19478 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19479 is set, we pretend that the type was never defined, so we only get the
19480 member DIEs needed by later specification DIEs. */
19483 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
19484 enum debug_info_usage usage
)
19486 dw_die_ref type_die
= lookup_type_die (type
);
19487 dw_die_ref scope_die
= 0;
19489 int complete
= (TYPE_SIZE (type
)
19490 && (! TYPE_STUB_DECL (type
)
19491 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
19492 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
19493 complete
= complete
&& should_emit_struct_debug (type
, usage
);
19495 if (type_die
&& ! complete
)
19498 if (TYPE_CONTEXT (type
) != NULL_TREE
19499 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19500 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
19503 scope_die
= scope_die_for (type
, context_die
);
19505 /* Generate child dies for template paramaters. */
19506 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
19507 schedule_generic_params_dies_gen (type
);
19509 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
19510 /* First occurrence of type or toplevel definition of nested class. */
19512 dw_die_ref old_die
= type_die
;
19514 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
19515 ? record_type_tag (type
) : DW_TAG_union_type
,
19517 equate_type_number_to_die (type
, type_die
);
19519 add_AT_specification (type_die
, old_die
);
19521 add_name_attribute (type_die
, type_tag (type
));
19524 remove_AT (type_die
, DW_AT_declaration
);
19526 /* If this type has been completed, then give it a byte_size attribute and
19527 then give a list of members. */
19528 if (complete
&& !ns_decl
)
19530 /* Prevent infinite recursion in cases where the type of some member of
19531 this type is expressed in terms of this type itself. */
19532 TREE_ASM_WRITTEN (type
) = 1;
19533 add_byte_size_attribute (type_die
, type
);
19534 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
19536 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
19537 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
19540 /* If the first reference to this type was as the return type of an
19541 inline function, then it may not have a parent. Fix this now. */
19542 if (type_die
->die_parent
== NULL
)
19543 add_child_die (scope_die
, type_die
);
19545 push_decl_scope (type
);
19546 gen_member_die (type
, type_die
);
19549 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
19550 if (TYPE_ARTIFICIAL (type
))
19551 add_AT_flag (type_die
, DW_AT_artificial
, 1);
19553 /* GNU extension: Record what type our vtable lives in. */
19554 if (TYPE_VFIELD (type
))
19556 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
19558 gen_type_die (vtype
, context_die
);
19559 add_AT_die_ref (type_die
, DW_AT_containing_type
,
19560 lookup_type_die (vtype
));
19565 add_AT_flag (type_die
, DW_AT_declaration
, 1);
19567 /* We don't need to do this for function-local types. */
19568 if (TYPE_STUB_DECL (type
)
19569 && ! decl_function_context (TYPE_STUB_DECL (type
)))
19570 vec_safe_push (incomplete_types
, type
);
19573 if (get_AT (type_die
, DW_AT_name
))
19574 add_pubtype (type
, type_die
);
19577 /* Generate a DIE for a subroutine _type_. */
19580 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
19582 tree return_type
= TREE_TYPE (type
);
19583 dw_die_ref subr_die
19584 = new_die (DW_TAG_subroutine_type
,
19585 scope_die_for (type
, context_die
), type
);
19587 equate_type_number_to_die (type
, subr_die
);
19588 add_prototyped_attribute (subr_die
, type
);
19589 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
19590 gen_formal_types_die (type
, subr_die
);
19592 if (get_AT (subr_die
, DW_AT_name
))
19593 add_pubtype (type
, subr_die
);
19596 /* Generate a DIE for a type definition. */
19599 gen_typedef_die (tree decl
, dw_die_ref context_die
)
19601 dw_die_ref type_die
;
19604 if (TREE_ASM_WRITTEN (decl
))
19607 TREE_ASM_WRITTEN (decl
) = 1;
19608 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
19609 origin
= decl_ultimate_origin (decl
);
19610 if (origin
!= NULL
)
19611 add_abstract_origin_attribute (type_die
, origin
);
19616 add_name_and_src_coords_attributes (type_die
, decl
);
19617 if (DECL_ORIGINAL_TYPE (decl
))
19619 type
= DECL_ORIGINAL_TYPE (decl
);
19621 gcc_assert (type
!= TREE_TYPE (decl
));
19622 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
19626 type
= TREE_TYPE (decl
);
19628 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19630 /* Here, we are in the case of decl being a typedef naming
19631 an anonymous type, e.g:
19632 typedef struct {...} foo;
19633 In that case TREE_TYPE (decl) is not a typedef variant
19634 type and TYPE_NAME of the anonymous type is set to the
19635 TYPE_DECL of the typedef. This construct is emitted by
19638 TYPE is the anonymous struct named by the typedef
19639 DECL. As we need the DW_AT_type attribute of the
19640 DW_TAG_typedef to point to the DIE of TYPE, let's
19641 generate that DIE right away. add_type_attribute
19642 called below will then pick (via lookup_type_die) that
19643 anonymous struct DIE. */
19644 if (!TREE_ASM_WRITTEN (type
))
19645 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
19647 /* This is a GNU Extension. We are adding a
19648 DW_AT_linkage_name attribute to the DIE of the
19649 anonymous struct TYPE. The value of that attribute
19650 is the name of the typedef decl naming the anonymous
19651 struct. This greatly eases the work of consumers of
19652 this debug info. */
19653 add_linkage_attr (lookup_type_die (type
), decl
);
19657 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
19658 TREE_THIS_VOLATILE (decl
), context_die
);
19660 if (is_naming_typedef_decl (decl
))
19661 /* We want that all subsequent calls to lookup_type_die with
19662 TYPE in argument yield the DW_TAG_typedef we have just
19664 equate_type_number_to_die (type
, type_die
);
19666 add_accessibility_attribute (type_die
, decl
);
19669 if (DECL_ABSTRACT (decl
))
19670 equate_decl_number_to_die (decl
, type_die
);
19672 if (get_AT (type_die
, DW_AT_name
))
19673 add_pubtype (decl
, type_die
);
19676 /* Generate a DIE for a struct, class, enum or union type. */
19679 gen_tagged_type_die (tree type
,
19680 dw_die_ref context_die
,
19681 enum debug_info_usage usage
)
19685 if (type
== NULL_TREE
19686 || !is_tagged_type (type
))
19689 /* If this is a nested type whose containing class hasn't been written
19690 out yet, writing it out will cover this one, too. This does not apply
19691 to instantiations of member class templates; they need to be added to
19692 the containing class as they are generated. FIXME: This hurts the
19693 idea of combining type decls from multiple TUs, since we can't predict
19694 what set of template instantiations we'll get. */
19695 if (TYPE_CONTEXT (type
)
19696 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19697 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
19699 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
19701 if (TREE_ASM_WRITTEN (type
))
19704 /* If that failed, attach ourselves to the stub. */
19705 push_decl_scope (TYPE_CONTEXT (type
));
19706 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
19709 else if (TYPE_CONTEXT (type
) != NULL_TREE
19710 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
19712 /* If this type is local to a function that hasn't been written
19713 out yet, use a NULL context for now; it will be fixed up in
19714 decls_for_scope. */
19715 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
19716 /* A declaration DIE doesn't count; nested types need to go in the
19718 if (context_die
&& is_declaration_die (context_die
))
19719 context_die
= NULL
;
19724 context_die
= declare_in_namespace (type
, context_die
);
19728 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
19730 /* This might have been written out by the call to
19731 declare_in_namespace. */
19732 if (!TREE_ASM_WRITTEN (type
))
19733 gen_enumeration_type_die (type
, context_die
);
19736 gen_struct_or_union_type_die (type
, context_die
, usage
);
19741 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
19742 it up if it is ever completed. gen_*_type_die will set it for us
19743 when appropriate. */
19746 /* Generate a type description DIE. */
19749 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
19750 enum debug_info_usage usage
)
19752 struct array_descr_info info
;
19754 if (type
== NULL_TREE
|| type
== error_mark_node
)
19757 if (TYPE_NAME (type
) != NULL_TREE
19758 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
19759 && is_redundant_typedef (TYPE_NAME (type
))
19760 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
19761 /* The DECL of this type is a typedef we don't want to emit debug
19762 info for but we want debug info for its underlying typedef.
19763 This can happen for e.g, the injected-class-name of a C++
19765 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
19767 /* If TYPE is a typedef type variant, let's generate debug info
19768 for the parent typedef which TYPE is a type of. */
19769 if (typedef_variant_p (type
))
19771 if (TREE_ASM_WRITTEN (type
))
19774 /* Prevent broken recursion; we can't hand off to the same type. */
19775 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
19777 /* Give typedefs the right scope. */
19778 context_die
= scope_die_for (type
, context_die
);
19780 TREE_ASM_WRITTEN (type
) = 1;
19782 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19786 /* If type is an anonymous tagged type named by a typedef, let's
19787 generate debug info for the typedef. */
19788 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19790 /* Use the DIE of the containing namespace as the parent DIE of
19791 the type description DIE we want to generate. */
19792 if (DECL_CONTEXT (TYPE_NAME (type
))
19793 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
19794 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
19796 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19800 /* If this is an array type with hidden descriptor, handle it first. */
19801 if (!TREE_ASM_WRITTEN (type
)
19802 && lang_hooks
.types
.get_array_descr_info
19803 && lang_hooks
.types
.get_array_descr_info (type
, &info
)
19804 && (dwarf_version
>= 3 || !dwarf_strict
))
19806 gen_descr_array_type_die (type
, &info
, context_die
);
19807 TREE_ASM_WRITTEN (type
) = 1;
19811 /* We are going to output a DIE to represent the unqualified version
19812 of this type (i.e. without any const or volatile qualifiers) so
19813 get the main variant (i.e. the unqualified version) of this type
19814 now. (Vectors are special because the debugging info is in the
19815 cloned type itself). */
19816 if (TREE_CODE (type
) != VECTOR_TYPE
)
19817 type
= type_main_variant (type
);
19819 if (TREE_ASM_WRITTEN (type
))
19822 switch (TREE_CODE (type
))
19828 case REFERENCE_TYPE
:
19829 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
19830 ensures that the gen_type_die recursion will terminate even if the
19831 type is recursive. Recursive types are possible in Ada. */
19832 /* ??? We could perhaps do this for all types before the switch
19834 TREE_ASM_WRITTEN (type
) = 1;
19836 /* For these types, all that is required is that we output a DIE (or a
19837 set of DIEs) to represent the "basis" type. */
19838 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19839 DINFO_USAGE_IND_USE
);
19843 /* This code is used for C++ pointer-to-data-member types.
19844 Output a description of the relevant class type. */
19845 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
19846 DINFO_USAGE_IND_USE
);
19848 /* Output a description of the type of the object pointed to. */
19849 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19850 DINFO_USAGE_IND_USE
);
19852 /* Now output a DIE to represent this pointer-to-data-member type
19854 gen_ptr_to_mbr_type_die (type
, context_die
);
19857 case FUNCTION_TYPE
:
19858 /* Force out return type (in case it wasn't forced out already). */
19859 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19860 DINFO_USAGE_DIR_USE
);
19861 gen_subroutine_type_die (type
, context_die
);
19865 /* Force out return type (in case it wasn't forced out already). */
19866 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19867 DINFO_USAGE_DIR_USE
);
19868 gen_subroutine_type_die (type
, context_die
);
19872 gen_array_type_die (type
, context_die
);
19876 gen_array_type_die (type
, context_die
);
19879 case ENUMERAL_TYPE
:
19882 case QUAL_UNION_TYPE
:
19883 gen_tagged_type_die (type
, context_die
, usage
);
19889 case FIXED_POINT_TYPE
:
19892 /* No DIEs needed for fundamental types. */
19897 /* Just use DW_TAG_unspecified_type. */
19899 dw_die_ref type_die
= lookup_type_die (type
);
19900 if (type_die
== NULL
)
19902 tree name
= TYPE_NAME (type
);
19903 if (TREE_CODE (name
) == TYPE_DECL
)
19904 name
= DECL_NAME (name
);
19905 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (), type
);
19906 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
19907 equate_type_number_to_die (type
, type_die
);
19913 if (is_cxx_auto (type
))
19915 tree name
= TYPE_NAME (type
);
19916 if (TREE_CODE (name
) == TYPE_DECL
)
19917 name
= DECL_NAME (name
);
19918 dw_die_ref
*die
= (name
== get_identifier ("auto")
19919 ? &auto_die
: &decltype_auto_die
);
19922 *die
= new_die (DW_TAG_unspecified_type
,
19923 comp_unit_die (), NULL_TREE
);
19924 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
19926 equate_type_number_to_die (type
, *die
);
19929 gcc_unreachable ();
19932 TREE_ASM_WRITTEN (type
) = 1;
19936 gen_type_die (tree type
, dw_die_ref context_die
)
19938 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
19941 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
19942 things which are local to the given block. */
19945 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19947 int must_output_die
= 0;
19950 /* Ignore blocks that are NULL. */
19951 if (stmt
== NULL_TREE
)
19954 inlined_func
= inlined_function_outer_scope_p (stmt
);
19956 /* If the block is one fragment of a non-contiguous block, do not
19957 process the variables, since they will have been done by the
19958 origin block. Do process subblocks. */
19959 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
19963 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
19964 gen_block_die (sub
, context_die
, depth
+ 1);
19969 /* Determine if we need to output any Dwarf DIEs at all to represent this
19972 /* The outer scopes for inlinings *must* always be represented. We
19973 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
19974 must_output_die
= 1;
19977 /* Determine if this block directly contains any "significant"
19978 local declarations which we will need to output DIEs for. */
19979 if (debug_info_level
> DINFO_LEVEL_TERSE
)
19980 /* We are not in terse mode so *any* local declaration counts
19981 as being a "significant" one. */
19982 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
19983 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
19984 && (TREE_USED (stmt
)
19985 || TREE_ASM_WRITTEN (stmt
)
19986 || BLOCK_ABSTRACT (stmt
)));
19987 else if ((TREE_USED (stmt
)
19988 || TREE_ASM_WRITTEN (stmt
)
19989 || BLOCK_ABSTRACT (stmt
))
19990 && !dwarf2out_ignore_block (stmt
))
19991 must_output_die
= 1;
19994 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
19995 DIE for any block which contains no significant local declarations at
19996 all. Rather, in such cases we just call `decls_for_scope' so that any
19997 needed Dwarf info for any sub-blocks will get properly generated. Note
19998 that in terse mode, our definition of what constitutes a "significant"
19999 local declaration gets restricted to include only inlined function
20000 instances and local (nested) function definitions. */
20001 if (must_output_die
)
20005 /* If STMT block is abstract, that means we have been called
20006 indirectly from dwarf2out_abstract_function.
20007 That function rightfully marks the descendent blocks (of
20008 the abstract function it is dealing with) as being abstract,
20009 precisely to prevent us from emitting any
20010 DW_TAG_inlined_subroutine DIE as a descendent
20011 of an abstract function instance. So in that case, we should
20012 not call gen_inlined_subroutine_die.
20014 Later though, when cgraph asks dwarf2out to emit info
20015 for the concrete instance of the function decl into which
20016 the concrete instance of STMT got inlined, the later will lead
20017 to the generation of a DW_TAG_inlined_subroutine DIE. */
20018 if (! BLOCK_ABSTRACT (stmt
))
20019 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
20022 gen_lexical_block_die (stmt
, context_die
, depth
);
20025 decls_for_scope (stmt
, context_die
, depth
);
20028 /* Process variable DECL (or variable with origin ORIGIN) within
20029 block STMT and add it to CONTEXT_DIE. */
20031 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
20034 tree decl_or_origin
= decl
? decl
: origin
;
20036 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
20037 die
= lookup_decl_die (decl_or_origin
);
20038 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
20039 && TYPE_DECL_IS_STUB (decl_or_origin
))
20040 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
20044 if (die
!= NULL
&& die
->die_parent
== NULL
)
20045 add_child_die (context_die
, die
);
20046 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
20047 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
20048 stmt
, context_die
);
20050 gen_decl_die (decl
, origin
, context_die
);
20053 /* Generate all of the decls declared within a given scope and (recursively)
20054 all of its sub-blocks. */
20057 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
20063 /* Ignore NULL blocks. */
20064 if (stmt
== NULL_TREE
)
20067 /* Output the DIEs to represent all of the data objects and typedefs
20068 declared directly within this block but not within any nested
20069 sub-blocks. Also, nested function and tag DIEs have been
20070 generated with a parent of NULL; fix that up now. We don't
20071 have to do this if we're at -g1. */
20072 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20074 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
20075 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
20076 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
20077 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
20081 /* Even if we're at -g1, we need to process the subblocks in order to get
20082 inlined call information. */
20084 /* Output the DIEs to represent all sub-blocks (and the items declared
20085 therein) of this block. */
20086 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
20088 subblocks
= BLOCK_CHAIN (subblocks
))
20089 gen_block_die (subblocks
, context_die
, depth
+ 1);
20092 /* Is this a typedef we can avoid emitting? */
20095 is_redundant_typedef (const_tree decl
)
20097 if (TYPE_DECL_IS_STUB (decl
))
20100 if (DECL_ARTIFICIAL (decl
)
20101 && DECL_CONTEXT (decl
)
20102 && is_tagged_type (DECL_CONTEXT (decl
))
20103 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
20104 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
20105 /* Also ignore the artificial member typedef for the class name. */
20111 /* Return TRUE if TYPE is a typedef that names a type for linkage
20112 purposes. This kind of typedefs is produced by the C++ FE for
20115 typedef struct {...} foo;
20117 In that case, there is no typedef variant type produced for foo.
20118 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20122 is_naming_typedef_decl (const_tree decl
)
20124 if (decl
== NULL_TREE
20125 || TREE_CODE (decl
) != TYPE_DECL
20126 || !is_tagged_type (TREE_TYPE (decl
))
20127 || DECL_IS_BUILTIN (decl
)
20128 || is_redundant_typedef (decl
)
20129 /* It looks like Ada produces TYPE_DECLs that are very similar
20130 to C++ naming typedefs but that have different
20131 semantics. Let's be specific to c++ for now. */
20135 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
20136 && TYPE_NAME (TREE_TYPE (decl
)) == decl
20137 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
20138 != TYPE_NAME (TREE_TYPE (decl
))));
20141 /* Returns the DIE for a context. */
20143 static inline dw_die_ref
20144 get_context_die (tree context
)
20148 /* Find die that represents this context. */
20149 if (TYPE_P (context
))
20151 context
= TYPE_MAIN_VARIANT (context
);
20152 return strip_naming_typedef (context
, force_type_die (context
));
20155 return force_decl_die (context
);
20157 return comp_unit_die ();
20160 /* Returns the DIE for decl. A DIE will always be returned. */
20163 force_decl_die (tree decl
)
20165 dw_die_ref decl_die
;
20166 unsigned saved_external_flag
;
20167 tree save_fn
= NULL_TREE
;
20168 decl_die
= lookup_decl_die (decl
);
20171 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
20173 decl_die
= lookup_decl_die (decl
);
20177 switch (TREE_CODE (decl
))
20179 case FUNCTION_DECL
:
20180 /* Clear current_function_decl, so that gen_subprogram_die thinks
20181 that this is a declaration. At this point, we just want to force
20182 declaration die. */
20183 save_fn
= current_function_decl
;
20184 current_function_decl
= NULL_TREE
;
20185 gen_subprogram_die (decl
, context_die
);
20186 current_function_decl
= save_fn
;
20190 /* Set external flag to force declaration die. Restore it after
20191 gen_decl_die() call. */
20192 saved_external_flag
= DECL_EXTERNAL (decl
);
20193 DECL_EXTERNAL (decl
) = 1;
20194 gen_decl_die (decl
, NULL
, context_die
);
20195 DECL_EXTERNAL (decl
) = saved_external_flag
;
20198 case NAMESPACE_DECL
:
20199 if (dwarf_version
>= 3 || !dwarf_strict
)
20200 dwarf2out_decl (decl
);
20202 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20203 decl_die
= comp_unit_die ();
20206 case TRANSLATION_UNIT_DECL
:
20207 decl_die
= comp_unit_die ();
20211 gcc_unreachable ();
20214 /* We should be able to find the DIE now. */
20216 decl_die
= lookup_decl_die (decl
);
20217 gcc_assert (decl_die
);
20223 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20224 always returned. */
20227 force_type_die (tree type
)
20229 dw_die_ref type_die
;
20231 type_die
= lookup_type_die (type
);
20234 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
20236 type_die
= modified_type_die (type
, TYPE_QUALS (type
), context_die
);
20237 gcc_assert (type_die
);
20242 /* Force out any required namespaces to be able to output DECL,
20243 and return the new context_die for it, if it's changed. */
20246 setup_namespace_context (tree thing
, dw_die_ref context_die
)
20248 tree context
= (DECL_P (thing
)
20249 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
20250 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
20251 /* Force out the namespace. */
20252 context_die
= force_decl_die (context
);
20254 return context_die
;
20257 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20258 type) within its namespace, if appropriate.
20260 For compatibility with older debuggers, namespace DIEs only contain
20261 declarations; all definitions are emitted at CU scope. */
20264 declare_in_namespace (tree thing
, dw_die_ref context_die
)
20266 dw_die_ref ns_context
;
20268 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20269 return context_die
;
20271 /* If this decl is from an inlined function, then don't try to emit it in its
20272 namespace, as we will get confused. It would have already been emitted
20273 when the abstract instance of the inline function was emitted anyways. */
20274 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
20275 return context_die
;
20277 ns_context
= setup_namespace_context (thing
, context_die
);
20279 if (ns_context
!= context_die
)
20283 if (DECL_P (thing
))
20284 gen_decl_die (thing
, NULL
, ns_context
);
20286 gen_type_die (thing
, ns_context
);
20288 return context_die
;
20291 /* Generate a DIE for a namespace or namespace alias. */
20294 gen_namespace_die (tree decl
, dw_die_ref context_die
)
20296 dw_die_ref namespace_die
;
20298 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20299 they are an alias of. */
20300 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
20302 /* Output a real namespace or module. */
20303 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20304 namespace_die
= new_die (is_fortran ()
20305 ? DW_TAG_module
: DW_TAG_namespace
,
20306 context_die
, decl
);
20307 /* For Fortran modules defined in different CU don't add src coords. */
20308 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
20310 const char *name
= dwarf2_name (decl
, 0);
20312 add_name_attribute (namespace_die
, name
);
20315 add_name_and_src_coords_attributes (namespace_die
, decl
);
20316 if (DECL_EXTERNAL (decl
))
20317 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
20318 equate_decl_number_to_die (decl
, namespace_die
);
20322 /* Output a namespace alias. */
20324 /* Force out the namespace we are an alias of, if necessary. */
20325 dw_die_ref origin_die
20326 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
20328 if (DECL_FILE_SCOPE_P (decl
)
20329 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
20330 context_die
= setup_namespace_context (decl
, comp_unit_die ());
20331 /* Now create the namespace alias DIE. */
20332 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
20333 add_name_and_src_coords_attributes (namespace_die
, decl
);
20334 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
20335 equate_decl_number_to_die (decl
, namespace_die
);
20337 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
20338 if (want_pubnames ())
20339 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
20342 /* Generate Dwarf debug information for a decl described by DECL.
20343 The return value is currently only meaningful for PARM_DECLs,
20344 for all other decls it returns NULL. */
20347 gen_decl_die (tree decl
, tree origin
, dw_die_ref context_die
)
20349 tree decl_or_origin
= decl
? decl
: origin
;
20350 tree class_origin
= NULL
, ultimate_origin
;
20352 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
20355 switch (TREE_CODE (decl_or_origin
))
20361 if (!is_fortran () && !is_ada ())
20363 /* The individual enumerators of an enum type get output when we output
20364 the Dwarf representation of the relevant enum type itself. */
20368 /* Emit its type. */
20369 gen_type_die (TREE_TYPE (decl
), context_die
);
20371 /* And its containing namespace. */
20372 context_die
= declare_in_namespace (decl
, context_die
);
20374 gen_const_die (decl
, context_die
);
20377 case FUNCTION_DECL
:
20378 /* Don't output any DIEs to represent mere function declarations,
20379 unless they are class members or explicit block externs. */
20380 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
20381 && DECL_FILE_SCOPE_P (decl_or_origin
)
20382 && (current_function_decl
== NULL_TREE
20383 || DECL_ARTIFICIAL (decl_or_origin
)))
20388 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20389 on local redeclarations of global functions. That seems broken. */
20390 if (current_function_decl
!= decl
)
20391 /* This is only a declaration. */;
20394 /* If we're emitting a clone, emit info for the abstract instance. */
20395 if (origin
|| DECL_ORIGIN (decl
) != decl
)
20396 dwarf2out_abstract_function (origin
20397 ? DECL_ORIGIN (origin
)
20398 : DECL_ABSTRACT_ORIGIN (decl
));
20400 /* If we're emitting an out-of-line copy of an inline function,
20401 emit info for the abstract instance and set up to refer to it. */
20402 else if (cgraph_function_possibly_inlined_p (decl
)
20403 && ! DECL_ABSTRACT (decl
)
20404 && ! class_or_namespace_scope_p (context_die
)
20405 /* dwarf2out_abstract_function won't emit a die if this is just
20406 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20407 that case, because that works only if we have a die. */
20408 && DECL_INITIAL (decl
) != NULL_TREE
)
20410 dwarf2out_abstract_function (decl
);
20411 set_decl_origin_self (decl
);
20414 /* Otherwise we're emitting the primary DIE for this decl. */
20415 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
20417 /* Before we describe the FUNCTION_DECL itself, make sure that we
20418 have its containing type. */
20420 origin
= decl_class_context (decl
);
20421 if (origin
!= NULL_TREE
)
20422 gen_type_die (origin
, context_die
);
20424 /* And its return type. */
20425 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
20427 /* And its virtual context. */
20428 if (DECL_VINDEX (decl
) != NULL_TREE
)
20429 gen_type_die (DECL_CONTEXT (decl
), context_die
);
20431 /* Make sure we have a member DIE for decl. */
20432 if (origin
!= NULL_TREE
)
20433 gen_type_die_for_member (origin
, decl
, context_die
);
20435 /* And its containing namespace. */
20436 context_die
= declare_in_namespace (decl
, context_die
);
20439 /* Now output a DIE to represent the function itself. */
20441 gen_subprogram_die (decl
, context_die
);
20445 /* If we are in terse mode, don't generate any DIEs to represent any
20446 actual typedefs. */
20447 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20450 /* In the special case of a TYPE_DECL node representing the declaration
20451 of some type tag, if the given TYPE_DECL is marked as having been
20452 instantiated from some other (original) TYPE_DECL node (e.g. one which
20453 was generated within the original definition of an inline function) we
20454 used to generate a special (abbreviated) DW_TAG_structure_type,
20455 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20456 should be actually referencing those DIEs, as variable DIEs with that
20457 type would be emitted already in the abstract origin, so it was always
20458 removed during unused type prunning. Don't add anything in this
20460 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
20463 if (is_redundant_typedef (decl
))
20464 gen_type_die (TREE_TYPE (decl
), context_die
);
20466 /* Output a DIE to represent the typedef itself. */
20467 gen_typedef_die (decl
, context_die
);
20471 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
20472 gen_label_die (decl
, context_die
);
20477 /* If we are in terse mode, don't generate any DIEs to represent any
20478 variable declarations or definitions. */
20479 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20482 /* Output any DIEs that are needed to specify the type of this data
20484 if (decl_by_reference_p (decl_or_origin
))
20485 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20487 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20489 /* And its containing type. */
20490 class_origin
= decl_class_context (decl_or_origin
);
20491 if (class_origin
!= NULL_TREE
)
20492 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
20494 /* And its containing namespace. */
20495 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
20497 /* Now output the DIE to represent the data object itself. This gets
20498 complicated because of the possibility that the VAR_DECL really
20499 represents an inlined instance of a formal parameter for an inline
20501 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
20502 if (ultimate_origin
!= NULL_TREE
20503 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
20504 gen_formal_parameter_die (decl
, origin
,
20505 true /* Emit name attribute. */,
20508 gen_variable_die (decl
, origin
, context_die
);
20512 /* Ignore the nameless fields that are used to skip bits but handle C++
20513 anonymous unions and structs. */
20514 if (DECL_NAME (decl
) != NULL_TREE
20515 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
20516 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
20518 gen_type_die (member_declared_type (decl
), context_die
);
20519 gen_field_die (decl
, context_die
);
20524 if (DECL_BY_REFERENCE (decl_or_origin
))
20525 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20527 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20528 return gen_formal_parameter_die (decl
, origin
,
20529 true /* Emit name attribute. */,
20532 case NAMESPACE_DECL
:
20533 case IMPORTED_DECL
:
20534 if (dwarf_version
>= 3 || !dwarf_strict
)
20535 gen_namespace_die (decl
, context_die
);
20538 case NAMELIST_DECL
:
20539 gen_namelist_decl (DECL_NAME (decl
), context_die
,
20540 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
20544 /* Probably some frontend-internal decl. Assume we don't care. */
20545 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
20552 /* Output debug information for global decl DECL. Called from toplev.c after
20553 compilation proper has finished. */
20556 dwarf2out_global_decl (tree decl
)
20558 /* Output DWARF2 information for file-scope tentative data object
20559 declarations, file-scope (extern) function declarations (which
20560 had no corresponding body) and file-scope tagged type declarations
20561 and definitions which have not yet been forced out. */
20562 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
20563 dwarf2out_decl (decl
);
20566 /* Output debug information for type decl DECL. Called from toplev.c
20567 and from language front ends (to record built-in types). */
20569 dwarf2out_type_decl (tree decl
, int local
)
20572 dwarf2out_decl (decl
);
20575 /* Output debug information for imported module or decl DECL.
20576 NAME is non-NULL name in the lexical block if the decl has been renamed.
20577 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
20578 that DECL belongs to.
20579 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
20581 dwarf2out_imported_module_or_decl_1 (tree decl
,
20583 tree lexical_block
,
20584 dw_die_ref lexical_block_die
)
20586 expanded_location xloc
;
20587 dw_die_ref imported_die
= NULL
;
20588 dw_die_ref at_import_die
;
20590 if (TREE_CODE (decl
) == IMPORTED_DECL
)
20592 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
20593 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
20597 xloc
= expand_location (input_location
);
20599 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
20601 at_import_die
= force_type_die (TREE_TYPE (decl
));
20602 /* For namespace N { typedef void T; } using N::T; base_type_die
20603 returns NULL, but DW_TAG_imported_declaration requires
20604 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
20605 if (!at_import_die
)
20607 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
20608 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
20609 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
20610 gcc_assert (at_import_die
);
20615 at_import_die
= lookup_decl_die (decl
);
20616 if (!at_import_die
)
20618 /* If we're trying to avoid duplicate debug info, we may not have
20619 emitted the member decl for this field. Emit it now. */
20620 if (TREE_CODE (decl
) == FIELD_DECL
)
20622 tree type
= DECL_CONTEXT (decl
);
20624 if (TYPE_CONTEXT (type
)
20625 && TYPE_P (TYPE_CONTEXT (type
))
20626 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
20627 DINFO_USAGE_DIR_USE
))
20629 gen_type_die_for_member (type
, decl
,
20630 get_context_die (TYPE_CONTEXT (type
)));
20632 if (TREE_CODE (decl
) == NAMELIST_DECL
)
20633 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
20634 get_context_die (DECL_CONTEXT (decl
)),
20637 at_import_die
= force_decl_die (decl
);
20641 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
20643 if (dwarf_version
>= 3 || !dwarf_strict
)
20644 imported_die
= new_die (DW_TAG_imported_module
,
20651 imported_die
= new_die (DW_TAG_imported_declaration
,
20655 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
20656 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
20658 add_AT_string (imported_die
, DW_AT_name
,
20659 IDENTIFIER_POINTER (name
));
20660 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
20663 /* Output debug information for imported module or decl DECL.
20664 NAME is non-NULL name in context if the decl has been renamed.
20665 CHILD is true if decl is one of the renamed decls as part of
20666 importing whole module. */
20669 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
20672 /* dw_die_ref at_import_die; */
20673 dw_die_ref scope_die
;
20675 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20680 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
20681 We need decl DIE for reference and scope die. First, get DIE for the decl
20684 /* Get the scope die for decl context. Use comp_unit_die for global module
20685 or decl. If die is not found for non globals, force new die. */
20687 && TYPE_P (context
)
20688 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
20691 if (!(dwarf_version
>= 3 || !dwarf_strict
))
20694 scope_die
= get_context_die (context
);
20698 gcc_assert (scope_die
->die_child
);
20699 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
20700 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
20701 scope_die
= scope_die
->die_child
;
20704 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
20705 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
20709 /* Output debug information for namelists. */
20712 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
20714 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
20718 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20721 gcc_assert (scope_die
!= NULL
);
20722 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
20723 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
20725 /* If there are no item_decls, we have a nondefining namelist, e.g.
20726 with USE association; hence, set DW_AT_declaration. */
20727 if (item_decls
== NULL_TREE
)
20729 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
20733 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
20735 nml_item_ref_die
= lookup_decl_die (value
);
20736 if (!nml_item_ref_die
)
20737 nml_item_ref_die
= force_decl_die (value
);
20739 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
20740 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
20746 /* Write the debugging output for DECL. */
20749 dwarf2out_decl (tree decl
)
20751 dw_die_ref context_die
= comp_unit_die ();
20753 switch (TREE_CODE (decl
))
20758 case FUNCTION_DECL
:
20759 /* What we would really like to do here is to filter out all mere
20760 file-scope declarations of file-scope functions which are never
20761 referenced later within this translation unit (and keep all of ones
20762 that *are* referenced later on) but we aren't clairvoyant, so we have
20763 no idea which functions will be referenced in the future (i.e. later
20764 on within the current translation unit). So here we just ignore all
20765 file-scope function declarations which are not also definitions. If
20766 and when the debugger needs to know something about these functions,
20767 it will have to hunt around and find the DWARF information associated
20768 with the definition of the function.
20770 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
20771 nodes represent definitions and which ones represent mere
20772 declarations. We have to check DECL_INITIAL instead. That's because
20773 the C front-end supports some weird semantics for "extern inline"
20774 function definitions. These can get inlined within the current
20775 translation unit (and thus, we need to generate Dwarf info for their
20776 abstract instances so that the Dwarf info for the concrete inlined
20777 instances can have something to refer to) but the compiler never
20778 generates any out-of-lines instances of such things (despite the fact
20779 that they *are* definitions).
20781 The important point is that the C front-end marks these "extern
20782 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
20783 them anyway. Note that the C++ front-end also plays some similar games
20784 for inline function definitions appearing within include files which
20785 also contain `#pragma interface' pragmas.
20787 If we are called from dwarf2out_abstract_function output a DIE
20788 anyway. We can end up here this way with early inlining and LTO
20789 where the inlined function is output in a different LTRANS unit
20791 if (DECL_INITIAL (decl
) == NULL_TREE
20792 && ! DECL_ABSTRACT (decl
))
20795 /* If we're a nested function, initially use a parent of NULL; if we're
20796 a plain function, this will be fixed up in decls_for_scope. If
20797 we're a method, it will be ignored, since we already have a DIE. */
20798 if (decl_function_context (decl
)
20799 /* But if we're in terse mode, we don't care about scope. */
20800 && debug_info_level
> DINFO_LEVEL_TERSE
)
20801 context_die
= NULL
;
20805 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
20806 declaration and if the declaration was never even referenced from
20807 within this entire compilation unit. We suppress these DIEs in
20808 order to save space in the .debug section (by eliminating entries
20809 which are probably useless). Note that we must not suppress
20810 block-local extern declarations (whether used or not) because that
20811 would screw-up the debugger's name lookup mechanism and cause it to
20812 miss things which really ought to be in scope at a given point. */
20813 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
20816 /* For local statics lookup proper context die. */
20817 if (TREE_STATIC (decl
)
20818 && DECL_CONTEXT (decl
)
20819 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
20820 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20822 /* If we are in terse mode, don't generate any DIEs to represent any
20823 variable declarations or definitions. */
20824 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20829 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20831 if (!is_fortran () && !is_ada ())
20833 if (TREE_STATIC (decl
) && decl_function_context (decl
))
20834 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20837 case NAMESPACE_DECL
:
20838 case IMPORTED_DECL
:
20839 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20841 if (lookup_decl_die (decl
) != NULL
)
20846 /* Don't emit stubs for types unless they are needed by other DIEs. */
20847 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
20850 /* Don't bother trying to generate any DIEs to represent any of the
20851 normal built-in types for the language we are compiling. */
20852 if (DECL_IS_BUILTIN (decl
))
20855 /* If we are in terse mode, don't generate any DIEs for types. */
20856 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20859 /* If we're a function-scope tag, initially use a parent of NULL;
20860 this will be fixed up in decls_for_scope. */
20861 if (decl_function_context (decl
))
20862 context_die
= NULL
;
20866 case NAMELIST_DECL
:
20873 gen_decl_die (decl
, NULL
, context_die
);
20876 /* Write the debugging output for DECL. */
20879 dwarf2out_function_decl (tree decl
)
20881 dwarf2out_decl (decl
);
20882 call_arg_locations
= NULL
;
20883 call_arg_loc_last
= NULL
;
20884 call_site_count
= -1;
20885 tail_call_site_count
= -1;
20886 block_map
.release ();
20887 htab_empty (decl_loc_table
);
20888 htab_empty (cached_dw_loc_list_table
);
20891 /* Output a marker (i.e. a label) for the beginning of the generated code for
20892 a lexical block. */
20895 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
20896 unsigned int blocknum
)
20898 switch_to_section (current_function_section ());
20899 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
20902 /* Output a marker (i.e. a label) for the end of the generated code for a
20906 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
20908 switch_to_section (current_function_section ());
20909 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
20912 /* Returns nonzero if it is appropriate not to emit any debugging
20913 information for BLOCK, because it doesn't contain any instructions.
20915 Don't allow this for blocks with nested functions or local classes
20916 as we would end up with orphans, and in the presence of scheduling
20917 we may end up calling them anyway. */
20920 dwarf2out_ignore_block (const_tree block
)
20925 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
20926 if (TREE_CODE (decl
) == FUNCTION_DECL
20927 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
20929 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
20931 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
20932 if (TREE_CODE (decl
) == FUNCTION_DECL
20933 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
20940 /* Hash table routines for file_hash. */
20943 file_table_eq (const void *p1_p
, const void *p2_p
)
20945 const struct dwarf_file_data
*const p1
=
20946 (const struct dwarf_file_data
*) p1_p
;
20947 const char *const p2
= (const char *) p2_p
;
20948 return filename_cmp (p1
->filename
, p2
) == 0;
20952 file_table_hash (const void *p_p
)
20954 const struct dwarf_file_data
*const p
= (const struct dwarf_file_data
*) p_p
;
20955 return htab_hash_string (p
->filename
);
20958 /* Lookup FILE_NAME (in the list of filenames that we know about here in
20959 dwarf2out.c) and return its "index". The index of each (known) filename is
20960 just a unique number which is associated with only that one filename. We
20961 need such numbers for the sake of generating labels (in the .debug_sfnames
20962 section) and references to those files numbers (in the .debug_srcinfo
20963 and.debug_macinfo sections). If the filename given as an argument is not
20964 found in our current list, add it to the list and assign it the next
20965 available unique index number. In order to speed up searches, we remember
20966 the index of the filename was looked up last. This handles the majority of
20969 static struct dwarf_file_data
*
20970 lookup_filename (const char *file_name
)
20973 struct dwarf_file_data
* created
;
20975 /* Check to see if the file name that was searched on the previous
20976 call matches this file name. If so, return the index. */
20977 if (file_table_last_lookup
20978 && (file_name
== file_table_last_lookup
->filename
20979 || filename_cmp (file_table_last_lookup
->filename
, file_name
) == 0))
20980 return file_table_last_lookup
;
20982 /* Didn't match the previous lookup, search the table. */
20983 slot
= htab_find_slot_with_hash (file_table
, file_name
,
20984 htab_hash_string (file_name
), INSERT
);
20986 return (struct dwarf_file_data
*) *slot
;
20988 created
= ggc_alloc_dwarf_file_data ();
20989 created
->filename
= file_name
;
20990 created
->emitted_number
= 0;
20995 /* If the assembler will construct the file table, then translate the compiler
20996 internal file table number into the assembler file table number, and emit
20997 a .file directive if we haven't already emitted one yet. The file table
20998 numbers are different because we prune debug info for unused variables and
20999 types, which may include filenames. */
21002 maybe_emit_file (struct dwarf_file_data
* fd
)
21004 if (! fd
->emitted_number
)
21006 if (last_emitted_file
)
21007 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
21009 fd
->emitted_number
= 1;
21010 last_emitted_file
= fd
;
21012 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21014 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
21015 output_quoted_string (asm_out_file
,
21016 remap_debug_filename (fd
->filename
));
21017 fputc ('\n', asm_out_file
);
21021 return fd
->emitted_number
;
21024 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21025 That generation should happen after function debug info has been
21026 generated. The value of the attribute is the constant value of ARG. */
21029 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
21031 die_arg_entry entry
;
21036 if (!tmpl_value_parm_die_table
)
21037 vec_alloc (tmpl_value_parm_die_table
, 32);
21041 vec_safe_push (tmpl_value_parm_die_table
, entry
);
21044 /* Return TRUE if T is an instance of generic type, FALSE
21048 generic_type_p (tree t
)
21050 if (t
== NULL_TREE
|| !TYPE_P (t
))
21052 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
21055 /* Schedule the generation of the generic parameter dies for the
21056 instance of generic type T. The proper generation itself is later
21057 done by gen_scheduled_generic_parms_dies. */
21060 schedule_generic_params_dies_gen (tree t
)
21062 if (!generic_type_p (t
))
21065 if (!generic_type_instances
)
21066 vec_alloc (generic_type_instances
, 256);
21068 vec_safe_push (generic_type_instances
, t
);
21071 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21072 by append_entry_to_tmpl_value_parm_die_table. This function must
21073 be called after function DIEs have been generated. */
21076 gen_remaining_tmpl_value_param_die_attribute (void)
21078 if (tmpl_value_parm_die_table
)
21083 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
21084 tree_add_const_value_attribute (e
->die
, e
->arg
);
21088 /* Generate generic parameters DIEs for instances of generic types
21089 that have been previously scheduled by
21090 schedule_generic_params_dies_gen. This function must be called
21091 after all the types of the CU have been laid out. */
21094 gen_scheduled_generic_parms_dies (void)
21099 if (!generic_type_instances
)
21102 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
21103 if (COMPLETE_TYPE_P (t
))
21104 gen_generic_params_dies (t
);
21108 /* Replace DW_AT_name for the decl with name. */
21111 dwarf2out_set_name (tree decl
, tree name
)
21117 die
= TYPE_SYMTAB_DIE (decl
);
21121 dname
= dwarf2_name (name
, 0);
21125 attr
= get_AT (die
, DW_AT_name
);
21128 struct indirect_string_node
*node
;
21130 node
= find_AT_string (dname
);
21131 /* replace the string. */
21132 attr
->dw_attr_val
.v
.val_str
= node
;
21136 add_name_attribute (die
, dname
);
21139 /* True if before or during processing of the first function being emitted. */
21140 static bool in_first_function_p
= true;
21141 /* True if loc_note during dwarf2out_var_location call might still be
21142 before first real instruction at address equal to .Ltext0. */
21143 static bool maybe_at_text_label_p
= true;
21144 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
21145 static unsigned int first_loclabel_num_not_at_text_label
;
21147 /* Called by the final INSN scan whenever we see a var location. We
21148 use it to drop labels in the right places, and throw the location in
21149 our lookup table. */
21152 dwarf2out_var_location (rtx loc_note
)
21154 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
21155 struct var_loc_node
*newloc
;
21156 rtx next_real
, next_note
;
21157 static const char *last_label
;
21158 static const char *last_postcall_label
;
21159 static bool last_in_cold_section_p
;
21160 static rtx expected_next_loc_note
;
21164 if (!NOTE_P (loc_note
))
21166 if (CALL_P (loc_note
))
21169 if (SIBLING_CALL_P (loc_note
))
21170 tail_call_site_count
++;
21175 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
21176 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
21179 /* Optimize processing a large consecutive sequence of location
21180 notes so we don't spend too much time in next_real_insn. If the
21181 next insn is another location note, remember the next_real_insn
21182 calculation for next time. */
21183 next_real
= cached_next_real_insn
;
21186 if (expected_next_loc_note
!= loc_note
)
21187 next_real
= NULL_RTX
;
21190 next_note
= NEXT_INSN (loc_note
);
21192 || INSN_DELETED_P (next_note
)
21193 || ! NOTE_P (next_note
)
21194 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
21195 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
21196 next_note
= NULL_RTX
;
21199 next_real
= next_real_insn (loc_note
);
21203 expected_next_loc_note
= next_note
;
21204 cached_next_real_insn
= next_real
;
21207 cached_next_real_insn
= NULL_RTX
;
21209 /* If there are no instructions which would be affected by this note,
21210 don't do anything. */
21212 && next_real
== NULL_RTX
21213 && !NOTE_DURING_CALL_P (loc_note
))
21216 if (next_real
== NULL_RTX
)
21217 next_real
= get_last_insn ();
21219 /* If there were any real insns between note we processed last time
21220 and this note (or if it is the first note), clear
21221 last_{,postcall_}label so that they are not reused this time. */
21222 if (last_var_location_insn
== NULL_RTX
21223 || last_var_location_insn
!= next_real
21224 || last_in_cold_section_p
!= in_cold_section_p
)
21227 last_postcall_label
= NULL
;
21232 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
21233 newloc
= add_var_loc_to_decl (decl
, loc_note
,
21234 NOTE_DURING_CALL_P (loc_note
)
21235 ? last_postcall_label
: last_label
);
21236 if (newloc
== NULL
)
21245 /* If there were no real insns between note we processed last time
21246 and this note, use the label we emitted last time. Otherwise
21247 create a new label and emit it. */
21248 if (last_label
== NULL
)
21250 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
21251 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
21253 last_label
= ggc_strdup (loclabel
);
21254 /* See if loclabel might be equal to .Ltext0. If yes,
21255 bump first_loclabel_num_not_at_text_label. */
21256 if (!have_multiple_function_sections
21257 && in_first_function_p
21258 && maybe_at_text_label_p
)
21260 static rtx last_start
;
21262 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
21263 if (insn
== last_start
)
21265 else if (!NONDEBUG_INSN_P (insn
))
21269 rtx body
= PATTERN (insn
);
21270 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
21272 /* Inline asm could occupy zero bytes. */
21273 else if (GET_CODE (body
) == ASM_INPUT
21274 || asm_noperands (body
) >= 0)
21276 #ifdef HAVE_attr_length
21277 else if (get_attr_min_length (insn
) == 0)
21282 /* Assume insn has non-zero length. */
21283 maybe_at_text_label_p
= false;
21287 if (maybe_at_text_label_p
)
21289 last_start
= loc_note
;
21290 first_loclabel_num_not_at_text_label
= loclabel_num
;
21297 struct call_arg_loc_node
*ca_loc
21298 = ggc_alloc_cleared_call_arg_loc_node ();
21299 rtx prev
= prev_real_insn (loc_note
), x
;
21300 ca_loc
->call_arg_loc_note
= loc_note
;
21301 ca_loc
->next
= NULL
;
21302 ca_loc
->label
= last_label
;
21305 || (NONJUMP_INSN_P (prev
)
21306 && GET_CODE (PATTERN (prev
)) == SEQUENCE
21307 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
21308 if (!CALL_P (prev
))
21309 prev
= XVECEXP (PATTERN (prev
), 0, 0);
21310 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
21311 x
= get_call_rtx_from (PATTERN (prev
));
21314 x
= XEXP (XEXP (x
, 0), 0);
21315 if (GET_CODE (x
) == SYMBOL_REF
21316 && SYMBOL_REF_DECL (x
)
21317 && TREE_CODE (SYMBOL_REF_DECL (x
)) == FUNCTION_DECL
)
21318 ca_loc
->symbol_ref
= x
;
21320 ca_loc
->block
= insn_scope (prev
);
21321 if (call_arg_locations
)
21322 call_arg_loc_last
->next
= ca_loc
;
21324 call_arg_locations
= ca_loc
;
21325 call_arg_loc_last
= ca_loc
;
21327 else if (!NOTE_DURING_CALL_P (loc_note
))
21328 newloc
->label
= last_label
;
21331 if (!last_postcall_label
)
21333 sprintf (loclabel
, "%s-1", last_label
);
21334 last_postcall_label
= ggc_strdup (loclabel
);
21336 newloc
->label
= last_postcall_label
;
21339 last_var_location_insn
= next_real
;
21340 last_in_cold_section_p
= in_cold_section_p
;
21343 /* Note in one location list that text section has changed. */
21346 var_location_switch_text_section_1 (void **slot
, void *data ATTRIBUTE_UNUSED
)
21348 var_loc_list
*list
= (var_loc_list
*) *slot
;
21350 list
->last_before_switch
21351 = list
->last
->next
? list
->last
->next
: list
->last
;
21355 /* Note in all location lists that text section has changed. */
21358 var_location_switch_text_section (void)
21360 if (decl_loc_table
== NULL
)
21363 htab_traverse (decl_loc_table
, var_location_switch_text_section_1
, NULL
);
21366 /* Create a new line number table. */
21368 static dw_line_info_table
*
21369 new_line_info_table (void)
21371 dw_line_info_table
*table
;
21373 table
= ggc_alloc_cleared_dw_line_info_table_struct ();
21374 table
->file_num
= 1;
21375 table
->line_num
= 1;
21376 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
21381 /* Lookup the "current" table into which we emit line info, so
21382 that we don't have to do it for every source line. */
21385 set_cur_line_info_table (section
*sec
)
21387 dw_line_info_table
*table
;
21389 if (sec
== text_section
)
21390 table
= text_section_line_info
;
21391 else if (sec
== cold_text_section
)
21393 table
= cold_text_section_line_info
;
21396 cold_text_section_line_info
= table
= new_line_info_table ();
21397 table
->end_label
= cold_end_label
;
21402 const char *end_label
;
21404 if (flag_reorder_blocks_and_partition
)
21406 if (in_cold_section_p
)
21407 end_label
= crtl
->subsections
.cold_section_end_label
;
21409 end_label
= crtl
->subsections
.hot_section_end_label
;
21413 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21414 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
21415 current_function_funcdef_no
);
21416 end_label
= ggc_strdup (label
);
21419 table
= new_line_info_table ();
21420 table
->end_label
= end_label
;
21422 vec_safe_push (separate_line_info
, table
);
21425 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21426 table
->is_stmt
= (cur_line_info_table
21427 ? cur_line_info_table
->is_stmt
21428 : DWARF_LINE_DEFAULT_IS_STMT_START
);
21429 cur_line_info_table
= table
;
21433 /* We need to reset the locations at the beginning of each
21434 function. We can't do this in the end_function hook, because the
21435 declarations that use the locations won't have been output when
21436 that hook is called. Also compute have_multiple_function_sections here. */
21439 dwarf2out_begin_function (tree fun
)
21441 section
*sec
= function_section (fun
);
21443 if (sec
!= text_section
)
21444 have_multiple_function_sections
= true;
21446 if (flag_reorder_blocks_and_partition
&& !cold_text_section
)
21448 gcc_assert (current_function_decl
== fun
);
21449 cold_text_section
= unlikely_text_section ();
21450 switch_to_section (cold_text_section
);
21451 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
21452 switch_to_section (sec
);
21455 dwarf2out_note_section_used ();
21456 call_site_count
= 0;
21457 tail_call_site_count
= 0;
21459 set_cur_line_info_table (sec
);
21462 /* Helper function of dwarf2out_end_function, called only after emitting
21463 the very first function into assembly. Check if some .debug_loc range
21464 might end with a .LVL* label that could be equal to .Ltext0.
21465 In that case we must force using absolute addresses in .debug_loc ranges,
21466 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
21467 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
21469 Set have_multiple_function_sections to true in that case and
21470 terminate htab traversal. */
21473 find_empty_loc_ranges_at_text_label (void **slot
, void *)
21475 var_loc_list
*entry
;
21476 struct var_loc_node
*node
;
21478 entry
= (var_loc_list
*) *slot
;
21479 node
= entry
->first
;
21480 if (node
&& node
->next
&& node
->next
->label
)
21483 const char *label
= node
->next
->label
;
21484 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
21486 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
21488 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
21489 if (strcmp (label
, loclabel
) == 0)
21491 have_multiple_function_sections
= true;
21499 /* Hook called after emitting a function into assembly.
21500 This does something only for the very first function emitted. */
21503 dwarf2out_end_function (unsigned int)
21505 if (in_first_function_p
21506 && !have_multiple_function_sections
21507 && first_loclabel_num_not_at_text_label
21509 htab_traverse (decl_loc_table
, find_empty_loc_ranges_at_text_label
,
21511 in_first_function_p
= false;
21512 maybe_at_text_label_p
= false;
21515 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
21518 push_dw_line_info_entry (dw_line_info_table
*table
,
21519 enum dw_line_info_opcode opcode
, unsigned int val
)
21521 dw_line_info_entry e
;
21524 vec_safe_push (table
->entries
, e
);
21527 /* Output a label to mark the beginning of a source code line entry
21528 and record information relating to this source line, in
21529 'line_info_table' for later output of the .debug_line section. */
21530 /* ??? The discriminator parameter ought to be unsigned. */
21533 dwarf2out_source_line (unsigned int line
, const char *filename
,
21534 int discriminator
, bool is_stmt
)
21536 unsigned int file_num
;
21537 dw_line_info_table
*table
;
21539 if (debug_info_level
< DINFO_LEVEL_TERSE
|| line
== 0)
21542 /* The discriminator column was added in dwarf4. Simplify the below
21543 by simply removing it if we're not supposed to output it. */
21544 if (dwarf_version
< 4 && dwarf_strict
)
21547 table
= cur_line_info_table
;
21548 file_num
= maybe_emit_file (lookup_filename (filename
));
21550 /* ??? TODO: Elide duplicate line number entries. Traditionally,
21551 the debugger has used the second (possibly duplicate) line number
21552 at the beginning of the function to mark the end of the prologue.
21553 We could eliminate any other duplicates within the function. For
21554 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
21555 that second line number entry. */
21556 /* Recall that this end-of-prologue indication is *not* the same thing
21557 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
21558 to which the hook corresponds, follows the last insn that was
21559 emitted by gen_prologue. What we need is to precede the first insn
21560 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
21561 insn that corresponds to something the user wrote. These may be
21562 very different locations once scheduling is enabled. */
21564 if (0 && file_num
== table
->file_num
21565 && line
== table
->line_num
21566 && discriminator
== table
->discrim_num
21567 && is_stmt
== table
->is_stmt
)
21570 switch_to_section (current_function_section ());
21572 /* If requested, emit something human-readable. */
21573 if (flag_debug_asm
)
21574 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
, filename
, line
);
21576 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21578 /* Emit the .loc directive understood by GNU as. */
21579 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
21580 file_num, line, is_stmt, discriminator */
21581 fputs ("\t.loc ", asm_out_file
);
21582 fprint_ul (asm_out_file
, file_num
);
21583 putc (' ', asm_out_file
);
21584 fprint_ul (asm_out_file
, line
);
21585 putc (' ', asm_out_file
);
21586 putc ('0', asm_out_file
);
21588 if (is_stmt
!= table
->is_stmt
)
21590 fputs (" is_stmt ", asm_out_file
);
21591 putc (is_stmt
? '1' : '0', asm_out_file
);
21593 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
21595 gcc_assert (discriminator
> 0);
21596 fputs (" discriminator ", asm_out_file
);
21597 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
21599 putc ('\n', asm_out_file
);
21603 unsigned int label_num
= ++line_info_label_num
;
21605 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
21607 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
21608 if (file_num
!= table
->file_num
)
21609 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
21610 if (discriminator
!= table
->discrim_num
)
21611 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
21612 if (is_stmt
!= table
->is_stmt
)
21613 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
21614 push_dw_line_info_entry (table
, LI_set_line
, line
);
21617 table
->file_num
= file_num
;
21618 table
->line_num
= line
;
21619 table
->discrim_num
= discriminator
;
21620 table
->is_stmt
= is_stmt
;
21621 table
->in_use
= true;
21624 /* Record the beginning of a new source file. */
21627 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
21629 if (flag_eliminate_dwarf2_dups
)
21631 /* Record the beginning of the file for break_out_includes. */
21632 dw_die_ref bincl_die
;
21634 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die (), NULL
);
21635 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
21638 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21641 e
.code
= DW_MACINFO_start_file
;
21643 e
.info
= ggc_strdup (filename
);
21644 vec_safe_push (macinfo_table
, e
);
21648 /* Record the end of a source file. */
21651 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
21653 if (flag_eliminate_dwarf2_dups
)
21654 /* Record the end of the file for break_out_includes. */
21655 new_die (DW_TAG_GNU_EINCL
, comp_unit_die (), NULL
);
21657 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21660 e
.code
= DW_MACINFO_end_file
;
21663 vec_safe_push (macinfo_table
, e
);
21667 /* Called from debug_define in toplev.c. The `buffer' parameter contains
21668 the tail part of the directive line, i.e. the part which is past the
21669 initial whitespace, #, whitespace, directive-name, whitespace part. */
21672 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
21673 const char *buffer ATTRIBUTE_UNUSED
)
21675 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21678 /* Insert a dummy first entry to be able to optimize the whole
21679 predefined macro block using DW_MACRO_GNU_transparent_include. */
21680 if (macinfo_table
->is_empty () && lineno
<= 1)
21685 vec_safe_push (macinfo_table
, e
);
21687 e
.code
= DW_MACINFO_define
;
21689 e
.info
= ggc_strdup (buffer
);
21690 vec_safe_push (macinfo_table
, e
);
21694 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
21695 the tail part of the directive line, i.e. the part which is past the
21696 initial whitespace, #, whitespace, directive-name, whitespace part. */
21699 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
21700 const char *buffer ATTRIBUTE_UNUSED
)
21702 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21705 /* Insert a dummy first entry to be able to optimize the whole
21706 predefined macro block using DW_MACRO_GNU_transparent_include. */
21707 if (macinfo_table
->is_empty () && lineno
<= 1)
21712 vec_safe_push (macinfo_table
, e
);
21714 e
.code
= DW_MACINFO_undef
;
21716 e
.info
= ggc_strdup (buffer
);
21717 vec_safe_push (macinfo_table
, e
);
21721 /* Helpers to manipulate hash table of CUs. */
21723 struct macinfo_entry_hasher
: typed_noop_remove
<macinfo_entry
>
21725 typedef macinfo_entry value_type
;
21726 typedef macinfo_entry compare_type
;
21727 static inline hashval_t
hash (const value_type
*);
21728 static inline bool equal (const value_type
*, const compare_type
*);
21732 macinfo_entry_hasher::hash (const value_type
*entry
)
21734 return htab_hash_string (entry
->info
);
21738 macinfo_entry_hasher::equal (const value_type
*entry1
,
21739 const compare_type
*entry2
)
21741 return !strcmp (entry1
->info
, entry2
->info
);
21744 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
21746 /* Output a single .debug_macinfo entry. */
21749 output_macinfo_op (macinfo_entry
*ref
)
21753 struct indirect_string_node
*node
;
21754 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21755 struct dwarf_file_data
*fd
;
21759 case DW_MACINFO_start_file
:
21760 fd
= lookup_filename (ref
->info
);
21761 file_num
= maybe_emit_file (fd
);
21762 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
21763 dw2_asm_output_data_uleb128 (ref
->lineno
,
21764 "Included from line number %lu",
21765 (unsigned long) ref
->lineno
);
21766 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
21768 case DW_MACINFO_end_file
:
21769 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
21771 case DW_MACINFO_define
:
21772 case DW_MACINFO_undef
:
21773 len
= strlen (ref
->info
) + 1;
21775 && len
> DWARF_OFFSET_SIZE
21776 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
21777 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
21779 ref
->code
= ref
->code
== DW_MACINFO_define
21780 ? DW_MACRO_GNU_define_indirect
21781 : DW_MACRO_GNU_undef_indirect
;
21782 output_macinfo_op (ref
);
21785 dw2_asm_output_data (1, ref
->code
,
21786 ref
->code
== DW_MACINFO_define
21787 ? "Define macro" : "Undefine macro");
21788 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21789 (unsigned long) ref
->lineno
);
21790 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
21792 case DW_MACRO_GNU_define_indirect
:
21793 case DW_MACRO_GNU_undef_indirect
:
21794 node
= find_AT_string (ref
->info
);
21796 && ((node
->form
== DW_FORM_strp
)
21797 || (node
->form
== DW_FORM_GNU_str_index
)));
21798 dw2_asm_output_data (1, ref
->code
,
21799 ref
->code
== DW_MACRO_GNU_define_indirect
21800 ? "Define macro indirect"
21801 : "Undefine macro indirect");
21802 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
21803 (unsigned long) ref
->lineno
);
21804 if (node
->form
== DW_FORM_strp
)
21805 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
21806 debug_str_section
, "The macro: \"%s\"",
21809 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
21812 case DW_MACRO_GNU_transparent_include
:
21813 dw2_asm_output_data (1, ref
->code
, "Transparent include");
21814 ASM_GENERATE_INTERNAL_LABEL (label
,
21815 DEBUG_MACRO_SECTION_LABEL
, ref
->lineno
);
21816 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
21819 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
21820 ASM_COMMENT_START
, (unsigned long) ref
->code
);
21825 /* Attempt to make a sequence of define/undef macinfo ops shareable with
21826 other compilation unit .debug_macinfo sections. IDX is the first
21827 index of a define/undef, return the number of ops that should be
21828 emitted in a comdat .debug_macinfo section and emit
21829 a DW_MACRO_GNU_transparent_include entry referencing it.
21830 If the define/undef entry should be emitted normally, return 0. */
21833 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
21834 macinfo_hash_type
*macinfo_htab
)
21836 macinfo_entry
*first
, *second
, *cur
, *inc
;
21837 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
21838 unsigned char checksum
[16];
21839 struct md5_ctx ctx
;
21840 char *grp_name
, *tail
;
21842 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
21843 macinfo_entry
**slot
;
21845 first
= &(*macinfo_table
)[idx
];
21846 second
= &(*macinfo_table
)[idx
+ 1];
21848 /* Optimize only if there are at least two consecutive define/undef ops,
21849 and either all of them are before first DW_MACINFO_start_file
21850 with lineno {0,1} (i.e. predefined macro block), or all of them are
21851 in some included header file. */
21852 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
21854 if (vec_safe_is_empty (files
))
21856 if (first
->lineno
> 1 || second
->lineno
> 1)
21859 else if (first
->lineno
== 0)
21862 /* Find the last define/undef entry that can be grouped together
21863 with first and at the same time compute md5 checksum of their
21864 codes, linenumbers and strings. */
21865 md5_init_ctx (&ctx
);
21866 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
21867 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
21869 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
21873 unsigned char code
= cur
->code
;
21874 md5_process_bytes (&code
, 1, &ctx
);
21875 checksum_uleb128 (cur
->lineno
, &ctx
);
21876 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
21878 md5_finish_ctx (&ctx
, checksum
);
21881 /* From the containing include filename (if any) pick up just
21882 usable characters from its basename. */
21883 if (vec_safe_is_empty (files
))
21886 base
= lbasename (files
->last ().info
);
21887 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
21888 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
21889 encoded_filename_len
++;
21890 /* Count . at the end. */
21891 if (encoded_filename_len
)
21892 encoded_filename_len
++;
21894 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
21895 linebuf_len
= strlen (linebuf
);
21897 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
21898 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
21900 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
21901 tail
= grp_name
+ 4;
21902 if (encoded_filename_len
)
21904 for (i
= 0; base
[i
]; i
++)
21905 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
21909 memcpy (tail
, linebuf
, linebuf_len
);
21910 tail
+= linebuf_len
;
21912 for (i
= 0; i
< 16; i
++)
21913 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
21915 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
21916 in the empty vector entry before the first define/undef. */
21917 inc
= &(*macinfo_table
)[idx
- 1];
21918 inc
->code
= DW_MACRO_GNU_transparent_include
;
21920 inc
->info
= ggc_strdup (grp_name
);
21921 if (!macinfo_htab
->is_created ())
21922 macinfo_htab
->create (10);
21923 /* Avoid emitting duplicates. */
21924 slot
= macinfo_htab
->find_slot (inc
, INSERT
);
21929 /* If such an entry has been used before, just emit
21930 a DW_MACRO_GNU_transparent_include op. */
21932 output_macinfo_op (inc
);
21933 /* And clear all macinfo_entry in the range to avoid emitting them
21934 in the second pass. */
21935 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
21944 inc
->lineno
= macinfo_htab
->elements ();
21945 output_macinfo_op (inc
);
21950 /* Save any strings needed by the macinfo table in the debug str
21951 table. All strings must be collected into the table by the time
21952 index_string is called. */
21955 save_macinfo_strings (void)
21959 macinfo_entry
*ref
;
21961 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
21965 /* Match the logic in output_macinfo_op to decide on
21966 indirect strings. */
21967 case DW_MACINFO_define
:
21968 case DW_MACINFO_undef
:
21969 len
= strlen (ref
->info
) + 1;
21971 && len
> DWARF_OFFSET_SIZE
21972 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
21973 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
21974 set_indirect_string (find_AT_string (ref
->info
));
21976 case DW_MACRO_GNU_define_indirect
:
21977 case DW_MACRO_GNU_undef_indirect
:
21978 set_indirect_string (find_AT_string (ref
->info
));
21986 /* Output macinfo section(s). */
21989 output_macinfo (void)
21992 unsigned long length
= vec_safe_length (macinfo_table
);
21993 macinfo_entry
*ref
;
21994 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
21995 macinfo_hash_type macinfo_htab
;
22000 /* output_macinfo* uses these interchangeably. */
22001 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_GNU_define
22002 && (int) DW_MACINFO_undef
== (int) DW_MACRO_GNU_undef
22003 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_GNU_start_file
22004 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_GNU_end_file
);
22006 /* For .debug_macro emit the section header. */
22009 dw2_asm_output_data (2, 4, "DWARF macro version number");
22010 if (DWARF_OFFSET_SIZE
== 8)
22011 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
22013 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
22014 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
22015 (!dwarf_split_debug_info
? debug_line_section_label
22016 : debug_skeleton_line_section_label
),
22017 debug_line_section
, NULL
);
22020 /* In the first loop, it emits the primary .debug_macinfo section
22021 and after each emitted op the macinfo_entry is cleared.
22022 If a longer range of define/undef ops can be optimized using
22023 DW_MACRO_GNU_transparent_include, the
22024 DW_MACRO_GNU_transparent_include op is emitted and kept in
22025 the vector before the first define/undef in the range and the
22026 whole range of define/undef ops is not emitted and kept. */
22027 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22031 case DW_MACINFO_start_file
:
22032 vec_safe_push (files
, *ref
);
22034 case DW_MACINFO_end_file
:
22035 if (!vec_safe_is_empty (files
))
22038 case DW_MACINFO_define
:
22039 case DW_MACINFO_undef
:
22041 && HAVE_COMDAT_GROUP
22042 && vec_safe_length (files
) != 1
22045 && (*macinfo_table
)[i
- 1].code
== 0)
22047 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
22056 /* A dummy entry may be inserted at the beginning to be able
22057 to optimize the whole block of predefined macros. */
22063 output_macinfo_op (ref
);
22068 if (!macinfo_htab
.is_created ())
22071 macinfo_htab
.dispose ();
22073 /* If any DW_MACRO_GNU_transparent_include were used, on those
22074 DW_MACRO_GNU_transparent_include entries terminate the
22075 current chain and switch to a new comdat .debug_macinfo
22076 section and emit the define/undef entries within it. */
22077 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
22082 case DW_MACRO_GNU_transparent_include
:
22084 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
22085 tree comdat_key
= get_identifier (ref
->info
);
22086 /* Terminate the previous .debug_macinfo section. */
22087 dw2_asm_output_data (1, 0, "End compilation unit");
22088 targetm
.asm_out
.named_section (DEBUG_MACRO_SECTION
,
22090 | SECTION_LINKONCE
,
22092 ASM_GENERATE_INTERNAL_LABEL (label
,
22093 DEBUG_MACRO_SECTION_LABEL
,
22095 ASM_OUTPUT_LABEL (asm_out_file
, label
);
22098 dw2_asm_output_data (2, 4, "DWARF macro version number");
22099 if (DWARF_OFFSET_SIZE
== 8)
22100 dw2_asm_output_data (1, 1, "Flags: 64-bit");
22102 dw2_asm_output_data (1, 0, "Flags: 32-bit");
22105 case DW_MACINFO_define
:
22106 case DW_MACINFO_undef
:
22107 output_macinfo_op (ref
);
22112 gcc_unreachable ();
22116 /* Set up for Dwarf output at the start of compilation. */
22119 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
22121 /* Allocate the file_table. */
22122 file_table
= htab_create_ggc (50, file_table_hash
,
22123 file_table_eq
, NULL
);
22125 /* Allocate the decl_die_table. */
22126 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
22127 decl_die_table_eq
, NULL
);
22129 /* Allocate the decl_loc_table. */
22130 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
22131 decl_loc_table_eq
, NULL
);
22133 /* Allocate the cached_dw_loc_list_table. */
22134 cached_dw_loc_list_table
22135 = htab_create_ggc (10, cached_dw_loc_list_table_hash
,
22136 cached_dw_loc_list_table_eq
, NULL
);
22138 /* Allocate the initial hunk of the decl_scope_table. */
22139 vec_alloc (decl_scope_table
, 256);
22141 /* Allocate the initial hunk of the abbrev_die_table. */
22142 abbrev_die_table
= ggc_alloc_cleared_vec_dw_die_ref
22143 (ABBREV_DIE_TABLE_INCREMENT
);
22144 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
22145 /* Zero-th entry is allocated, but unused. */
22146 abbrev_die_table_in_use
= 1;
22148 /* Allocate the pubtypes and pubnames vectors. */
22149 vec_alloc (pubname_table
, 32);
22150 vec_alloc (pubtype_table
, 32);
22152 vec_alloc (incomplete_types
, 64);
22154 vec_alloc (used_rtx_array
, 32);
22156 if (!dwarf_split_debug_info
)
22158 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
22159 SECTION_DEBUG
, NULL
);
22160 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22161 SECTION_DEBUG
, NULL
);
22162 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
22163 SECTION_DEBUG
, NULL
);
22167 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
22168 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22169 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
22170 SECTION_DEBUG
| SECTION_EXCLUDE
,
22172 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
22173 SECTION_DEBUG
, NULL
);
22174 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
22175 SECTION_DEBUG
, NULL
);
22176 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
22177 SECTION_DEBUG
, NULL
);
22178 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
22179 DEBUG_SKELETON_ABBREV_SECTION_LABEL
, 0);
22181 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
22182 the main .o, but the skeleton_line goes into the split off dwo. */
22183 debug_skeleton_line_section
22184 = get_section (DEBUG_DWO_LINE_SECTION
,
22185 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22186 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
22187 DEBUG_SKELETON_LINE_SECTION_LABEL
, 0);
22188 debug_str_offsets_section
= get_section (DEBUG_STR_OFFSETS_SECTION
,
22189 SECTION_DEBUG
| SECTION_EXCLUDE
,
22191 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
22192 DEBUG_SKELETON_INFO_SECTION_LABEL
, 0);
22193 debug_loc_section
= get_section (DEBUG_DWO_LOC_SECTION
,
22194 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
22195 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
22196 DEBUG_STR_DWO_SECTION_FLAGS
, NULL
);
22198 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
22199 SECTION_DEBUG
, NULL
);
22200 debug_macinfo_section
= get_section (dwarf_strict
22201 ? DEBUG_MACINFO_SECTION
22202 : DEBUG_MACRO_SECTION
,
22203 DEBUG_MACRO_SECTION_FLAGS
, NULL
);
22204 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
22205 SECTION_DEBUG
, NULL
);
22206 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
22207 SECTION_DEBUG
, NULL
);
22208 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
22209 SECTION_DEBUG
, NULL
);
22210 debug_str_section
= get_section (DEBUG_STR_SECTION
,
22211 DEBUG_STR_SECTION_FLAGS
, NULL
);
22212 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
22213 SECTION_DEBUG
, NULL
);
22214 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
22215 SECTION_DEBUG
, NULL
);
22217 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
22218 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
22219 DEBUG_ABBREV_SECTION_LABEL
, 0);
22220 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
22221 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
22222 COLD_TEXT_SECTION_LABEL
, 0);
22223 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
22225 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
22226 DEBUG_INFO_SECTION_LABEL
, 0);
22227 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
22228 DEBUG_LINE_SECTION_LABEL
, 0);
22229 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
22230 DEBUG_RANGES_SECTION_LABEL
, 0);
22231 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
22232 DEBUG_ADDR_SECTION_LABEL
, 0);
22233 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
22235 ? DEBUG_MACINFO_SECTION_LABEL
22236 : DEBUG_MACRO_SECTION_LABEL
, 0);
22237 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
, 0);
22239 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22240 vec_alloc (macinfo_table
, 64);
22242 switch_to_section (text_section
);
22243 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
22245 /* Make sure the line number table for .text always exists. */
22246 text_section_line_info
= new_line_info_table ();
22247 text_section_line_info
->end_label
= text_end_label
;
22250 /* Called before compile () starts outputtting functions, variables
22251 and toplevel asms into assembly. */
22254 dwarf2out_assembly_start (void)
22256 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
22257 && dwarf2out_do_cfi_asm ()
22258 && (!(flag_unwind_tables
|| flag_exceptions
)
22259 || targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
))
22260 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
22263 /* A helper function for dwarf2out_finish called through
22264 htab_traverse. Assign a string its index. All strings must be
22265 collected into the table by the time index_string is called,
22266 because the indexing code relies on htab_traverse to traverse nodes
22267 in the same order for each run. */
22270 index_string (void **h
, void *v
)
22272 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22273 unsigned int *index
= (unsigned int *) v
;
22275 find_string_form (node
);
22276 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22278 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
22279 node
->index
= *index
;
22285 /* A helper function for output_indirect_strings called through
22286 htab_traverse. Output the offset to a string and update the
22290 output_index_string_offset (void **h
, void *v
)
22292 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22293 unsigned int *offset
= (unsigned int *) v
;
22295 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22297 /* Assert that this node has been assigned an index. */
22298 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
22299 && node
->index
!= NOT_INDEXED
);
22300 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
22301 "indexed string 0x%x: %s", node
->index
, node
->str
);
22302 *offset
+= strlen (node
->str
) + 1;
22307 /* A helper function for dwarf2out_finish called through
22308 htab_traverse. Output the indexed string. */
22311 output_index_string (void **h
, void *v
)
22313 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22314 unsigned int *cur_idx
= (unsigned int *) v
;
22316 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
22318 /* Assert that the strings are output in the same order as their
22319 indexes were assigned. */
22320 gcc_assert (*cur_idx
== node
->index
);
22321 assemble_string (node
->str
, strlen (node
->str
) + 1);
22327 /* A helper function for dwarf2out_finish called through
22328 htab_traverse. Emit one queued .debug_str string. */
22331 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
22333 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
22335 node
->form
= find_string_form (node
);
22336 if (node
->form
== DW_FORM_strp
&& node
->refcount
> 0)
22338 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
22339 assemble_string (node
->str
, strlen (node
->str
) + 1);
22345 /* Output the indexed string table. */
22348 output_indirect_strings (void)
22350 switch_to_section (debug_str_section
);
22351 if (!dwarf_split_debug_info
)
22352 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
22355 unsigned int offset
= 0;
22356 unsigned int cur_idx
= 0;
22358 htab_traverse (skeleton_debug_str_hash
, output_indirect_string
, NULL
);
22360 switch_to_section (debug_str_offsets_section
);
22361 htab_traverse_noresize (debug_str_hash
,
22362 output_index_string_offset
,
22364 switch_to_section (debug_str_dwo_section
);
22365 htab_traverse_noresize (debug_str_hash
,
22366 output_index_string
,
22371 /* Callback for htab_traverse to assign an index to an entry in the
22372 table, and to write that entry to the .debug_addr section. */
22375 output_addr_table_entry (void **slot
, void *data
)
22377 addr_table_entry
*entry
= (addr_table_entry
*) *slot
;
22378 unsigned int *cur_index
= (unsigned int *)data
;
22380 if (entry
->refcount
== 0)
22382 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
22383 || entry
->index
== NOT_INDEXED
);
22387 gcc_assert (entry
->index
== *cur_index
);
22390 switch (entry
->kind
)
22393 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
22394 "0x%x", entry
->index
);
22396 case ate_kind_rtx_dtprel
:
22397 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
22398 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
22401 fputc ('\n', asm_out_file
);
22403 case ate_kind_label
:
22404 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
22405 "0x%x", entry
->index
);
22408 gcc_unreachable ();
22413 /* Produce the .debug_addr section. */
22416 output_addr_table (void)
22418 unsigned int index
= 0;
22419 if (addr_index_table
== NULL
|| htab_size (addr_index_table
) == 0)
22422 switch_to_section (debug_addr_section
);
22423 htab_traverse_noresize (addr_index_table
, output_addr_table_entry
, &index
);
22426 #if ENABLE_ASSERT_CHECKING
22427 /* Verify that all marks are clear. */
22430 verify_marks_clear (dw_die_ref die
)
22434 gcc_assert (! die
->die_mark
);
22435 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
22437 #endif /* ENABLE_ASSERT_CHECKING */
22439 /* Clear the marks for a die and its children.
22440 Be cool if the mark isn't set. */
22443 prune_unmark_dies (dw_die_ref die
)
22449 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
22452 /* Given DIE that we're marking as used, find any other dies
22453 it references as attributes and mark them as used. */
22456 prune_unused_types_walk_attribs (dw_die_ref die
)
22461 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22463 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
22465 /* A reference to another DIE.
22466 Make sure that it will get emitted.
22467 If it was broken out into a comdat group, don't follow it. */
22468 if (! AT_ref (a
)->comdat_type_p
22469 || a
->dw_attr
== DW_AT_specification
)
22470 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
22472 /* Set the string's refcount to 0 so that prune_unused_types_mark
22473 accounts properly for it. */
22474 if (AT_class (a
) == dw_val_class_str
)
22475 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
22479 /* Mark the generic parameters and arguments children DIEs of DIE. */
22482 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
22486 if (die
== NULL
|| die
->die_child
== NULL
)
22488 c
= die
->die_child
;
22491 if (is_template_parameter (c
))
22492 prune_unused_types_mark (c
, 1);
22494 } while (c
&& c
!= die
->die_child
);
22497 /* Mark DIE as being used. If DOKIDS is true, then walk down
22498 to DIE's children. */
22501 prune_unused_types_mark (dw_die_ref die
, int dokids
)
22505 if (die
->die_mark
== 0)
22507 /* We haven't done this node yet. Mark it as used. */
22509 /* If this is the DIE of a generic type instantiation,
22510 mark the children DIEs that describe its generic parms and
22512 prune_unused_types_mark_generic_parms_dies (die
);
22514 /* We also have to mark its parents as used.
22515 (But we don't want to mark our parent's kids due to this,
22516 unless it is a class.) */
22517 if (die
->die_parent
)
22518 prune_unused_types_mark (die
->die_parent
,
22519 class_scope_p (die
->die_parent
));
22521 /* Mark any referenced nodes. */
22522 prune_unused_types_walk_attribs (die
);
22524 /* If this node is a specification,
22525 also mark the definition, if it exists. */
22526 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
22527 prune_unused_types_mark (die
->die_definition
, 1);
22530 if (dokids
&& die
->die_mark
!= 2)
22532 /* We need to walk the children, but haven't done so yet.
22533 Remember that we've walked the kids. */
22536 /* If this is an array type, we need to make sure our
22537 kids get marked, even if they're types. If we're
22538 breaking out types into comdat sections, do this
22539 for all type definitions. */
22540 if (die
->die_tag
== DW_TAG_array_type
22541 || (use_debug_types
22542 && is_type_die (die
) && ! is_declaration_die (die
)))
22543 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
22545 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22549 /* For local classes, look if any static member functions were emitted
22550 and if so, mark them. */
22553 prune_unused_types_walk_local_classes (dw_die_ref die
)
22557 if (die
->die_mark
== 2)
22560 switch (die
->die_tag
)
22562 case DW_TAG_structure_type
:
22563 case DW_TAG_union_type
:
22564 case DW_TAG_class_type
:
22567 case DW_TAG_subprogram
:
22568 if (!get_AT_flag (die
, DW_AT_declaration
)
22569 || die
->die_definition
!= NULL
)
22570 prune_unused_types_mark (die
, 1);
22577 /* Mark children. */
22578 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
22581 /* Walk the tree DIE and mark types that we actually use. */
22584 prune_unused_types_walk (dw_die_ref die
)
22588 /* Don't do anything if this node is already marked and
22589 children have been marked as well. */
22590 if (die
->die_mark
== 2)
22593 switch (die
->die_tag
)
22595 case DW_TAG_structure_type
:
22596 case DW_TAG_union_type
:
22597 case DW_TAG_class_type
:
22598 if (die
->die_perennial_p
)
22601 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
22602 if (c
->die_tag
== DW_TAG_subprogram
)
22605 /* Finding used static member functions inside of classes
22606 is needed just for local classes, because for other classes
22607 static member function DIEs with DW_AT_specification
22608 are emitted outside of the DW_TAG_*_type. If we ever change
22609 it, we'd need to call this even for non-local classes. */
22611 prune_unused_types_walk_local_classes (die
);
22613 /* It's a type node --- don't mark it. */
22616 case DW_TAG_const_type
:
22617 case DW_TAG_packed_type
:
22618 case DW_TAG_pointer_type
:
22619 case DW_TAG_reference_type
:
22620 case DW_TAG_rvalue_reference_type
:
22621 case DW_TAG_volatile_type
:
22622 case DW_TAG_typedef
:
22623 case DW_TAG_array_type
:
22624 case DW_TAG_interface_type
:
22625 case DW_TAG_friend
:
22626 case DW_TAG_variant_part
:
22627 case DW_TAG_enumeration_type
:
22628 case DW_TAG_subroutine_type
:
22629 case DW_TAG_string_type
:
22630 case DW_TAG_set_type
:
22631 case DW_TAG_subrange_type
:
22632 case DW_TAG_ptr_to_member_type
:
22633 case DW_TAG_file_type
:
22634 if (die
->die_perennial_p
)
22637 /* It's a type node --- don't mark it. */
22641 /* Mark everything else. */
22645 if (die
->die_mark
== 0)
22649 /* Now, mark any dies referenced from here. */
22650 prune_unused_types_walk_attribs (die
);
22655 /* Mark children. */
22656 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
22659 /* Increment the string counts on strings referred to from DIE's
22663 prune_unused_types_update_strings (dw_die_ref die
)
22668 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
22669 if (AT_class (a
) == dw_val_class_str
)
22671 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
22673 /* Avoid unnecessarily putting strings that are used less than
22674 twice in the hash table. */
22676 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
22679 slot
= htab_find_slot_with_hash (debug_str_hash
, s
->str
,
22680 htab_hash_string (s
->str
),
22682 gcc_assert (*slot
== NULL
);
22688 /* Remove from the tree DIE any dies that aren't marked. */
22691 prune_unused_types_prune (dw_die_ref die
)
22695 gcc_assert (die
->die_mark
);
22696 prune_unused_types_update_strings (die
);
22698 if (! die
->die_child
)
22701 c
= die
->die_child
;
22703 dw_die_ref prev
= c
;
22704 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
22705 if (c
== die
->die_child
)
22707 /* No marked children between 'prev' and the end of the list. */
22709 /* No marked children at all. */
22710 die
->die_child
= NULL
;
22713 prev
->die_sib
= c
->die_sib
;
22714 die
->die_child
= prev
;
22719 if (c
!= prev
->die_sib
)
22721 prune_unused_types_prune (c
);
22722 } while (c
!= die
->die_child
);
22725 /* Remove dies representing declarations that we never use. */
22728 prune_unused_types (void)
22731 limbo_die_node
*node
;
22732 comdat_type_node
*ctnode
;
22734 dw_die_ref base_type
;
22736 #if ENABLE_ASSERT_CHECKING
22737 /* All the marks should already be clear. */
22738 verify_marks_clear (comp_unit_die ());
22739 for (node
= limbo_die_list
; node
; node
= node
->next
)
22740 verify_marks_clear (node
->die
);
22741 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22742 verify_marks_clear (ctnode
->root_die
);
22743 #endif /* ENABLE_ASSERT_CHECKING */
22745 /* Mark types that are used in global variables. */
22746 premark_types_used_by_global_vars ();
22748 /* Set the mark on nodes that are actually used. */
22749 prune_unused_types_walk (comp_unit_die ());
22750 for (node
= limbo_die_list
; node
; node
= node
->next
)
22751 prune_unused_types_walk (node
->die
);
22752 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22754 prune_unused_types_walk (ctnode
->root_die
);
22755 prune_unused_types_mark (ctnode
->type_die
, 1);
22758 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
22759 are unusual in that they are pubnames that are the children of pubtypes.
22760 They should only be marked via their parent DW_TAG_enumeration_type die,
22761 not as roots in themselves. */
22762 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
22763 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
22764 prune_unused_types_mark (pub
->die
, 1);
22765 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
22766 prune_unused_types_mark (base_type
, 1);
22768 if (debug_str_hash
)
22769 htab_empty (debug_str_hash
);
22770 if (skeleton_debug_str_hash
)
22771 htab_empty (skeleton_debug_str_hash
);
22772 prune_unused_types_prune (comp_unit_die ());
22773 for (node
= limbo_die_list
; node
; node
= node
->next
)
22774 prune_unused_types_prune (node
->die
);
22775 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22776 prune_unused_types_prune (ctnode
->root_die
);
22778 /* Leave the marks clear. */
22779 prune_unmark_dies (comp_unit_die ());
22780 for (node
= limbo_die_list
; node
; node
= node
->next
)
22781 prune_unmark_dies (node
->die
);
22782 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
22783 prune_unmark_dies (ctnode
->root_die
);
22786 /* Set the parameter to true if there are any relative pathnames in
22789 file_table_relative_p (void ** slot
, void *param
)
22791 bool *p
= (bool *) param
;
22792 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
22793 if (!IS_ABSOLUTE_PATH (d
->filename
))
22801 /* Helpers to manipulate hash table of comdat type units. */
22803 struct comdat_type_hasher
: typed_noop_remove
<comdat_type_node
>
22805 typedef comdat_type_node value_type
;
22806 typedef comdat_type_node compare_type
;
22807 static inline hashval_t
hash (const value_type
*);
22808 static inline bool equal (const value_type
*, const compare_type
*);
22812 comdat_type_hasher::hash (const value_type
*type_node
)
22815 memcpy (&h
, type_node
->signature
, sizeof (h
));
22820 comdat_type_hasher::equal (const value_type
*type_node_1
,
22821 const compare_type
*type_node_2
)
22823 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
22824 DWARF_TYPE_SIGNATURE_SIZE
));
22827 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
22828 to the location it would have been added, should we know its
22829 DECL_ASSEMBLER_NAME when we added other attributes. This will
22830 probably improve compactness of debug info, removing equivalent
22831 abbrevs, and hide any differences caused by deferring the
22832 computation of the assembler name, triggered by e.g. PCH. */
22835 move_linkage_attr (dw_die_ref die
)
22837 unsigned ix
= vec_safe_length (die
->die_attr
);
22838 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
22840 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
22841 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
22845 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
22847 if (prev
->dw_attr
== DW_AT_decl_line
|| prev
->dw_attr
== DW_AT_name
)
22851 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
22853 die
->die_attr
->pop ();
22854 die
->die_attr
->quick_insert (ix
, linkage
);
22858 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
22859 referenced from typed stack ops and count how often they are used. */
22862 mark_base_types (dw_loc_descr_ref loc
)
22864 dw_die_ref base_type
= NULL
;
22866 for (; loc
; loc
= loc
->dw_loc_next
)
22868 switch (loc
->dw_loc_opc
)
22870 case DW_OP_GNU_regval_type
:
22871 case DW_OP_GNU_deref_type
:
22872 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
22874 case DW_OP_GNU_convert
:
22875 case DW_OP_GNU_reinterpret
:
22876 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
22879 case DW_OP_GNU_const_type
:
22880 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
22882 case DW_OP_GNU_entry_value
:
22883 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
22888 gcc_assert (base_type
->die_parent
== comp_unit_die ());
22889 if (base_type
->die_mark
)
22890 base_type
->die_mark
++;
22893 base_types
.safe_push (base_type
);
22894 base_type
->die_mark
= 1;
22899 /* Comparison function for sorting marked base types. */
22902 base_type_cmp (const void *x
, const void *y
)
22904 dw_die_ref dx
= *(const dw_die_ref
*) x
;
22905 dw_die_ref dy
= *(const dw_die_ref
*) y
;
22906 unsigned int byte_size1
, byte_size2
;
22907 unsigned int encoding1
, encoding2
;
22908 if (dx
->die_mark
> dy
->die_mark
)
22910 if (dx
->die_mark
< dy
->die_mark
)
22912 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
22913 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
22914 if (byte_size1
< byte_size2
)
22916 if (byte_size1
> byte_size2
)
22918 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
22919 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
22920 if (encoding1
< encoding2
)
22922 if (encoding1
> encoding2
)
22927 /* Move base types marked by mark_base_types as early as possible
22928 in the CU, sorted by decreasing usage count both to make the
22929 uleb128 references as small as possible and to make sure they
22930 will have die_offset already computed by calc_die_sizes when
22931 sizes of typed stack loc ops is computed. */
22934 move_marked_base_types (void)
22937 dw_die_ref base_type
, die
, c
;
22939 if (base_types
.is_empty ())
22942 /* Sort by decreasing usage count, they will be added again in that
22944 base_types
.qsort (base_type_cmp
);
22945 die
= comp_unit_die ();
22946 c
= die
->die_child
;
22949 dw_die_ref prev
= c
;
22951 while (c
->die_mark
)
22953 remove_child_with_prev (c
, prev
);
22954 /* As base types got marked, there must be at least
22955 one node other than DW_TAG_base_type. */
22956 gcc_assert (c
!= c
->die_sib
);
22960 while (c
!= die
->die_child
);
22961 gcc_assert (die
->die_child
);
22962 c
= die
->die_child
;
22963 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
22965 base_type
->die_mark
= 0;
22966 base_type
->die_sib
= c
->die_sib
;
22967 c
->die_sib
= base_type
;
22972 /* Helper function for resolve_addr, attempt to resolve
22973 one CONST_STRING, return non-zero if not successful. Similarly verify that
22974 SYMBOL_REFs refer to variables emitted in the current CU. */
22977 resolve_one_addr (rtx
*addr
, void *data ATTRIBUTE_UNUSED
)
22981 if (GET_CODE (rtl
) == CONST_STRING
)
22983 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
22984 tree t
= build_string (len
, XSTR (rtl
, 0));
22985 tree tlen
= size_int (len
- 1);
22987 = build_array_type (char_type_node
, build_index_type (tlen
));
22988 rtl
= lookup_constant_def (t
);
22989 if (!rtl
|| !MEM_P (rtl
))
22991 rtl
= XEXP (rtl
, 0);
22992 if (GET_CODE (rtl
) == SYMBOL_REF
22993 && SYMBOL_REF_DECL (rtl
)
22994 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
22996 vec_safe_push (used_rtx_array
, rtl
);
23001 if (GET_CODE (rtl
) == SYMBOL_REF
23002 && SYMBOL_REF_DECL (rtl
))
23004 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
23006 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
23009 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
23013 if (GET_CODE (rtl
) == CONST
23014 && for_each_rtx (&XEXP (rtl
, 0), resolve_one_addr
, NULL
))
23020 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
23021 if possible, and create DW_TAG_dwarf_procedure that can be referenced
23022 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
23025 string_cst_pool_decl (tree t
)
23027 rtx rtl
= output_constant_def (t
, 1);
23028 unsigned char *array
;
23029 dw_loc_descr_ref l
;
23034 if (!rtl
|| !MEM_P (rtl
))
23036 rtl
= XEXP (rtl
, 0);
23037 if (GET_CODE (rtl
) != SYMBOL_REF
23038 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
23041 decl
= SYMBOL_REF_DECL (rtl
);
23042 if (!lookup_decl_die (decl
))
23044 len
= TREE_STRING_LENGTH (t
);
23045 vec_safe_push (used_rtx_array
, rtl
);
23046 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
23047 array
= (unsigned char *) ggc_alloc_atomic (len
);
23048 memcpy (array
, TREE_STRING_POINTER (t
), len
);
23049 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
23050 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
23051 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
23052 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
23053 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
23054 add_AT_loc (ref
, DW_AT_location
, l
);
23055 equate_decl_number_to_die (decl
, ref
);
23060 /* Helper function of resolve_addr_in_expr. LOC is
23061 a DW_OP_addr followed by DW_OP_stack_value, either at the start
23062 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
23063 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
23064 with DW_OP_GNU_implicit_pointer if possible
23065 and return true, if unsuccessful, return false. */
23068 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
23070 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
23071 HOST_WIDE_INT offset
= 0;
23072 dw_die_ref ref
= NULL
;
23075 if (GET_CODE (rtl
) == CONST
23076 && GET_CODE (XEXP (rtl
, 0)) == PLUS
23077 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
23079 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
23080 rtl
= XEXP (XEXP (rtl
, 0), 0);
23082 if (GET_CODE (rtl
) == CONST_STRING
)
23084 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
23085 tree t
= build_string (len
, XSTR (rtl
, 0));
23086 tree tlen
= size_int (len
- 1);
23089 = build_array_type (char_type_node
, build_index_type (tlen
));
23090 rtl
= string_cst_pool_decl (t
);
23094 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
23096 decl
= SYMBOL_REF_DECL (rtl
);
23097 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
23099 ref
= lookup_decl_die (decl
);
23100 if (ref
&& (get_AT (ref
, DW_AT_location
)
23101 || get_AT (ref
, DW_AT_const_value
)))
23103 loc
->dw_loc_opc
= DW_OP_GNU_implicit_pointer
;
23104 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23105 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
23106 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23107 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23108 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23109 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
23117 /* Helper function for resolve_addr, handle one location
23118 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23119 the location list couldn't be resolved. */
23122 resolve_addr_in_expr (dw_loc_descr_ref loc
)
23124 dw_loc_descr_ref keep
= NULL
;
23125 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
23126 switch (loc
->dw_loc_opc
)
23129 if (resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
23132 || prev
->dw_loc_opc
== DW_OP_piece
23133 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
23134 && loc
->dw_loc_next
23135 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
23137 && optimize_one_addr_into_implicit_ptr (loc
))
23142 case DW_OP_GNU_addr_index
:
23143 case DW_OP_GNU_const_index
:
23144 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
23145 || (loc
->dw_loc_opc
== DW_OP_GNU_const_index
&& loc
->dtprel
))
23146 && resolve_one_addr (&loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
,
23150 case DW_OP_const4u
:
23151 case DW_OP_const8u
:
23153 && resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
23156 case DW_OP_plus_uconst
:
23157 if (size_of_loc_descr (loc
)
23158 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
23160 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
23162 dw_loc_descr_ref repl
23163 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
23164 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
23165 add_loc_descr (&repl
, loc
->dw_loc_next
);
23169 case DW_OP_implicit_value
:
23170 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
23171 && resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
, NULL
))
23174 case DW_OP_GNU_implicit_pointer
:
23175 case DW_OP_GNU_parameter_ref
:
23176 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
23179 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
23182 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23183 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23184 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23187 case DW_OP_GNU_const_type
:
23188 case DW_OP_GNU_regval_type
:
23189 case DW_OP_GNU_deref_type
:
23190 case DW_OP_GNU_convert
:
23191 case DW_OP_GNU_reinterpret
:
23192 while (loc
->dw_loc_next
23193 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
)
23195 dw_die_ref base1
, base2
;
23196 unsigned enc1
, enc2
, size1
, size2
;
23197 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23198 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23199 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
23200 else if (loc
->dw_loc_oprnd1
.val_class
23201 == dw_val_class_unsigned_const
)
23204 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23205 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
23206 == dw_val_class_unsigned_const
)
23208 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
23209 gcc_assert (base1
->die_tag
== DW_TAG_base_type
23210 && base2
->die_tag
== DW_TAG_base_type
);
23211 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
23212 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
23213 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
23214 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
23216 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
23217 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
23221 /* Optimize away next DW_OP_GNU_convert after
23222 adjusting LOC's base type die reference. */
23223 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
23224 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
23225 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
23227 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
23228 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
23231 /* Don't change integer DW_OP_GNU_convert after e.g. floating
23232 point typed stack entry. */
23233 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
23234 keep
= loc
->dw_loc_next
;
23244 /* Helper function of resolve_addr. DIE had DW_AT_location of
23245 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
23246 and DW_OP_addr couldn't be resolved. resolve_addr has already
23247 removed the DW_AT_location attribute. This function attempts to
23248 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
23249 to it or DW_AT_const_value attribute, if possible. */
23252 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
23254 if (TREE_CODE (decl
) != VAR_DECL
23255 || lookup_decl_die (decl
) != die
23256 || DECL_EXTERNAL (decl
)
23257 || !TREE_STATIC (decl
)
23258 || DECL_INITIAL (decl
) == NULL_TREE
23259 || DECL_P (DECL_INITIAL (decl
))
23260 || get_AT (die
, DW_AT_const_value
))
23263 tree init
= DECL_INITIAL (decl
);
23264 HOST_WIDE_INT offset
= 0;
23265 /* For variables that have been optimized away and thus
23266 don't have a memory location, see if we can emit
23267 DW_AT_const_value instead. */
23268 if (tree_add_const_value_attribute (die
, init
))
23272 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
23273 and ADDR_EXPR refers to a decl that has DW_AT_location or
23274 DW_AT_const_value (but isn't addressable, otherwise
23275 resolving the original DW_OP_addr wouldn't fail), see if
23276 we can add DW_OP_GNU_implicit_pointer. */
23278 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
23279 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
23281 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
23282 init
= TREE_OPERAND (init
, 0);
23285 if (TREE_CODE (init
) != ADDR_EXPR
)
23287 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
23288 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
23289 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
23290 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
23291 && TREE_OPERAND (init
, 0) != decl
))
23294 dw_loc_descr_ref l
;
23296 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
23298 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
23301 decl
= SYMBOL_REF_DECL (rtl
);
23304 decl
= TREE_OPERAND (init
, 0);
23305 ref
= lookup_decl_die (decl
);
23307 || (!get_AT (ref
, DW_AT_location
)
23308 && !get_AT (ref
, DW_AT_const_value
)))
23310 l
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
23311 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
23312 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
23313 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
23314 add_AT_loc (die
, DW_AT_location
, l
);
23318 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23319 an address in .rodata section if the string literal is emitted there,
23320 or remove the containing location list or replace DW_AT_const_value
23321 with DW_AT_location and empty location expression, if it isn't found
23322 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23323 to something that has been emitted in the current CU. */
23326 resolve_addr (dw_die_ref die
)
23330 dw_loc_list_ref
*curr
, *start
, loc
;
23333 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23334 switch (AT_class (a
))
23336 case dw_val_class_loc_list
:
23337 start
= curr
= AT_loc_list_ptr (a
);
23340 /* The same list can be referenced more than once. See if we have
23341 already recorded the result from a previous pass. */
23343 *curr
= loc
->dw_loc_next
;
23344 else if (!loc
->resolved_addr
)
23346 /* As things stand, we do not expect or allow one die to
23347 reference a suffix of another die's location list chain.
23348 References must be identical or completely separate.
23349 There is therefore no need to cache the result of this
23350 pass on any list other than the first; doing so
23351 would lead to unnecessary writes. */
23354 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
23355 if (!resolve_addr_in_expr ((*curr
)->expr
))
23357 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
23358 dw_loc_descr_ref l
= (*curr
)->expr
;
23360 if (next
&& (*curr
)->ll_symbol
)
23362 gcc_assert (!next
->ll_symbol
);
23363 next
->ll_symbol
= (*curr
)->ll_symbol
;
23365 if (dwarf_split_debug_info
)
23366 remove_loc_list_addr_table_entries (l
);
23371 mark_base_types ((*curr
)->expr
);
23372 curr
= &(*curr
)->dw_loc_next
;
23376 loc
->resolved_addr
= 1;
23380 loc
->dw_loc_next
= *start
;
23385 remove_AT (die
, a
->dw_attr
);
23389 case dw_val_class_loc
:
23391 dw_loc_descr_ref l
= AT_loc (a
);
23392 /* For -gdwarf-2 don't attempt to optimize
23393 DW_AT_data_member_location containing
23394 DW_OP_plus_uconst - older consumers might
23395 rely on it being that op instead of a more complex,
23396 but shorter, location description. */
23397 if ((dwarf_version
> 2
23398 || a
->dw_attr
!= DW_AT_data_member_location
23400 || l
->dw_loc_opc
!= DW_OP_plus_uconst
23401 || l
->dw_loc_next
!= NULL
)
23402 && !resolve_addr_in_expr (l
))
23404 if (dwarf_split_debug_info
)
23405 remove_loc_list_addr_table_entries (l
);
23407 && l
->dw_loc_next
== NULL
23408 && l
->dw_loc_opc
== DW_OP_addr
23409 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
23410 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
23411 && a
->dw_attr
== DW_AT_location
)
23413 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
23414 remove_AT (die
, a
->dw_attr
);
23416 optimize_location_into_implicit_ptr (die
, decl
);
23419 remove_AT (die
, a
->dw_attr
);
23423 mark_base_types (l
);
23426 case dw_val_class_addr
:
23427 if (a
->dw_attr
== DW_AT_const_value
23428 && resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
, NULL
))
23430 if (AT_index (a
) != NOT_INDEXED
)
23431 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23432 remove_AT (die
, a
->dw_attr
);
23435 if (die
->die_tag
== DW_TAG_GNU_call_site
23436 && a
->dw_attr
== DW_AT_abstract_origin
)
23438 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
23439 dw_die_ref tdie
= lookup_decl_die (tdecl
);
23441 && DECL_EXTERNAL (tdecl
)
23442 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
)
23444 force_decl_die (tdecl
);
23445 tdie
= lookup_decl_die (tdecl
);
23449 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
23450 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
23451 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
23455 if (AT_index (a
) != NOT_INDEXED
)
23456 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
23457 remove_AT (die
, a
->dw_attr
);
23466 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
23469 /* Helper routines for optimize_location_lists.
23470 This pass tries to share identical local lists in .debug_loc
23473 /* Iteratively hash operands of LOC opcode. */
23476 hash_loc_operands (dw_loc_descr_ref loc
, hashval_t hash
)
23478 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
23479 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
23481 switch (loc
->dw_loc_opc
)
23483 case DW_OP_const4u
:
23484 case DW_OP_const8u
:
23488 case DW_OP_const1u
:
23489 case DW_OP_const1s
:
23490 case DW_OP_const2u
:
23491 case DW_OP_const2s
:
23492 case DW_OP_const4s
:
23493 case DW_OP_const8s
:
23497 case DW_OP_plus_uconst
:
23533 case DW_OP_deref_size
:
23534 case DW_OP_xderef_size
:
23535 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23542 gcc_assert (val1
->val_class
== dw_val_class_loc
);
23543 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
23544 hash
= iterative_hash_object (offset
, hash
);
23547 case DW_OP_implicit_value
:
23548 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
23549 switch (val2
->val_class
)
23551 case dw_val_class_const
:
23552 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23554 case dw_val_class_vec
:
23556 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23557 unsigned int len
= val2
->v
.val_vec
.length
;
23559 hash
= iterative_hash_object (elt_size
, hash
);
23560 hash
= iterative_hash_object (len
, hash
);
23561 hash
= iterative_hash (val2
->v
.val_vec
.array
,
23562 len
* elt_size
, hash
);
23565 case dw_val_class_const_double
:
23566 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
23567 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
23569 case dw_val_class_addr
:
23570 hash
= iterative_hash_rtx (val2
->v
.val_addr
, hash
);
23573 gcc_unreachable ();
23577 case DW_OP_bit_piece
:
23578 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23579 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23585 unsigned char dtprel
= 0xd1;
23586 hash
= iterative_hash_object (dtprel
, hash
);
23588 hash
= iterative_hash_rtx (val1
->v
.val_addr
, hash
);
23590 case DW_OP_GNU_addr_index
:
23591 case DW_OP_GNU_const_index
:
23595 unsigned char dtprel
= 0xd1;
23596 hash
= iterative_hash_object (dtprel
, hash
);
23598 hash
= iterative_hash_rtx (val1
->val_entry
->addr
.rtl
, hash
);
23601 case DW_OP_GNU_implicit_pointer
:
23602 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23604 case DW_OP_GNU_entry_value
:
23605 hash
= hash_loc_operands (val1
->v
.val_loc
, hash
);
23607 case DW_OP_GNU_regval_type
:
23608 case DW_OP_GNU_deref_type
:
23610 unsigned int byte_size
23611 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23612 unsigned int encoding
23613 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
23614 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
23615 hash
= iterative_hash_object (byte_size
, hash
);
23616 hash
= iterative_hash_object (encoding
, hash
);
23619 case DW_OP_GNU_convert
:
23620 case DW_OP_GNU_reinterpret
:
23621 if (val1
->val_class
== dw_val_class_unsigned_const
)
23623 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
23627 case DW_OP_GNU_const_type
:
23629 unsigned int byte_size
23630 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
23631 unsigned int encoding
23632 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
23633 hash
= iterative_hash_object (byte_size
, hash
);
23634 hash
= iterative_hash_object (encoding
, hash
);
23635 if (loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
23637 hash
= iterative_hash_object (val2
->val_class
, hash
);
23638 switch (val2
->val_class
)
23640 case dw_val_class_const
:
23641 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
23643 case dw_val_class_vec
:
23645 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
23646 unsigned int len
= val2
->v
.val_vec
.length
;
23648 hash
= iterative_hash_object (elt_size
, hash
);
23649 hash
= iterative_hash_object (len
, hash
);
23650 hash
= iterative_hash (val2
->v
.val_vec
.array
,
23651 len
* elt_size
, hash
);
23654 case dw_val_class_const_double
:
23655 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
23656 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
23659 gcc_unreachable ();
23665 /* Other codes have no operands. */
23671 /* Iteratively hash the whole DWARF location expression LOC. */
23673 static inline hashval_t
23674 hash_locs (dw_loc_descr_ref loc
, hashval_t hash
)
23676 dw_loc_descr_ref l
;
23677 bool sizes_computed
= false;
23678 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
23679 size_of_locs (loc
);
23681 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
23683 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
23684 hash
= iterative_hash_object (opc
, hash
);
23685 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
23687 size_of_locs (loc
);
23688 sizes_computed
= true;
23690 hash
= hash_loc_operands (l
, hash
);
23695 /* Compute hash of the whole location list LIST_HEAD. */
23698 hash_loc_list (dw_loc_list_ref list_head
)
23700 dw_loc_list_ref curr
= list_head
;
23701 hashval_t hash
= 0;
23703 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
23705 hash
= iterative_hash (curr
->begin
, strlen (curr
->begin
) + 1, hash
);
23706 hash
= iterative_hash (curr
->end
, strlen (curr
->end
) + 1, hash
);
23708 hash
= iterative_hash (curr
->section
, strlen (curr
->section
) + 1,
23710 hash
= hash_locs (curr
->expr
, hash
);
23712 list_head
->hash
= hash
;
23715 /* Return true if X and Y opcodes have the same operands. */
23718 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
23720 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
23721 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
23722 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
23723 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
23725 switch (x
->dw_loc_opc
)
23727 case DW_OP_const4u
:
23728 case DW_OP_const8u
:
23732 case DW_OP_const1u
:
23733 case DW_OP_const1s
:
23734 case DW_OP_const2u
:
23735 case DW_OP_const2s
:
23736 case DW_OP_const4s
:
23737 case DW_OP_const8s
:
23741 case DW_OP_plus_uconst
:
23777 case DW_OP_deref_size
:
23778 case DW_OP_xderef_size
:
23779 return valx1
->v
.val_int
== valy1
->v
.val_int
;
23782 /* If splitting debug info, the use of DW_OP_GNU_addr_index
23783 can cause irrelevant differences in dw_loc_addr. */
23784 gcc_assert (valx1
->val_class
== dw_val_class_loc
23785 && valy1
->val_class
== dw_val_class_loc
23786 && (dwarf_split_debug_info
23787 || x
->dw_loc_addr
== y
->dw_loc_addr
));
23788 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
23789 case DW_OP_implicit_value
:
23790 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
23791 || valx2
->val_class
!= valy2
->val_class
)
23793 switch (valx2
->val_class
)
23795 case dw_val_class_const
:
23796 return valx2
->v
.val_int
== valy2
->v
.val_int
;
23797 case dw_val_class_vec
:
23798 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
23799 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
23800 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
23801 valx2
->v
.val_vec
.elt_size
23802 * valx2
->v
.val_vec
.length
) == 0;
23803 case dw_val_class_const_double
:
23804 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
23805 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
23806 case dw_val_class_addr
:
23807 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
23809 gcc_unreachable ();
23812 case DW_OP_bit_piece
:
23813 return valx1
->v
.val_int
== valy1
->v
.val_int
23814 && valx2
->v
.val_int
== valy2
->v
.val_int
;
23817 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
23818 case DW_OP_GNU_addr_index
:
23819 case DW_OP_GNU_const_index
:
23821 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
23822 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
23823 return rtx_equal_p (ax1
, ay1
);
23825 case DW_OP_GNU_implicit_pointer
:
23826 return valx1
->val_class
== dw_val_class_die_ref
23827 && valx1
->val_class
== valy1
->val_class
23828 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
23829 && valx2
->v
.val_int
== valy2
->v
.val_int
;
23830 case DW_OP_GNU_entry_value
:
23831 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
23832 case DW_OP_GNU_const_type
:
23833 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
23834 || valx2
->val_class
!= valy2
->val_class
)
23836 switch (valx2
->val_class
)
23838 case dw_val_class_const
:
23839 return valx2
->v
.val_int
== valy2
->v
.val_int
;
23840 case dw_val_class_vec
:
23841 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
23842 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
23843 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
23844 valx2
->v
.val_vec
.elt_size
23845 * valx2
->v
.val_vec
.length
) == 0;
23846 case dw_val_class_const_double
:
23847 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
23848 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
23850 gcc_unreachable ();
23852 case DW_OP_GNU_regval_type
:
23853 case DW_OP_GNU_deref_type
:
23854 return valx1
->v
.val_int
== valy1
->v
.val_int
23855 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
23856 case DW_OP_GNU_convert
:
23857 case DW_OP_GNU_reinterpret
:
23858 if (valx1
->val_class
!= valy1
->val_class
)
23860 if (valx1
->val_class
== dw_val_class_unsigned_const
)
23861 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
23862 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
23863 case DW_OP_GNU_parameter_ref
:
23864 return valx1
->val_class
== dw_val_class_die_ref
23865 && valx1
->val_class
== valy1
->val_class
23866 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
23868 /* Other codes have no operands. */
23873 /* Return true if DWARF location expressions X and Y are the same. */
23876 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
23878 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
23879 if (x
->dw_loc_opc
!= y
->dw_loc_opc
23880 || x
->dtprel
!= y
->dtprel
23881 || !compare_loc_operands (x
, y
))
23883 return x
== NULL
&& y
== NULL
;
23886 /* Hashtable helpers. */
23888 struct loc_list_hasher
: typed_noop_remove
<dw_loc_list_struct
>
23890 typedef dw_loc_list_struct value_type
;
23891 typedef dw_loc_list_struct compare_type
;
23892 static inline hashval_t
hash (const value_type
*);
23893 static inline bool equal (const value_type
*, const compare_type
*);
23896 /* Return precomputed hash of location list X. */
23899 loc_list_hasher::hash (const value_type
*x
)
23904 /* Return true if location lists A and B are the same. */
23907 loc_list_hasher::equal (const value_type
*a
, const compare_type
*b
)
23911 if (a
->hash
!= b
->hash
)
23913 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
23914 if (strcmp (a
->begin
, b
->begin
) != 0
23915 || strcmp (a
->end
, b
->end
) != 0
23916 || (a
->section
== NULL
) != (b
->section
== NULL
)
23917 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
23918 || !compare_locs (a
->expr
, b
->expr
))
23920 return a
== NULL
&& b
== NULL
;
23923 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
23926 /* Recursively optimize location lists referenced from DIE
23927 children and share them whenever possible. */
23930 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type htab
)
23935 dw_loc_list_struct
**slot
;
23937 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23938 if (AT_class (a
) == dw_val_class_loc_list
)
23940 dw_loc_list_ref list
= AT_loc_list (a
);
23941 /* TODO: perform some optimizations here, before hashing
23942 it and storing into the hash table. */
23943 hash_loc_list (list
);
23944 slot
= htab
.find_slot_with_hash (list
, list
->hash
, INSERT
);
23948 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
23951 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
23955 /* Recursively assign each location list a unique index into the debug_addr
23959 index_location_lists (dw_die_ref die
)
23965 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
23966 if (AT_class (a
) == dw_val_class_loc_list
)
23968 dw_loc_list_ref list
= AT_loc_list (a
);
23969 dw_loc_list_ref curr
;
23970 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
23972 /* Don't index an entry that has already been indexed
23973 or won't be output. */
23974 if (curr
->begin_entry
!= NULL
23975 || (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
))
23979 = add_addr_table_entry (xstrdup (curr
->begin
),
23984 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
23987 /* Optimize location lists referenced from DIE
23988 children and share them whenever possible. */
23991 optimize_location_lists (dw_die_ref die
)
23993 loc_list_hash_type htab
;
23995 optimize_location_lists_1 (die
, htab
);
23999 /* Output stuff that dwarf requires at the end of every file,
24000 and generate the DWARF-2 debugging info. */
24003 dwarf2out_finish (const char *filename
)
24005 limbo_die_node
*node
, *next_node
;
24006 comdat_type_node
*ctnode
;
24007 hash_table
<comdat_type_hasher
> comdat_type_table
;
24009 dw_die_ref main_comp_unit_die
;
24011 /* PCH might result in DW_AT_producer string being restored from the
24012 header compilation, so always fill it with empty string initially
24013 and overwrite only here. */
24014 dw_attr_ref producer
= get_AT (comp_unit_die (), DW_AT_producer
);
24015 producer_string
= gen_producer_string ();
24016 producer
->dw_attr_val
.v
.val_str
->refcount
--;
24017 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
24019 gen_scheduled_generic_parms_dies ();
24020 gen_remaining_tmpl_value_param_die_attribute ();
24022 /* Add the name for the main input file now. We delayed this from
24023 dwarf2out_init to avoid complications with PCH. */
24024 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
24025 if (!IS_ABSOLUTE_PATH (filename
) || targetm
.force_at_comp_dir
)
24026 add_comp_dir_attribute (comp_unit_die ());
24027 else if (get_AT (comp_unit_die (), DW_AT_comp_dir
) == NULL
)
24030 htab_traverse (file_table
, file_table_relative_p
, &p
);
24032 add_comp_dir_attribute (comp_unit_die ());
24035 if (deferred_locations_list
)
24036 for (i
= 0; i
< deferred_locations_list
->length (); i
++)
24038 add_location_or_const_value_attribute (
24039 (*deferred_locations_list
)[i
].die
,
24040 (*deferred_locations_list
)[i
].variable
,
24045 /* Traverse the limbo die list, and add parent/child links. The only
24046 dies without parents that should be here are concrete instances of
24047 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
24048 For concrete instances, we can get the parent die from the abstract
24050 for (node
= limbo_die_list
; node
; node
= next_node
)
24052 dw_die_ref die
= node
->die
;
24053 next_node
= node
->next
;
24055 if (die
->die_parent
== NULL
)
24057 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
24059 if (origin
&& origin
->die_parent
)
24060 add_child_die (origin
->die_parent
, die
);
24061 else if (is_cu_die (die
))
24063 else if (seen_error ())
24064 /* It's OK to be confused by errors in the input. */
24065 add_child_die (comp_unit_die (), die
);
24068 /* In certain situations, the lexical block containing a
24069 nested function can be optimized away, which results
24070 in the nested function die being orphaned. Likewise
24071 with the return type of that nested function. Force
24072 this to be a child of the containing function.
24074 It may happen that even the containing function got fully
24075 inlined and optimized out. In that case we are lost and
24076 assign the empty child. This should not be big issue as
24077 the function is likely unreachable too. */
24078 gcc_assert (node
->created_for
);
24080 if (DECL_P (node
->created_for
))
24081 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
24082 else if (TYPE_P (node
->created_for
))
24083 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
24085 origin
= comp_unit_die ();
24087 add_child_die (origin
, die
);
24092 limbo_die_list
= NULL
;
24094 #if ENABLE_ASSERT_CHECKING
24096 dw_die_ref die
= comp_unit_die (), c
;
24097 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
24100 resolve_addr (comp_unit_die ());
24101 move_marked_base_types ();
24103 for (node
= deferred_asm_name
; node
; node
= node
->next
)
24105 tree decl
= node
->created_for
;
24106 /* When generating LTO bytecode we can not generate new assembler
24107 names at this point and all important decls got theirs via
24109 if ((!flag_generate_lto
|| DECL_ASSEMBLER_NAME_SET_P (decl
))
24110 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
24112 add_linkage_attr (node
->die
, decl
);
24113 move_linkage_attr (node
->die
);
24117 deferred_asm_name
= NULL
;
24119 /* Walk through the list of incomplete types again, trying once more to
24120 emit full debugging info for them. */
24121 retry_incomplete_types ();
24123 if (flag_eliminate_unused_debug_types
)
24124 prune_unused_types ();
24126 /* Generate separate COMDAT sections for type DIEs. */
24127 if (use_debug_types
)
24129 break_out_comdat_types (comp_unit_die ());
24131 /* Each new type_unit DIE was added to the limbo die list when created.
24132 Since these have all been added to comdat_type_list, clear the
24134 limbo_die_list
= NULL
;
24136 /* For each new comdat type unit, copy declarations for incomplete
24137 types to make the new unit self-contained (i.e., no direct
24138 references to the main compile unit). */
24139 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24140 copy_decls_for_unworthy_types (ctnode
->root_die
);
24141 copy_decls_for_unworthy_types (comp_unit_die ());
24143 /* In the process of copying declarations from one unit to another,
24144 we may have left some declarations behind that are no longer
24145 referenced. Prune them. */
24146 prune_unused_types ();
24149 /* Generate separate CUs for each of the include files we've seen.
24150 They will go into limbo_die_list. */
24151 if (flag_eliminate_dwarf2_dups
)
24152 break_out_includes (comp_unit_die ());
24154 /* Traverse the DIE's and add add sibling attributes to those DIE's
24155 that have children. */
24156 add_sibling_attributes (comp_unit_die ());
24157 for (node
= limbo_die_list
; node
; node
= node
->next
)
24158 add_sibling_attributes (node
->die
);
24159 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24160 add_sibling_attributes (ctnode
->root_die
);
24162 /* When splitting DWARF info, we put some attributes in the
24163 skeleton compile_unit DIE that remains in the .o, while
24164 most attributes go in the DWO compile_unit_die. */
24165 if (dwarf_split_debug_info
)
24166 main_comp_unit_die
= gen_compile_unit_die (NULL
);
24168 main_comp_unit_die
= comp_unit_die ();
24170 /* Output a terminator label for the .text section. */
24171 switch_to_section (text_section
);
24172 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
24173 if (cold_text_section
)
24175 switch_to_section (cold_text_section
);
24176 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
24179 /* We can only use the low/high_pc attributes if all of the code was
24181 if (!have_multiple_function_sections
24182 || (dwarf_version
< 3 && dwarf_strict
))
24184 /* Don't add if the CU has no associated code. */
24185 if (text_section_used
)
24186 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
24187 text_end_label
, true);
24193 bool range_list_added
= false;
24195 if (text_section_used
)
24196 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
24197 text_end_label
, &range_list_added
, true);
24198 if (cold_text_section_used
)
24199 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
24200 cold_end_label
, &range_list_added
, true);
24202 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
24204 if (DECL_IGNORED_P (fde
->decl
))
24206 if (!fde
->in_std_section
)
24207 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
24208 fde
->dw_fde_end
, &range_list_added
,
24210 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
24211 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
24212 fde
->dw_fde_second_end
, &range_list_added
,
24216 if (range_list_added
)
24218 /* We need to give .debug_loc and .debug_ranges an appropriate
24219 "base address". Use zero so that these addresses become
24220 absolute. Historically, we've emitted the unexpected
24221 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24222 Emit both to give time for other tools to adapt. */
24223 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
24224 if (! dwarf_strict
&& dwarf_version
< 4)
24225 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
24231 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24232 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
24233 debug_line_section_label
);
24236 add_AT_macptr (comp_unit_die (),
24237 dwarf_strict
? DW_AT_macro_info
: DW_AT_GNU_macros
,
24238 macinfo_section_label
);
24240 if (dwarf_split_debug_info
&& addr_index_table
!= NULL
)
24242 /* optimize_location_lists calculates the size of the lists,
24243 so index them first, and assign indices to the entries.
24244 Although optimize_location_lists will remove entries from
24245 the table, it only does so for duplicates, and therefore
24246 only reduces ref_counts to 1. */
24247 unsigned int index
= 0;
24248 index_location_lists (comp_unit_die ());
24249 htab_traverse_noresize (addr_index_table
,
24250 index_addr_table_entry
, &index
);
24252 if (have_location_lists
)
24253 optimize_location_lists (comp_unit_die ());
24255 save_macinfo_strings ();
24257 if (dwarf_split_debug_info
)
24259 unsigned int index
= 0;
24261 /* Add attributes common to skeleton compile_units and
24262 type_units. Because these attributes include strings, it
24263 must be done before freezing the string table. Top-level
24264 skeleton die attrs are added when the skeleton type unit is
24265 created, so ensure it is created by this point. */
24266 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
24267 (void) get_skeleton_type_unit ();
24268 htab_traverse_noresize (debug_str_hash
, index_string
, &index
);
24271 /* Output all of the compilation units. We put the main one last so that
24272 the offsets are available to output_pubnames. */
24273 for (node
= limbo_die_list
; node
; node
= node
->next
)
24274 output_comp_unit (node
->die
, 0);
24276 comdat_type_table
.create (100);
24277 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
24279 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
24281 /* Don't output duplicate types. */
24282 if (*slot
!= HTAB_EMPTY_ENTRY
)
24285 /* Add a pointer to the line table for the main compilation unit
24286 so that the debugger can make sense of DW_AT_decl_file
24288 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
24289 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
24290 (!dwarf_split_debug_info
24291 ? debug_line_section_label
24292 : debug_skeleton_line_section_label
));
24294 output_comdat_type_unit (ctnode
);
24297 comdat_type_table
.dispose ();
24299 /* The AT_pubnames attribute needs to go in all skeleton dies, including
24300 both the main_cu and all skeleton TUs. Making this call unconditional
24301 would end up either adding a second copy of the AT_pubnames attribute, or
24302 requiring a special case in add_top_level_skeleton_die_attrs. */
24303 if (!dwarf_split_debug_info
)
24304 add_AT_pubnames (comp_unit_die ());
24306 if (dwarf_split_debug_info
)
24309 unsigned char checksum
[16];
24310 struct md5_ctx ctx
;
24312 /* Compute a checksum of the comp_unit to use as the dwo_id. */
24313 md5_init_ctx (&ctx
);
24315 die_checksum (comp_unit_die (), &ctx
, &mark
);
24316 unmark_all_dies (comp_unit_die ());
24317 md5_finish_ctx (&ctx
, checksum
);
24319 /* Use the first 8 bytes of the checksum as the dwo_id,
24320 and add it to both comp-unit DIEs. */
24321 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
24322 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
24324 /* Add the base offset of the ranges table to the skeleton
24326 if (ranges_table_in_use
)
24327 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
24328 ranges_section_label
);
24330 switch_to_section (debug_addr_section
);
24331 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
24332 output_addr_table ();
24335 /* Output the main compilation unit if non-empty or if .debug_macinfo
24336 or .debug_macro will be emitted. */
24337 output_comp_unit (comp_unit_die (), have_macinfo
);
24339 if (dwarf_split_debug_info
&& info_section_emitted
)
24340 output_skeleton_debug_sections (main_comp_unit_die
);
24342 /* Output the abbreviation table. */
24343 if (abbrev_die_table_in_use
!= 1)
24345 switch_to_section (debug_abbrev_section
);
24346 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
24347 output_abbrev_section ();
24350 /* Output location list section if necessary. */
24351 if (have_location_lists
)
24353 /* Output the location lists info. */
24354 switch_to_section (debug_loc_section
);
24355 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
24356 output_location_lists (comp_unit_die ());
24359 output_pubtables ();
24361 /* Output the address range information if a CU (.debug_info section)
24362 was emitted. We output an empty table even if we had no functions
24363 to put in it. This because the consumer has no way to tell the
24364 difference between an empty table that we omitted and failure to
24365 generate a table that would have contained data. */
24366 if (info_section_emitted
)
24368 unsigned long aranges_length
= size_of_aranges ();
24370 switch_to_section (debug_aranges_section
);
24371 output_aranges (aranges_length
);
24374 /* Output ranges section if necessary. */
24375 if (ranges_table_in_use
)
24377 switch_to_section (debug_ranges_section
);
24378 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
24382 /* Have to end the macro section. */
24385 switch_to_section (debug_macinfo_section
);
24386 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
24388 dw2_asm_output_data (1, 0, "End compilation unit");
24391 /* Output the source line correspondence table. We must do this
24392 even if there is no line information. Otherwise, on an empty
24393 translation unit, we will generate a present, but empty,
24394 .debug_info section. IRIX 6.5 `nm' will then complain when
24395 examining the file. This is done late so that any filenames
24396 used by the debug_info section are marked as 'used'. */
24397 switch_to_section (debug_line_section
);
24398 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
24399 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
24400 output_line_info (false);
24402 if (dwarf_split_debug_info
&& info_section_emitted
)
24404 switch_to_section (debug_skeleton_line_section
);
24405 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
24406 output_line_info (true);
24409 /* If we emitted any indirect strings, output the string table too. */
24410 if (debug_str_hash
|| skeleton_debug_str_hash
)
24411 output_indirect_strings ();
24414 #include "gt-dwarf2out.h"