1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Contributed by Gary Funck (gary@intrepid.com).
6 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
7 Extensively modified by Jason Merrill (jason@cygnus.com).
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
25 /* TODO: Emit .debug_line header even when there are no functions, since
26 the file numbers are used by .debug_info. Alternately, leave
27 out locations for types and decls.
28 Avoid talking about ctors and op= for PODs.
29 Factor out common prologue sequences into multiple CIEs. */
31 /* The first part of this file deals with the DWARF 2 frame unwind
32 information, which is also used by the GCC efficient exception handling
33 mechanism. The second part, controlled only by an #ifdef
34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
37 /* DWARF2 Abbreviation Glossary:
39 CFA = Canonical Frame Address
40 a fixed address on the stack which identifies a call frame.
41 We define it to be the value of SP just before the call insn.
42 The CFA register and offset, which may change during the course
43 of the function, are used to calculate its value at runtime.
45 CFI = Call Frame Instruction
46 an instruction for the DWARF2 abstract machine
48 CIE = Common Information Entry
49 information describing information common to one or more FDEs
51 DIE = Debugging Information Entry
53 FDE = Frame Description Entry
54 information describing the stack call frame, in particular,
55 how to restore registers
57 DW_CFA_... = DWARF2 CFA call frame instruction
58 DW_TAG_... = DWARF2 DIE tag */
62 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
84 #include "diagnostic.h"
85 #include "tree-pretty-print.h"
88 #include "common/common-target.h"
89 #include "langhooks.h"
94 #include "tree-pass.h"
95 #include "tree-flow.h"
96 #include "cfglayout.h"
99 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
100 static rtx last_var_location_insn
;
101 static rtx cached_next_real_insn
;
103 #ifdef VMS_DEBUGGING_INFO
104 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
106 /* Define this macro to be a nonzero value if the directory specifications
107 which are output in the debug info should end with a separator. */
108 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
109 /* Define this macro to evaluate to a nonzero value if GCC should refrain
110 from generating indirect strings in DWARF2 debug information, for instance
111 if your target is stuck with an old version of GDB that is unable to
112 process them properly or uses VMS Debug. */
113 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
115 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
116 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
119 /* ??? Poison these here until it can be done generically. They've been
120 totally replaced in this file; make sure it stays that way. */
121 #undef DWARF2_UNWIND_INFO
122 #undef DWARF2_FRAME_INFO
123 #if (GCC_VERSION >= 3000)
124 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
127 /* The size of the target's pointer type. */
129 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
132 /* Array of RTXes referenced by the debugging information, which therefore
133 must be kept around forever. */
134 static GTY(()) VEC(rtx
,gc
) *used_rtx_array
;
136 /* A pointer to the base of a list of incomplete types which might be
137 completed at some later time. incomplete_types_list needs to be a
138 VEC(tree,gc) because we want to tell the garbage collector about
140 static GTY(()) VEC(tree
,gc
) *incomplete_types
;
142 /* A pointer to the base of a table of references to declaration
143 scopes. This table is a display which tracks the nesting
144 of declaration scopes at the current scope and containing
145 scopes. This table is used to find the proper place to
146 define type declaration DIE's. */
147 static GTY(()) VEC(tree
,gc
) *decl_scope_table
;
149 /* Pointers to various DWARF2 sections. */
150 static GTY(()) section
*debug_info_section
;
151 static GTY(()) section
*debug_abbrev_section
;
152 static GTY(()) section
*debug_aranges_section
;
153 static GTY(()) section
*debug_macinfo_section
;
154 static GTY(()) section
*debug_line_section
;
155 static GTY(()) section
*debug_loc_section
;
156 static GTY(()) section
*debug_pubnames_section
;
157 static GTY(()) section
*debug_pubtypes_section
;
158 static GTY(()) section
*debug_str_section
;
159 static GTY(()) section
*debug_ranges_section
;
160 static GTY(()) section
*debug_frame_section
;
162 /* Maximum size (in bytes) of an artificially generated label. */
163 #define MAX_ARTIFICIAL_LABEL_BYTES 30
165 /* According to the (draft) DWARF 3 specification, the initial length
166 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
167 bytes are 0xffffffff, followed by the length stored in the next 8
170 However, the SGI/MIPS ABI uses an initial length which is equal to
171 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
173 #ifndef DWARF_INITIAL_LENGTH_SIZE
174 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
177 /* Round SIZE up to the nearest BOUNDARY. */
178 #define DWARF_ROUND(SIZE,BOUNDARY) \
179 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
181 /* CIE identifier. */
182 #if HOST_BITS_PER_WIDE_INT >= 64
183 #define DWARF_CIE_ID \
184 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
186 #define DWARF_CIE_ID DW_CIE_ID
189 DEF_VEC_P (dw_fde_ref
);
190 DEF_VEC_ALLOC_P (dw_fde_ref
, gc
);
192 /* A vector for a table that contains frame description
193 information for each routine. */
194 static GTY(()) VEC(dw_fde_ref
, gc
) *fde_vec
;
196 struct GTY(()) indirect_string_node
{
198 unsigned int refcount
;
199 enum dwarf_form form
;
203 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
205 static GTY(()) int dw2_string_counter
;
207 /* True if the compilation unit places functions in more than one section. */
208 static GTY(()) bool have_multiple_function_sections
= false;
210 /* Whether the default text and cold text sections have been used at all. */
212 static GTY(()) bool text_section_used
= false;
213 static GTY(()) bool cold_text_section_used
= false;
215 /* The default cold text section. */
216 static GTY(()) section
*cold_text_section
;
218 /* Forward declarations for functions defined in this file. */
220 static char *stripattributes (const char *);
221 static void output_call_frame_info (int);
222 static void dwarf2out_note_section_used (void);
224 /* Personality decl of current unit. Used only when assembler does not support
226 static GTY(()) rtx current_unit_personality
;
228 /* Data and reference forms for relocatable data. */
229 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
230 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
232 #ifndef DEBUG_FRAME_SECTION
233 #define DEBUG_FRAME_SECTION ".debug_frame"
236 #ifndef FUNC_BEGIN_LABEL
237 #define FUNC_BEGIN_LABEL "LFB"
240 #ifndef FUNC_END_LABEL
241 #define FUNC_END_LABEL "LFE"
244 #ifndef PROLOGUE_END_LABEL
245 #define PROLOGUE_END_LABEL "LPE"
248 #ifndef EPILOGUE_BEGIN_LABEL
249 #define EPILOGUE_BEGIN_LABEL "LEB"
252 #ifndef FRAME_BEGIN_LABEL
253 #define FRAME_BEGIN_LABEL "Lframe"
255 #define CIE_AFTER_SIZE_LABEL "LSCIE"
256 #define CIE_END_LABEL "LECIE"
257 #define FDE_LABEL "LSFDE"
258 #define FDE_AFTER_SIZE_LABEL "LASFDE"
259 #define FDE_END_LABEL "LEFDE"
260 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
261 #define LINE_NUMBER_END_LABEL "LELT"
262 #define LN_PROLOG_AS_LABEL "LASLTP"
263 #define LN_PROLOG_END_LABEL "LELTP"
264 #define DIE_LABEL_PREFIX "DW"
266 /* Match the base name of a file to the base name of a compilation unit. */
269 matches_main_base (const char *path
)
271 /* Cache the last query. */
272 static const char *last_path
= NULL
;
273 static int last_match
= 0;
274 if (path
!= last_path
)
277 int length
= base_of_path (path
, &base
);
279 last_match
= (length
== main_input_baselength
280 && memcmp (base
, main_input_basename
, length
) == 0);
285 #ifdef DEBUG_DEBUG_STRUCT
288 dump_struct_debug (tree type
, enum debug_info_usage usage
,
289 enum debug_struct_file criterion
, int generic
,
290 int matches
, int result
)
292 /* Find the type name. */
293 tree type_decl
= TYPE_STUB_DECL (type
);
295 const char *name
= 0;
296 if (TREE_CODE (t
) == TYPE_DECL
)
299 name
= IDENTIFIER_POINTER (t
);
301 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
303 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
304 matches
? "bas" : "hdr",
305 generic
? "gen" : "ord",
306 usage
== DINFO_USAGE_DFN
? ";" :
307 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
309 (void*) type_decl
, name
);
312 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
313 dump_struct_debug (type, usage, criterion, generic, matches, result)
317 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
323 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
325 enum debug_struct_file criterion
;
327 bool generic
= lang_hooks
.types
.generic_p (type
);
330 criterion
= debug_struct_generic
[usage
];
332 criterion
= debug_struct_ordinary
[usage
];
334 if (criterion
== DINFO_STRUCT_FILE_NONE
)
335 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
336 if (criterion
== DINFO_STRUCT_FILE_ANY
)
337 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
339 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
341 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
342 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
344 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
345 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
346 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
349 /* Return a pointer to a copy of the section string name S with all
350 attributes stripped off, and an asterisk prepended (for assemble_name). */
353 stripattributes (const char *s
)
355 char *stripped
= XNEWVEC (char, strlen (s
) + 2);
360 while (*s
&& *s
!= ',')
367 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
368 switch to the data section instead, and write out a synthetic start label
369 for collect2 the first time around. */
372 switch_to_eh_frame_section (bool back
)
376 #ifdef EH_FRAME_SECTION_NAME
377 if (eh_frame_section
== 0)
381 if (EH_TABLES_CAN_BE_READ_ONLY
)
387 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
389 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
391 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
394 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
395 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
396 && (per_encoding
& 0x70) != DW_EH_PE_absptr
397 && (per_encoding
& 0x70) != DW_EH_PE_aligned
398 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
399 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
400 ? 0 : SECTION_WRITE
);
403 flags
= SECTION_WRITE
;
404 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
406 #endif /* EH_FRAME_SECTION_NAME */
408 if (eh_frame_section
)
409 switch_to_section (eh_frame_section
);
412 /* We have no special eh_frame section. Put the information in
413 the data section and emit special labels to guide collect2. */
414 switch_to_section (data_section
);
418 label
= get_file_function_name ("F");
419 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
420 targetm
.asm_out
.globalize_label (asm_out_file
,
421 IDENTIFIER_POINTER (label
));
422 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
427 /* Switch [BACK] to the eh or debug frame table section, depending on
431 switch_to_frame_table_section (int for_eh
, bool back
)
434 switch_to_eh_frame_section (back
);
437 if (!debug_frame_section
)
438 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
439 SECTION_DEBUG
, NULL
);
440 switch_to_section (debug_frame_section
);
444 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
446 enum dw_cfi_oprnd_type
447 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
452 case DW_CFA_GNU_window_save
:
453 case DW_CFA_remember_state
:
454 case DW_CFA_restore_state
:
455 return dw_cfi_oprnd_unused
;
458 case DW_CFA_advance_loc1
:
459 case DW_CFA_advance_loc2
:
460 case DW_CFA_advance_loc4
:
461 case DW_CFA_MIPS_advance_loc8
:
462 return dw_cfi_oprnd_addr
;
465 case DW_CFA_offset_extended
:
467 case DW_CFA_offset_extended_sf
:
468 case DW_CFA_def_cfa_sf
:
470 case DW_CFA_restore_extended
:
471 case DW_CFA_undefined
:
472 case DW_CFA_same_value
:
473 case DW_CFA_def_cfa_register
:
474 case DW_CFA_register
:
475 case DW_CFA_expression
:
476 return dw_cfi_oprnd_reg_num
;
478 case DW_CFA_def_cfa_offset
:
479 case DW_CFA_GNU_args_size
:
480 case DW_CFA_def_cfa_offset_sf
:
481 return dw_cfi_oprnd_offset
;
483 case DW_CFA_def_cfa_expression
:
484 return dw_cfi_oprnd_loc
;
491 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
493 enum dw_cfi_oprnd_type
494 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
499 case DW_CFA_def_cfa_sf
:
501 case DW_CFA_offset_extended_sf
:
502 case DW_CFA_offset_extended
:
503 return dw_cfi_oprnd_offset
;
505 case DW_CFA_register
:
506 return dw_cfi_oprnd_reg_num
;
508 case DW_CFA_expression
:
509 return dw_cfi_oprnd_loc
;
512 return dw_cfi_oprnd_unused
;
516 /* Output one FDE. */
519 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
520 char *section_start_label
, int fde_encoding
, char *augmentation
,
521 bool any_lsda_needed
, int lsda_encoding
)
523 const char *begin
, *end
;
524 static unsigned int j
;
527 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
529 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
531 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
532 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
533 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
534 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
535 " indicating 64-bit DWARF extension");
536 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
538 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
541 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
543 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
544 debug_frame_section
, "FDE CIE offset");
546 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
547 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
551 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
552 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
553 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
554 "FDE initial location");
555 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
556 end
, begin
, "FDE address range");
560 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
561 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
568 int size
= size_of_encoded_value (lsda_encoding
);
570 if (lsda_encoding
== DW_EH_PE_aligned
)
572 int offset
= ( 4 /* Length */
574 + 2 * size_of_encoded_value (fde_encoding
)
575 + 1 /* Augmentation size */ );
576 int pad
= -offset
& (PTR_SIZE
- 1);
579 gcc_assert (size_of_uleb128 (size
) == 1);
582 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
584 if (fde
->uses_eh_lsda
)
586 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
587 fde
->funcdef_number
);
588 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
589 gen_rtx_SYMBOL_REF (Pmode
, l1
),
591 "Language Specific Data Area");
595 if (lsda_encoding
== DW_EH_PE_aligned
)
596 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
597 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
598 "Language Specific Data Area (none)");
602 dw2_asm_output_data_uleb128 (0, "Augmentation size");
605 /* Loop through the Call Frame Instructions associated with this FDE. */
606 fde
->dw_fde_current_label
= begin
;
608 size_t from
, until
, i
;
611 until
= VEC_length (dw_cfi_ref
, fde
->dw_fde_cfi
);
613 if (fde
->dw_fde_second_begin
== NULL
)
616 until
= fde
->dw_fde_switch_cfi_index
;
618 from
= fde
->dw_fde_switch_cfi_index
;
620 for (i
= from
; i
< until
; i
++)
621 output_cfi (VEC_index (dw_cfi_ref
, fde
->dw_fde_cfi
, i
), fde
, for_eh
);
624 /* If we are to emit a ref/link from function bodies to their frame tables,
625 do it now. This is typically performed to make sure that tables
626 associated with functions are dragged with them and not discarded in
627 garbage collecting links. We need to do this on a per function basis to
628 cope with -ffunction-sections. */
630 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
631 /* Switch to the function section, emit the ref to the tables, and
632 switch *back* into the table section. */
633 switch_to_section (function_section (fde
->decl
));
634 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
635 switch_to_frame_table_section (for_eh
, true);
638 /* Pad the FDE out to an address sized boundary. */
639 ASM_OUTPUT_ALIGN (asm_out_file
,
640 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
641 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
646 /* Return true if frame description entry FDE is needed for EH. */
649 fde_needed_for_eh_p (dw_fde_ref fde
)
651 if (flag_asynchronous_unwind_tables
)
654 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
657 if (fde
->uses_eh_lsda
)
660 /* If exceptions are enabled, we have collected nothrow info. */
661 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
667 /* Output the call frame information used to record information
668 that relates to calculating the frame pointer, and records the
669 location of saved registers. */
672 output_call_frame_info (int for_eh
)
677 char l1
[20], l2
[20], section_start_label
[20];
678 bool any_lsda_needed
= false;
679 char augmentation
[6];
680 int augmentation_size
;
681 int fde_encoding
= DW_EH_PE_absptr
;
682 int per_encoding
= DW_EH_PE_absptr
;
683 int lsda_encoding
= DW_EH_PE_absptr
;
685 rtx personality
= NULL
;
688 /* Don't emit a CIE if there won't be any FDEs. */
692 /* Nothing to do if the assembler's doing it all. */
693 if (dwarf2out_do_cfi_asm ())
696 /* If we don't have any functions we'll want to unwind out of, don't emit
697 any EH unwind information. If we make FDEs linkonce, we may have to
698 emit an empty label for an FDE that wouldn't otherwise be emitted. We
699 want to avoid having an FDE kept around when the function it refers to
700 is discarded. Example where this matters: a primary function template
701 in C++ requires EH information, an explicit specialization doesn't. */
704 bool any_eh_needed
= false;
706 FOR_EACH_VEC_ELT (dw_fde_ref
, fde_vec
, i
, fde
)
708 if (fde
->uses_eh_lsda
)
709 any_eh_needed
= any_lsda_needed
= true;
710 else if (fde_needed_for_eh_p (fde
))
711 any_eh_needed
= true;
712 else if (TARGET_USES_WEAK_UNWIND_INFO
)
713 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
720 /* We're going to be generating comments, so turn on app. */
724 /* Switch to the proper frame section, first time. */
725 switch_to_frame_table_section (for_eh
, false);
727 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
728 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
730 /* Output the CIE. */
731 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
732 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
733 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
734 dw2_asm_output_data (4, 0xffffffff,
735 "Initial length escape value indicating 64-bit DWARF extension");
736 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
737 "Length of Common Information Entry");
738 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
740 /* Now that the CIE pointer is PC-relative for EH,
741 use 0 to identify the CIE. */
742 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
743 (for_eh
? 0 : DWARF_CIE_ID
),
744 "CIE Identifier Tag");
746 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
747 use CIE version 1, unless that would produce incorrect results
748 due to overflowing the return register column. */
749 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
751 if (return_reg
>= 256 || dwarf_version
> 2)
753 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
756 augmentation_size
= 0;
758 personality
= current_unit_personality
;
764 z Indicates that a uleb128 is present to size the
765 augmentation section.
766 L Indicates the encoding (and thus presence) of
767 an LSDA pointer in the FDE augmentation.
768 R Indicates a non-default pointer encoding for
770 P Indicates the presence of an encoding + language
771 personality routine in the CIE augmentation. */
773 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
774 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
775 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
777 p
= augmentation
+ 1;
781 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
782 assemble_external_libcall (personality
);
787 augmentation_size
+= 1;
789 if (fde_encoding
!= DW_EH_PE_absptr
)
792 augmentation_size
+= 1;
794 if (p
> augmentation
+ 1)
796 augmentation
[0] = 'z';
800 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
801 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
803 int offset
= ( 4 /* Length */
805 + 1 /* CIE version */
806 + strlen (augmentation
) + 1 /* Augmentation */
807 + size_of_uleb128 (1) /* Code alignment */
808 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
810 + 1 /* Augmentation size */
811 + 1 /* Personality encoding */ );
812 int pad
= -offset
& (PTR_SIZE
- 1);
814 augmentation_size
+= pad
;
816 /* Augmentations should be small, so there's scarce need to
817 iterate for a solution. Die if we exceed one uleb128 byte. */
818 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
822 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
823 if (dw_cie_version
>= 4)
825 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
826 dw2_asm_output_data (1, 0, "CIE Segment Size");
828 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
829 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
830 "CIE Data Alignment Factor");
832 if (dw_cie_version
== 1)
833 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
835 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
839 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
842 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
843 eh_data_format_name (per_encoding
));
844 dw2_asm_output_encoded_addr_rtx (per_encoding
,
850 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
851 eh_data_format_name (lsda_encoding
));
853 if (fde_encoding
!= DW_EH_PE_absptr
)
854 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
855 eh_data_format_name (fde_encoding
));
858 FOR_EACH_VEC_ELT (dw_cfi_ref
, cie_cfi_vec
, i
, cfi
)
859 output_cfi (cfi
, NULL
, for_eh
);
861 /* Pad the CIE out to an address sized boundary. */
862 ASM_OUTPUT_ALIGN (asm_out_file
,
863 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
864 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
866 /* Loop through all of the FDE's. */
867 FOR_EACH_VEC_ELT (dw_fde_ref
, fde_vec
, i
, fde
)
871 /* Don't emit EH unwind info for leaf functions that don't need it. */
872 if (for_eh
&& !fde_needed_for_eh_p (fde
))
875 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
876 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
877 augmentation
, any_lsda_needed
, lsda_encoding
);
880 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
881 dw2_asm_output_data (4, 0, "End of Table");
882 #ifdef MIPS_DEBUGGING_INFO
883 /* Work around Irix 6 assembler bug whereby labels at the end of a section
884 get a value of 0. Putting .align 0 after the label fixes it. */
885 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
888 /* Turn off app to make assembly quicker. */
893 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
896 dwarf2out_do_cfi_startproc (bool second
)
900 rtx personality
= get_personality_function (current_function_decl
);
902 fprintf (asm_out_file
, "\t.cfi_startproc\n");
906 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
909 /* ??? The GAS support isn't entirely consistent. We have to
910 handle indirect support ourselves, but PC-relative is done
911 in the assembler. Further, the assembler can't handle any
912 of the weirder relocation types. */
913 if (enc
& DW_EH_PE_indirect
)
914 ref
= dw2_force_const_mem (ref
, true);
916 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
917 output_addr_const (asm_out_file
, ref
);
918 fputc ('\n', asm_out_file
);
921 if (crtl
->uses_eh_lsda
)
925 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
926 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
927 current_function_funcdef_no
);
928 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
929 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
931 if (enc
& DW_EH_PE_indirect
)
932 ref
= dw2_force_const_mem (ref
, true);
934 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
935 output_addr_const (asm_out_file
, ref
);
936 fputc ('\n', asm_out_file
);
940 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
941 this allocation may be done before pass_final. */
944 dwarf2out_alloc_current_fde (void)
948 fde
= ggc_alloc_cleared_dw_fde_node ();
949 fde
->decl
= current_function_decl
;
950 fde
->funcdef_number
= current_function_funcdef_no
;
951 fde
->fde_index
= VEC_length (dw_fde_ref
, fde_vec
);
952 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
953 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
954 fde
->nothrow
= crtl
->nothrow
;
955 fde
->drap_reg
= INVALID_REGNUM
;
956 fde
->vdrap_reg
= INVALID_REGNUM
;
958 /* Record the FDE associated with this function. */
960 VEC_safe_push (dw_fde_ref
, gc
, fde_vec
, fde
);
965 /* Output a marker (i.e. a label) for the beginning of a function, before
969 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
970 const char *file ATTRIBUTE_UNUSED
)
972 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
978 current_function_func_begin_label
= NULL
;
980 do_frame
= dwarf2out_do_frame ();
982 /* ??? current_function_func_begin_label is also used by except.c for
983 call-site information. We must emit this label if it might be used. */
986 || targetm_common
.except_unwind_info (&global_options
) != UI_TARGET
))
989 fnsec
= function_section (current_function_decl
);
990 switch_to_section (fnsec
);
991 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
992 current_function_funcdef_no
);
993 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
994 current_function_funcdef_no
);
995 dup_label
= xstrdup (label
);
996 current_function_func_begin_label
= dup_label
;
998 /* We can elide the fde allocation if we're not emitting debug info. */
1002 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1003 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1004 would include pass_dwarf2_frame. If we've not created the FDE yet,
1008 fde
= dwarf2out_alloc_current_fde ();
1010 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1011 fde
->dw_fde_begin
= dup_label
;
1012 fde
->dw_fde_current_label
= dup_label
;
1013 fde
->in_std_section
= (fnsec
== text_section
1014 || (cold_text_section
&& fnsec
== cold_text_section
));
1016 /* We only want to output line number information for the genuine dwarf2
1017 prologue case, not the eh frame case. */
1018 #ifdef DWARF2_DEBUGGING_INFO
1020 dwarf2out_source_line (line
, file
, 0, true);
1023 if (dwarf2out_do_cfi_asm ())
1024 dwarf2out_do_cfi_startproc (false);
1027 rtx personality
= get_personality_function (current_function_decl
);
1028 if (!current_unit_personality
)
1029 current_unit_personality
= personality
;
1031 /* We cannot keep a current personality per function as without CFI
1032 asm, at the point where we emit the CFI data, there is no current
1033 function anymore. */
1034 if (personality
&& current_unit_personality
!= personality
)
1035 sorry ("multiple EH personalities are supported only with assemblers "
1036 "supporting .cfi_personality directive");
1040 /* Output a marker (i.e. a label) for the end of the generated code
1041 for a function prologue. This gets called *after* the prologue code has
1045 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1046 const char *file ATTRIBUTE_UNUSED
)
1048 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1050 /* Output a label to mark the endpoint of the code generated for this
1052 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1053 current_function_funcdef_no
);
1054 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1055 current_function_funcdef_no
);
1056 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1059 /* Output a marker (i.e. a label) for the beginning of the generated code
1060 for a function epilogue. This gets called *before* the prologue code has
1064 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1065 const char *file ATTRIBUTE_UNUSED
)
1067 dw_fde_ref fde
= cfun
->fde
;
1068 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1070 if (fde
->dw_fde_vms_begin_epilogue
)
1073 /* Output a label to mark the endpoint of the code generated for this
1075 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1076 current_function_funcdef_no
);
1077 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1078 current_function_funcdef_no
);
1079 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1082 /* Output a marker (i.e. a label) for the absolute end of the generated code
1083 for a function definition. This gets called *after* the epilogue code has
1087 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1088 const char *file ATTRIBUTE_UNUSED
)
1091 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1093 last_var_location_insn
= NULL_RTX
;
1094 cached_next_real_insn
= NULL_RTX
;
1096 if (dwarf2out_do_cfi_asm ())
1097 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1099 /* Output a label to mark the endpoint of the code generated for this
1101 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1102 current_function_funcdef_no
);
1103 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1105 gcc_assert (fde
!= NULL
);
1106 if (fde
->dw_fde_second_begin
== NULL
)
1107 fde
->dw_fde_end
= xstrdup (label
);
1111 dwarf2out_frame_finish (void)
1113 /* Output call frame information. */
1114 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1115 output_call_frame_info (0);
1117 /* Output another copy for the unwinder. */
1118 if ((flag_unwind_tables
|| flag_exceptions
)
1119 && targetm_common
.except_unwind_info (&global_options
) == UI_DWARF2
)
1120 output_call_frame_info (1);
1123 /* Note that the current function section is being used for code. */
1126 dwarf2out_note_section_used (void)
1128 section
*sec
= current_function_section ();
1129 if (sec
== text_section
)
1130 text_section_used
= true;
1131 else if (sec
== cold_text_section
)
1132 cold_text_section_used
= true;
1135 static void var_location_switch_text_section (void);
1136 static void set_cur_line_info_table (section
*);
1139 dwarf2out_switch_text_section (void)
1142 dw_fde_ref fde
= cfun
->fde
;
1144 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1146 if (!in_cold_section_p
)
1148 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1149 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1150 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1154 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1155 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1156 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1158 have_multiple_function_sections
= true;
1160 /* There is no need to mark used sections when not debugging. */
1161 if (cold_text_section
!= NULL
)
1162 dwarf2out_note_section_used ();
1164 if (dwarf2out_do_cfi_asm ())
1165 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1167 /* Now do the real section switch. */
1168 sect
= current_function_section ();
1169 switch_to_section (sect
);
1171 fde
->second_in_std_section
1172 = (sect
== text_section
1173 || (cold_text_section
&& sect
== cold_text_section
));
1175 if (dwarf2out_do_cfi_asm ())
1176 dwarf2out_do_cfi_startproc (true);
1178 var_location_switch_text_section ();
1180 if (cold_text_section
!= NULL
)
1181 set_cur_line_info_table (sect
);
1184 /* And now, the subset of the debugging information support code necessary
1185 for emitting location expressions. */
1187 /* Data about a single source file. */
1188 struct GTY(()) dwarf_file_data
{
1189 const char * filename
;
1193 typedef struct GTY(()) deferred_locations_struct
1197 } deferred_locations
;
1199 DEF_VEC_O(deferred_locations
);
1200 DEF_VEC_ALLOC_O(deferred_locations
,gc
);
1202 static GTY(()) VEC(deferred_locations
, gc
) *deferred_locations_list
;
1204 DEF_VEC_P(dw_die_ref
);
1205 DEF_VEC_ALLOC_P(dw_die_ref
,heap
);
1207 /* Location lists are ranges + location descriptions for that range,
1208 so you can track variables that are in different places over
1209 their entire life. */
1210 typedef struct GTY(()) dw_loc_list_struct
{
1211 dw_loc_list_ref dw_loc_next
;
1212 const char *begin
; /* Label for begin address of range */
1213 const char *end
; /* Label for end address of range */
1214 char *ll_symbol
; /* Label for beginning of location list.
1215 Only on head of list */
1216 const char *section
; /* Section this loclist is relative to */
1217 dw_loc_descr_ref expr
;
1219 /* True if all addresses in this and subsequent lists are known to be
1222 /* True if this list has been replaced by dw_loc_next. */
1225 /* True if the range should be emitted even if begin and end
1230 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
1232 /* Convert a DWARF stack opcode into its string name. */
1235 dwarf_stack_op_name (unsigned int op
)
1240 return "DW_OP_addr";
1242 return "DW_OP_deref";
1244 return "DW_OP_const1u";
1246 return "DW_OP_const1s";
1248 return "DW_OP_const2u";
1250 return "DW_OP_const2s";
1252 return "DW_OP_const4u";
1254 return "DW_OP_const4s";
1256 return "DW_OP_const8u";
1258 return "DW_OP_const8s";
1260 return "DW_OP_constu";
1262 return "DW_OP_consts";
1266 return "DW_OP_drop";
1268 return "DW_OP_over";
1270 return "DW_OP_pick";
1272 return "DW_OP_swap";
1276 return "DW_OP_xderef";
1284 return "DW_OP_minus";
1296 return "DW_OP_plus";
1297 case DW_OP_plus_uconst
:
1298 return "DW_OP_plus_uconst";
1304 return "DW_OP_shra";
1322 return "DW_OP_skip";
1324 return "DW_OP_lit0";
1326 return "DW_OP_lit1";
1328 return "DW_OP_lit2";
1330 return "DW_OP_lit3";
1332 return "DW_OP_lit4";
1334 return "DW_OP_lit5";
1336 return "DW_OP_lit6";
1338 return "DW_OP_lit7";
1340 return "DW_OP_lit8";
1342 return "DW_OP_lit9";
1344 return "DW_OP_lit10";
1346 return "DW_OP_lit11";
1348 return "DW_OP_lit12";
1350 return "DW_OP_lit13";
1352 return "DW_OP_lit14";
1354 return "DW_OP_lit15";
1356 return "DW_OP_lit16";
1358 return "DW_OP_lit17";
1360 return "DW_OP_lit18";
1362 return "DW_OP_lit19";
1364 return "DW_OP_lit20";
1366 return "DW_OP_lit21";
1368 return "DW_OP_lit22";
1370 return "DW_OP_lit23";
1372 return "DW_OP_lit24";
1374 return "DW_OP_lit25";
1376 return "DW_OP_lit26";
1378 return "DW_OP_lit27";
1380 return "DW_OP_lit28";
1382 return "DW_OP_lit29";
1384 return "DW_OP_lit30";
1386 return "DW_OP_lit31";
1388 return "DW_OP_reg0";
1390 return "DW_OP_reg1";
1392 return "DW_OP_reg2";
1394 return "DW_OP_reg3";
1396 return "DW_OP_reg4";
1398 return "DW_OP_reg5";
1400 return "DW_OP_reg6";
1402 return "DW_OP_reg7";
1404 return "DW_OP_reg8";
1406 return "DW_OP_reg9";
1408 return "DW_OP_reg10";
1410 return "DW_OP_reg11";
1412 return "DW_OP_reg12";
1414 return "DW_OP_reg13";
1416 return "DW_OP_reg14";
1418 return "DW_OP_reg15";
1420 return "DW_OP_reg16";
1422 return "DW_OP_reg17";
1424 return "DW_OP_reg18";
1426 return "DW_OP_reg19";
1428 return "DW_OP_reg20";
1430 return "DW_OP_reg21";
1432 return "DW_OP_reg22";
1434 return "DW_OP_reg23";
1436 return "DW_OP_reg24";
1438 return "DW_OP_reg25";
1440 return "DW_OP_reg26";
1442 return "DW_OP_reg27";
1444 return "DW_OP_reg28";
1446 return "DW_OP_reg29";
1448 return "DW_OP_reg30";
1450 return "DW_OP_reg31";
1452 return "DW_OP_breg0";
1454 return "DW_OP_breg1";
1456 return "DW_OP_breg2";
1458 return "DW_OP_breg3";
1460 return "DW_OP_breg4";
1462 return "DW_OP_breg5";
1464 return "DW_OP_breg6";
1466 return "DW_OP_breg7";
1468 return "DW_OP_breg8";
1470 return "DW_OP_breg9";
1472 return "DW_OP_breg10";
1474 return "DW_OP_breg11";
1476 return "DW_OP_breg12";
1478 return "DW_OP_breg13";
1480 return "DW_OP_breg14";
1482 return "DW_OP_breg15";
1484 return "DW_OP_breg16";
1486 return "DW_OP_breg17";
1488 return "DW_OP_breg18";
1490 return "DW_OP_breg19";
1492 return "DW_OP_breg20";
1494 return "DW_OP_breg21";
1496 return "DW_OP_breg22";
1498 return "DW_OP_breg23";
1500 return "DW_OP_breg24";
1502 return "DW_OP_breg25";
1504 return "DW_OP_breg26";
1506 return "DW_OP_breg27";
1508 return "DW_OP_breg28";
1510 return "DW_OP_breg29";
1512 return "DW_OP_breg30";
1514 return "DW_OP_breg31";
1516 return "DW_OP_regx";
1518 return "DW_OP_fbreg";
1520 return "DW_OP_bregx";
1522 return "DW_OP_piece";
1523 case DW_OP_deref_size
:
1524 return "DW_OP_deref_size";
1525 case DW_OP_xderef_size
:
1526 return "DW_OP_xderef_size";
1530 case DW_OP_push_object_address
:
1531 return "DW_OP_push_object_address";
1533 return "DW_OP_call2";
1535 return "DW_OP_call4";
1536 case DW_OP_call_ref
:
1537 return "DW_OP_call_ref";
1538 case DW_OP_implicit_value
:
1539 return "DW_OP_implicit_value";
1540 case DW_OP_stack_value
:
1541 return "DW_OP_stack_value";
1542 case DW_OP_form_tls_address
:
1543 return "DW_OP_form_tls_address";
1544 case DW_OP_call_frame_cfa
:
1545 return "DW_OP_call_frame_cfa";
1546 case DW_OP_bit_piece
:
1547 return "DW_OP_bit_piece";
1549 case DW_OP_GNU_push_tls_address
:
1550 return "DW_OP_GNU_push_tls_address";
1551 case DW_OP_GNU_uninit
:
1552 return "DW_OP_GNU_uninit";
1553 case DW_OP_GNU_encoded_addr
:
1554 return "DW_OP_GNU_encoded_addr";
1555 case DW_OP_GNU_implicit_pointer
:
1556 return "DW_OP_GNU_implicit_pointer";
1557 case DW_OP_GNU_entry_value
:
1558 return "DW_OP_GNU_entry_value";
1559 case DW_OP_GNU_const_type
:
1560 return "DW_OP_GNU_const_type";
1561 case DW_OP_GNU_regval_type
:
1562 return "DW_OP_GNU_regval_type";
1563 case DW_OP_GNU_deref_type
:
1564 return "DW_OP_GNU_deref_type";
1565 case DW_OP_GNU_convert
:
1566 return "DW_OP_GNU_convert";
1567 case DW_OP_GNU_reinterpret
:
1568 return "DW_OP_GNU_reinterpret";
1569 case DW_OP_GNU_parameter_ref
:
1570 return "DW_OP_GNU_parameter_ref";
1573 return "OP_<unknown>";
1577 /* Return a pointer to a newly allocated location description. Location
1578 descriptions are simple expression terms that can be strung
1579 together to form more complicated location (address) descriptions. */
1581 static inline dw_loc_descr_ref
1582 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1583 unsigned HOST_WIDE_INT oprnd2
)
1585 dw_loc_descr_ref descr
= ggc_alloc_cleared_dw_loc_descr_node ();
1587 descr
->dw_loc_opc
= op
;
1588 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1589 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1590 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1591 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1596 /* Return a pointer to a newly allocated location description for
1599 static inline dw_loc_descr_ref
1600 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
1603 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1606 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
1609 /* Add a location description term to a location description expression. */
1612 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1614 dw_loc_descr_ref
*d
;
1616 /* Find the end of the chain. */
1617 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1623 /* Compare two location operands for exact equality. */
1626 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1628 if (a
->val_class
!= b
->val_class
)
1630 switch (a
->val_class
)
1632 case dw_val_class_none
:
1634 case dw_val_class_addr
:
1635 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1637 case dw_val_class_offset
:
1638 case dw_val_class_unsigned_const
:
1639 case dw_val_class_const
:
1640 case dw_val_class_range_list
:
1641 case dw_val_class_lineptr
:
1642 case dw_val_class_macptr
:
1643 /* These are all HOST_WIDE_INT, signed or unsigned. */
1644 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1646 case dw_val_class_loc
:
1647 return a
->v
.val_loc
== b
->v
.val_loc
;
1648 case dw_val_class_loc_list
:
1649 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1650 case dw_val_class_die_ref
:
1651 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1652 case dw_val_class_fde_ref
:
1653 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1654 case dw_val_class_lbl_id
:
1655 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1656 case dw_val_class_str
:
1657 return a
->v
.val_str
== b
->v
.val_str
;
1658 case dw_val_class_flag
:
1659 return a
->v
.val_flag
== b
->v
.val_flag
;
1660 case dw_val_class_file
:
1661 return a
->v
.val_file
== b
->v
.val_file
;
1662 case dw_val_class_decl_ref
:
1663 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1665 case dw_val_class_const_double
:
1666 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1667 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1669 case dw_val_class_vec
:
1671 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1672 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1674 return (a_len
== b_len
1675 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1678 case dw_val_class_data8
:
1679 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1681 case dw_val_class_vms_delta
:
1682 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1683 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1688 /* Compare two location atoms for exact equality. */
1691 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1693 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1696 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1697 address size, but since we always allocate cleared storage it
1698 should be zero for other types of locations. */
1699 if (a
->dtprel
!= b
->dtprel
)
1702 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1703 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1706 /* Compare two complete location expressions for exact equality. */
1709 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1715 if (a
== NULL
|| b
== NULL
)
1717 if (!loc_descr_equal_p_1 (a
, b
))
1726 /* Add a constant OFFSET to a location expression. */
1729 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
1731 dw_loc_descr_ref loc
;
1734 gcc_assert (*list_head
!= NULL
);
1739 /* Find the end of the chain. */
1740 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1744 if (loc
->dw_loc_opc
== DW_OP_fbreg
1745 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1746 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1747 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1748 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1750 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1751 offset. Don't optimize if an signed integer overflow would happen. */
1753 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1754 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1757 else if (offset
> 0)
1758 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1762 loc
->dw_loc_next
= int_loc_descriptor (-offset
);
1763 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1767 /* Add a constant OFFSET to a location list. */
1770 loc_list_plus_const (dw_loc_list_ref list_head
, HOST_WIDE_INT offset
)
1773 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1774 loc_descr_plus_const (&d
->expr
, offset
);
1777 #define DWARF_REF_SIZE \
1778 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1780 static unsigned long int get_base_type_offset (dw_die_ref
);
1782 /* Return the size of a location descriptor. */
1784 static unsigned long
1785 size_of_loc_descr (dw_loc_descr_ref loc
)
1787 unsigned long size
= 1;
1789 switch (loc
->dw_loc_opc
)
1792 size
+= DWARF2_ADDR_SIZE
;
1811 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1814 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1819 case DW_OP_plus_uconst
:
1820 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1858 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1861 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1864 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1867 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1868 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1871 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1873 case DW_OP_bit_piece
:
1874 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1875 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1877 case DW_OP_deref_size
:
1878 case DW_OP_xderef_size
:
1887 case DW_OP_call_ref
:
1888 size
+= DWARF_REF_SIZE
;
1890 case DW_OP_implicit_value
:
1891 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1892 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1894 case DW_OP_GNU_implicit_pointer
:
1895 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1897 case DW_OP_GNU_entry_value
:
1899 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1900 size
+= size_of_uleb128 (op_size
) + op_size
;
1903 case DW_OP_GNU_const_type
:
1906 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1907 size
+= size_of_uleb128 (o
) + 1;
1908 switch (loc
->dw_loc_oprnd2
.val_class
)
1910 case dw_val_class_vec
:
1911 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1912 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1914 case dw_val_class_const
:
1915 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1917 case dw_val_class_const_double
:
1918 size
+= 2 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1925 case DW_OP_GNU_regval_type
:
1928 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1929 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1930 + size_of_uleb128 (o
);
1933 case DW_OP_GNU_deref_type
:
1936 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1937 size
+= 1 + size_of_uleb128 (o
);
1940 case DW_OP_GNU_convert
:
1941 case DW_OP_GNU_reinterpret
:
1942 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1943 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1947 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1948 size
+= size_of_uleb128 (o
);
1951 case DW_OP_GNU_parameter_ref
:
1961 /* Return the size of a series of location descriptors. */
1964 size_of_locs (dw_loc_descr_ref loc
)
1969 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1970 field, to avoid writing to a PCH file. */
1971 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1973 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1975 size
+= size_of_loc_descr (l
);
1980 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1982 l
->dw_loc_addr
= size
;
1983 size
+= size_of_loc_descr (l
);
1989 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
1990 static void get_ref_die_offset_label (char *, dw_die_ref
);
1991 static unsigned long int get_ref_die_offset (dw_die_ref
);
1993 /* Output location description stack opcode's operands (if any).
1994 The for_eh_or_skip parameter controls whether register numbers are
1995 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1996 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1997 info). This should be suppressed for the cases that have not been converted
1998 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2001 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2003 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2004 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2006 switch (loc
->dw_loc_opc
)
2008 #ifdef DWARF2_DEBUGGING_INFO
2011 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2016 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2017 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
2019 fputc ('\n', asm_out_file
);
2024 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2029 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2030 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
2032 fputc ('\n', asm_out_file
);
2037 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2038 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2045 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2046 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2048 dw2_asm_output_data (2, offset
, NULL
);
2051 case DW_OP_implicit_value
:
2052 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2053 switch (val2
->val_class
)
2055 case dw_val_class_const
:
2056 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2058 case dw_val_class_vec
:
2060 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2061 unsigned int len
= val2
->v
.val_vec
.length
;
2065 if (elt_size
> sizeof (HOST_WIDE_INT
))
2070 for (i
= 0, p
= val2
->v
.val_vec
.array
;
2073 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2074 "fp or vector constant word %u", i
);
2077 case dw_val_class_const_double
:
2079 unsigned HOST_WIDE_INT first
, second
;
2081 if (WORDS_BIG_ENDIAN
)
2083 first
= val2
->v
.val_double
.high
;
2084 second
= val2
->v
.val_double
.low
;
2088 first
= val2
->v
.val_double
.low
;
2089 second
= val2
->v
.val_double
.high
;
2091 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2093 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2097 case dw_val_class_addr
:
2098 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2099 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2114 case DW_OP_implicit_value
:
2115 /* We currently don't make any attempt to make sure these are
2116 aligned properly like we do for the main unwind info, so
2117 don't support emitting things larger than a byte if we're
2118 only doing unwinding. */
2123 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2126 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2129 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2132 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2134 case DW_OP_plus_uconst
:
2135 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2169 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2173 unsigned r
= val1
->v
.val_unsigned
;
2174 if (for_eh_or_skip
>= 0)
2175 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2176 gcc_assert (size_of_uleb128 (r
)
2177 == size_of_uleb128 (val1
->v
.val_unsigned
));
2178 dw2_asm_output_data_uleb128 (r
, NULL
);
2182 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2186 unsigned r
= val1
->v
.val_unsigned
;
2187 if (for_eh_or_skip
>= 0)
2188 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2189 gcc_assert (size_of_uleb128 (r
)
2190 == size_of_uleb128 (val1
->v
.val_unsigned
));
2191 dw2_asm_output_data_uleb128 (r
, NULL
);
2192 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2196 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2198 case DW_OP_bit_piece
:
2199 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2200 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2202 case DW_OP_deref_size
:
2203 case DW_OP_xderef_size
:
2204 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2210 if (targetm
.asm_out
.output_dwarf_dtprel
)
2212 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2215 fputc ('\n', asm_out_file
);
2222 #ifdef DWARF2_DEBUGGING_INFO
2223 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2230 case DW_OP_GNU_implicit_pointer
:
2232 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2233 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2234 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2235 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2236 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2237 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2241 case DW_OP_GNU_entry_value
:
2242 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2243 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2246 case DW_OP_GNU_const_type
:
2248 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2250 dw2_asm_output_data_uleb128 (o
, NULL
);
2251 switch (val2
->val_class
)
2253 case dw_val_class_const
:
2254 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2255 dw2_asm_output_data (1, l
, NULL
);
2256 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2258 case dw_val_class_vec
:
2260 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2261 unsigned int len
= val2
->v
.val_vec
.length
;
2266 dw2_asm_output_data (1, l
, NULL
);
2267 if (elt_size
> sizeof (HOST_WIDE_INT
))
2272 for (i
= 0, p
= val2
->v
.val_vec
.array
;
2275 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2276 "fp or vector constant word %u", i
);
2279 case dw_val_class_const_double
:
2281 unsigned HOST_WIDE_INT first
, second
;
2282 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2284 dw2_asm_output_data (1, 2 * l
, NULL
);
2285 if (WORDS_BIG_ENDIAN
)
2287 first
= val2
->v
.val_double
.high
;
2288 second
= val2
->v
.val_double
.low
;
2292 first
= val2
->v
.val_double
.low
;
2293 second
= val2
->v
.val_double
.high
;
2295 dw2_asm_output_data (l
, first
, NULL
);
2296 dw2_asm_output_data (l
, second
, NULL
);
2304 case DW_OP_GNU_regval_type
:
2306 unsigned r
= val1
->v
.val_unsigned
;
2307 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2309 if (for_eh_or_skip
>= 0)
2311 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2312 gcc_assert (size_of_uleb128 (r
)
2313 == size_of_uleb128 (val1
->v
.val_unsigned
));
2315 dw2_asm_output_data_uleb128 (r
, NULL
);
2316 dw2_asm_output_data_uleb128 (o
, NULL
);
2319 case DW_OP_GNU_deref_type
:
2321 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2323 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2324 dw2_asm_output_data_uleb128 (o
, NULL
);
2327 case DW_OP_GNU_convert
:
2328 case DW_OP_GNU_reinterpret
:
2329 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2330 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2333 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2335 dw2_asm_output_data_uleb128 (o
, NULL
);
2339 case DW_OP_GNU_parameter_ref
:
2342 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2343 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2344 dw2_asm_output_data (4, o
, NULL
);
2349 /* Other codes have no operands. */
2354 /* Output a sequence of location operations.
2355 The for_eh_or_skip parameter controls whether register numbers are
2356 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2357 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2358 info). This should be suppressed for the cases that have not been converted
2359 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2362 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2364 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2366 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2367 /* Output the opcode. */
2368 if (for_eh_or_skip
>= 0
2369 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2371 unsigned r
= (opc
- DW_OP_breg0
);
2372 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2373 gcc_assert (r
<= 31);
2374 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2376 else if (for_eh_or_skip
>= 0
2377 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2379 unsigned r
= (opc
- DW_OP_reg0
);
2380 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2381 gcc_assert (r
<= 31);
2382 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2385 dw2_asm_output_data (1, opc
,
2386 "%s", dwarf_stack_op_name (opc
));
2388 /* Output the operand(s) (if any). */
2389 output_loc_operands (loc
, for_eh_or_skip
);
2393 /* Output location description stack opcode's operands (if any).
2394 The output is single bytes on a line, suitable for .cfi_escape. */
2397 output_loc_operands_raw (dw_loc_descr_ref loc
)
2399 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2400 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2402 switch (loc
->dw_loc_opc
)
2405 case DW_OP_implicit_value
:
2406 /* We cannot output addresses in .cfi_escape, only bytes. */
2412 case DW_OP_deref_size
:
2413 case DW_OP_xderef_size
:
2414 fputc (',', asm_out_file
);
2415 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2420 fputc (',', asm_out_file
);
2421 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2426 fputc (',', asm_out_file
);
2427 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2432 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2433 fputc (',', asm_out_file
);
2434 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2442 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2443 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2445 fputc (',', asm_out_file
);
2446 dw2_asm_output_data_raw (2, offset
);
2452 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2453 gcc_assert (size_of_uleb128 (r
)
2454 == size_of_uleb128 (val1
->v
.val_unsigned
));
2455 fputc (',', asm_out_file
);
2456 dw2_asm_output_data_uleb128_raw (r
);
2461 case DW_OP_plus_uconst
:
2463 fputc (',', asm_out_file
);
2464 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2467 case DW_OP_bit_piece
:
2468 fputc (',', asm_out_file
);
2469 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2470 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2507 fputc (',', asm_out_file
);
2508 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2513 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2514 gcc_assert (size_of_uleb128 (r
)
2515 == size_of_uleb128 (val1
->v
.val_unsigned
));
2516 fputc (',', asm_out_file
);
2517 dw2_asm_output_data_uleb128_raw (r
);
2518 fputc (',', asm_out_file
);
2519 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2523 case DW_OP_GNU_implicit_pointer
:
2524 case DW_OP_GNU_entry_value
:
2525 case DW_OP_GNU_const_type
:
2526 case DW_OP_GNU_regval_type
:
2527 case DW_OP_GNU_deref_type
:
2528 case DW_OP_GNU_convert
:
2529 case DW_OP_GNU_reinterpret
:
2530 case DW_OP_GNU_parameter_ref
:
2535 /* Other codes have no operands. */
2541 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2545 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2546 /* Output the opcode. */
2547 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2549 unsigned r
= (opc
- DW_OP_breg0
);
2550 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2551 gcc_assert (r
<= 31);
2552 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2554 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2556 unsigned r
= (opc
- DW_OP_reg0
);
2557 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2558 gcc_assert (r
<= 31);
2559 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2561 /* Output the opcode. */
2562 fprintf (asm_out_file
, "%#x", opc
);
2563 output_loc_operands_raw (loc
);
2565 if (!loc
->dw_loc_next
)
2567 loc
= loc
->dw_loc_next
;
2569 fputc (',', asm_out_file
);
2573 /* This function builds a dwarf location descriptor sequence from a
2574 dw_cfa_location, adding the given OFFSET to the result of the
2577 struct dw_loc_descr_struct
*
2578 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
2580 struct dw_loc_descr_struct
*head
, *tmp
;
2582 offset
+= cfa
->offset
;
2586 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2587 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2588 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2589 add_loc_descr (&head
, tmp
);
2592 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
2593 add_loc_descr (&head
, tmp
);
2597 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2602 /* This function builds a dwarf location descriptor sequence for
2603 the address at OFFSET from the CFA when stack is aligned to
2606 struct dw_loc_descr_struct
*
2607 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2608 HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
2610 struct dw_loc_descr_struct
*head
;
2611 unsigned int dwarf_fp
2612 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2614 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2615 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2617 head
= new_reg_loc_descr (dwarf_fp
, 0);
2618 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2619 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2620 loc_descr_plus_const (&head
, offset
);
2623 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2627 /* And now, the support for symbolic debugging information. */
2629 /* .debug_str support. */
2630 static int output_indirect_string (void **, void *);
2632 static void dwarf2out_init (const char *);
2633 static void dwarf2out_finish (const char *);
2634 static void dwarf2out_assembly_start (void);
2635 static void dwarf2out_define (unsigned int, const char *);
2636 static void dwarf2out_undef (unsigned int, const char *);
2637 static void dwarf2out_start_source_file (unsigned, const char *);
2638 static void dwarf2out_end_source_file (unsigned);
2639 static void dwarf2out_function_decl (tree
);
2640 static void dwarf2out_begin_block (unsigned, unsigned);
2641 static void dwarf2out_end_block (unsigned, unsigned);
2642 static bool dwarf2out_ignore_block (const_tree
);
2643 static void dwarf2out_global_decl (tree
);
2644 static void dwarf2out_type_decl (tree
, int);
2645 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool);
2646 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2648 static void dwarf2out_abstract_function (tree
);
2649 static void dwarf2out_var_location (rtx
);
2650 static void dwarf2out_begin_function (tree
);
2651 static void dwarf2out_set_name (tree
, tree
);
2653 /* The debug hooks structure. */
2655 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2659 dwarf2out_assembly_start
,
2662 dwarf2out_start_source_file
,
2663 dwarf2out_end_source_file
,
2664 dwarf2out_begin_block
,
2665 dwarf2out_end_block
,
2666 dwarf2out_ignore_block
,
2667 dwarf2out_source_line
,
2668 dwarf2out_begin_prologue
,
2669 #if VMS_DEBUGGING_INFO
2670 dwarf2out_vms_end_prologue
,
2671 dwarf2out_vms_begin_epilogue
,
2673 debug_nothing_int_charstar
,
2674 debug_nothing_int_charstar
,
2676 dwarf2out_end_epilogue
,
2677 dwarf2out_begin_function
,
2678 debug_nothing_int
, /* end_function */
2679 dwarf2out_function_decl
, /* function_decl */
2680 dwarf2out_global_decl
,
2681 dwarf2out_type_decl
, /* type_decl */
2682 dwarf2out_imported_module_or_decl
,
2683 debug_nothing_tree
, /* deferred_inline_function */
2684 /* The DWARF 2 backend tries to reduce debugging bloat by not
2685 emitting the abstract description of inline functions until
2686 something tries to reference them. */
2687 dwarf2out_abstract_function
, /* outlining_inline_function */
2688 debug_nothing_rtx
, /* label */
2689 debug_nothing_int
, /* handle_pch */
2690 dwarf2out_var_location
,
2691 dwarf2out_switch_text_section
,
2693 1, /* start_end_main_source_file */
2694 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2697 /* NOTE: In the comments in this file, many references are made to
2698 "Debugging Information Entries". This term is abbreviated as `DIE'
2699 throughout the remainder of this file. */
2701 /* An internal representation of the DWARF output is built, and then
2702 walked to generate the DWARF debugging info. The walk of the internal
2703 representation is done after the entire program has been compiled.
2704 The types below are used to describe the internal representation. */
2706 /* Whether to put type DIEs into their own section .debug_types instead
2707 of making them part of the .debug_info section. Only supported for
2708 Dwarf V4 or higher and the user didn't disable them through
2709 -fno-debug-types-section. It is more efficient to put them in a
2710 separate comdat sections since the linker will then be able to
2711 remove duplicates. But not all tools support .debug_types sections
2714 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2716 /* Various DIE's use offsets relative to the beginning of the
2717 .debug_info section to refer to each other. */
2719 typedef long int dw_offset
;
2721 /* Define typedefs here to avoid circular dependencies. */
2723 typedef struct dw_attr_struct
*dw_attr_ref
;
2724 typedef struct dw_line_info_struct
*dw_line_info_ref
;
2725 typedef struct pubname_struct
*pubname_ref
;
2726 typedef struct dw_ranges_struct
*dw_ranges_ref
;
2727 typedef struct dw_ranges_by_label_struct
*dw_ranges_by_label_ref
;
2728 typedef struct comdat_type_struct
*comdat_type_node_ref
;
2730 /* The entries in the line_info table more-or-less mirror the opcodes
2731 that are used in the real dwarf line table. Arrays of these entries
2732 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2735 enum dw_line_info_opcode
{
2736 /* Emit DW_LNE_set_address; the operand is the label index. */
2739 /* Emit a row to the matrix with the given line. This may be done
2740 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2744 /* Emit a DW_LNS_set_file. */
2747 /* Emit a DW_LNS_set_column. */
2750 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2753 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2754 LI_set_prologue_end
,
2755 LI_set_epilogue_begin
,
2757 /* Emit a DW_LNE_set_discriminator. */
2758 LI_set_discriminator
2761 typedef struct GTY(()) dw_line_info_struct
{
2762 enum dw_line_info_opcode opcode
;
2764 } dw_line_info_entry
;
2766 DEF_VEC_O(dw_line_info_entry
);
2767 DEF_VEC_ALLOC_O(dw_line_info_entry
, gc
);
2769 typedef struct GTY(()) dw_line_info_table_struct
{
2770 /* The label that marks the end of this section. */
2771 const char *end_label
;
2773 /* The values for the last row of the matrix, as collected in the table.
2774 These are used to minimize the changes to the next row. */
2775 unsigned int file_num
;
2776 unsigned int line_num
;
2777 unsigned int column_num
;
2782 VEC(dw_line_info_entry
, gc
) *entries
;
2783 } dw_line_info_table
;
2785 typedef dw_line_info_table
*dw_line_info_table_p
;
2787 DEF_VEC_P(dw_line_info_table_p
);
2788 DEF_VEC_ALLOC_P(dw_line_info_table_p
, gc
);
2790 /* Each DIE attribute has a field specifying the attribute kind,
2791 a link to the next attribute in the chain, and an attribute value.
2792 Attributes are typically linked below the DIE they modify. */
2794 typedef struct GTY(()) dw_attr_struct
{
2795 enum dwarf_attribute dw_attr
;
2796 dw_val_node dw_attr_val
;
2800 DEF_VEC_O(dw_attr_node
);
2801 DEF_VEC_ALLOC_O(dw_attr_node
,gc
);
2803 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2804 The children of each node form a circular list linked by
2805 die_sib. die_child points to the node *before* the "first" child node. */
2807 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct
{
2808 union die_symbol_or_type_node
2810 char * GTY ((tag ("0"))) die_symbol
;
2811 comdat_type_node_ref
GTY ((tag ("1"))) die_type_node
;
2813 GTY ((desc ("use_debug_types"))) die_id
;
2814 VEC(dw_attr_node
,gc
) * die_attr
;
2815 dw_die_ref die_parent
;
2816 dw_die_ref die_child
;
2818 dw_die_ref die_definition
; /* ref from a specification to its definition */
2819 dw_offset die_offset
;
2820 unsigned long die_abbrev
;
2822 /* Die is used and must not be pruned as unused. */
2823 int die_perennial_p
;
2824 unsigned int decl_id
;
2825 enum dwarf_tag die_tag
;
2829 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2830 #define FOR_EACH_CHILD(die, c, expr) do { \
2831 c = die->die_child; \
2835 } while (c != die->die_child); \
2838 /* The pubname structure */
2840 typedef struct GTY(()) pubname_struct
{
2846 DEF_VEC_O(pubname_entry
);
2847 DEF_VEC_ALLOC_O(pubname_entry
, gc
);
2849 struct GTY(()) dw_ranges_struct
{
2850 /* If this is positive, it's a block number, otherwise it's a
2851 bitwise-negated index into dw_ranges_by_label. */
2855 /* A structure to hold a macinfo entry. */
2857 typedef struct GTY(()) macinfo_struct
{
2859 unsigned HOST_WIDE_INT lineno
;
2864 DEF_VEC_O(macinfo_entry
);
2865 DEF_VEC_ALLOC_O(macinfo_entry
, gc
);
2867 struct GTY(()) dw_ranges_by_label_struct
{
2872 /* The comdat type node structure. */
2873 typedef struct GTY(()) comdat_type_struct
2875 dw_die_ref root_die
;
2876 dw_die_ref type_die
;
2877 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
2878 struct comdat_type_struct
*next
;
2882 /* The limbo die list structure. */
2883 typedef struct GTY(()) limbo_die_struct
{
2886 struct limbo_die_struct
*next
;
2890 typedef struct skeleton_chain_struct
2894 struct skeleton_chain_struct
*parent
;
2896 skeleton_chain_node
;
2898 /* Define a macro which returns nonzero for a TYPE_DECL which was
2899 implicitly generated for a type.
2901 Note that, unlike the C front-end (which generates a NULL named
2902 TYPE_DECL node for each complete tagged type, each array type,
2903 and each function type node created) the C++ front-end generates
2904 a _named_ TYPE_DECL node for each tagged type node created.
2905 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2906 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2907 front-end, but for each type, tagged or not. */
2909 #define TYPE_DECL_IS_STUB(decl) \
2910 (DECL_NAME (decl) == NULL_TREE \
2911 || (DECL_ARTIFICIAL (decl) \
2912 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2913 /* This is necessary for stub decls that \
2914 appear in nested inline functions. */ \
2915 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2916 && (decl_ultimate_origin (decl) \
2917 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2919 /* Information concerning the compilation unit's programming
2920 language, and compiler version. */
2922 /* Fixed size portion of the DWARF compilation unit header. */
2923 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2924 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2926 /* Fixed size portion of the DWARF comdat type unit header. */
2927 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2928 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2929 + DWARF_OFFSET_SIZE)
2931 /* Fixed size portion of public names info. */
2932 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2934 /* Fixed size portion of the address range info. */
2935 #define DWARF_ARANGES_HEADER_SIZE \
2936 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2937 DWARF2_ADDR_SIZE * 2) \
2938 - DWARF_INITIAL_LENGTH_SIZE)
2940 /* Size of padding portion in the address range info. It must be
2941 aligned to twice the pointer size. */
2942 #define DWARF_ARANGES_PAD_SIZE \
2943 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2944 DWARF2_ADDR_SIZE * 2) \
2945 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2947 /* Use assembler line directives if available. */
2948 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2949 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2950 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2952 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2956 /* Minimum line offset in a special line info. opcode.
2957 This value was chosen to give a reasonable range of values. */
2958 #define DWARF_LINE_BASE -10
2960 /* First special line opcode - leave room for the standard opcodes. */
2961 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2963 /* Range of line offsets in a special line info. opcode. */
2964 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2966 /* Flag that indicates the initial value of the is_stmt_start flag.
2967 In the present implementation, we do not mark any lines as
2968 the beginning of a source statement, because that information
2969 is not made available by the GCC front-end. */
2970 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2972 /* Maximum number of operations per instruction bundle. */
2973 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2974 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2977 /* This location is used by calc_die_sizes() to keep track
2978 the offset of each DIE within the .debug_info section. */
2979 static unsigned long next_die_offset
;
2981 /* Record the root of the DIE's built for the current compilation unit. */
2982 static GTY(()) dw_die_ref single_comp_unit_die
;
2984 /* A list of type DIEs that have been separated into comdat sections. */
2985 static GTY(()) comdat_type_node
*comdat_type_list
;
2987 /* A list of DIEs with a NULL parent waiting to be relocated. */
2988 static GTY(()) limbo_die_node
*limbo_die_list
;
2990 /* A list of DIEs for which we may have to generate
2991 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2992 static GTY(()) limbo_die_node
*deferred_asm_name
;
2994 /* Filenames referenced by this compilation unit. */
2995 static GTY((param_is (struct dwarf_file_data
))) htab_t file_table
;
2997 /* A hash table of references to DIE's that describe declarations.
2998 The key is a DECL_UID() which is a unique number identifying each decl. */
2999 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
3001 /* A hash table of references to DIE's that describe COMMON blocks.
3002 The key is DECL_UID() ^ die_parent. */
3003 static GTY ((param_is (struct die_struct
))) htab_t common_block_die_table
;
3005 typedef struct GTY(()) die_arg_entry_struct
{
3010 DEF_VEC_O(die_arg_entry
);
3011 DEF_VEC_ALLOC_O(die_arg_entry
,gc
);
3013 /* Node of the variable location list. */
3014 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3015 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3016 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3017 in mode of the EXPR_LIST node and first EXPR_LIST operand
3018 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3019 location or NULL for padding. For larger bitsizes,
3020 mode is 0 and first operand is a CONCAT with bitsize
3021 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3022 NULL as second operand. */
3024 const char * GTY (()) label
;
3025 struct var_loc_node
* GTY (()) next
;
3028 /* Variable location list. */
3029 struct GTY (()) var_loc_list_def
{
3030 struct var_loc_node
* GTY (()) first
;
3032 /* Pointer to the last but one or last element of the
3033 chained list. If the list is empty, both first and
3034 last are NULL, if the list contains just one node
3035 or the last node certainly is not redundant, it points
3036 to the last node, otherwise points to the last but one.
3037 Do not mark it for GC because it is marked through the chain. */
3038 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3040 /* Pointer to the last element before section switch,
3041 if NULL, either sections weren't switched or first
3042 is after section switch. */
3043 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3045 /* DECL_UID of the variable decl. */
3046 unsigned int decl_id
;
3048 typedef struct var_loc_list_def var_loc_list
;
3050 /* Call argument location list. */
3051 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3052 rtx
GTY (()) call_arg_loc_note
;
3053 const char * GTY (()) label
;
3054 tree
GTY (()) block
;
3056 rtx
GTY (()) symbol_ref
;
3057 struct call_arg_loc_node
* GTY (()) next
;
3061 /* Table of decl location linked lists. */
3062 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
3064 /* Head and tail of call_arg_loc chain. */
3065 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3066 static struct call_arg_loc_node
*call_arg_loc_last
;
3068 /* Number of call sites in the current function. */
3069 static int call_site_count
= -1;
3070 /* Number of tail call sites in the current function. */
3071 static int tail_call_site_count
= -1;
3073 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
3075 static VEC (dw_die_ref
, heap
) *block_map
;
3077 /* A cached location list. */
3078 struct GTY (()) cached_dw_loc_list_def
{
3079 /* The DECL_UID of the decl that this entry describes. */
3080 unsigned int decl_id
;
3082 /* The cached location list. */
3083 dw_loc_list_ref loc_list
;
3085 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3087 /* Table of cached location lists. */
3088 static GTY ((param_is (cached_dw_loc_list
))) htab_t cached_dw_loc_list_table
;
3090 /* A pointer to the base of a list of references to DIE's that
3091 are uniquely identified by their tag, presence/absence of
3092 children DIE's, and list of attribute/value pairs. */
3093 static GTY((length ("abbrev_die_table_allocated")))
3094 dw_die_ref
*abbrev_die_table
;
3096 /* Number of elements currently allocated for abbrev_die_table. */
3097 static GTY(()) unsigned abbrev_die_table_allocated
;
3099 /* Number of elements in type_die_table currently in use. */
3100 static GTY(()) unsigned abbrev_die_table_in_use
;
3102 /* Size (in elements) of increments by which we may expand the
3103 abbrev_die_table. */
3104 #define ABBREV_DIE_TABLE_INCREMENT 256
3106 /* A global counter for generating labels for line number data. */
3107 static unsigned int line_info_label_num
;
3109 /* The current table to which we should emit line number information
3110 for the current function. This will be set up at the beginning of
3111 assembly for the function. */
3112 static dw_line_info_table
*cur_line_info_table
;
3114 /* The two default tables of line number info. */
3115 static GTY(()) dw_line_info_table
*text_section_line_info
;
3116 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3118 /* The set of all non-default tables of line number info. */
3119 static GTY(()) VEC (dw_line_info_table_p
, gc
) *separate_line_info
;
3121 /* A flag to tell pubnames/types export if there is an info section to
3123 static bool info_section_emitted
;
3125 /* A pointer to the base of a table that contains a list of publicly
3126 accessible names. */
3127 static GTY (()) VEC (pubname_entry
, gc
) * pubname_table
;
3129 /* A pointer to the base of a table that contains a list of publicly
3130 accessible types. */
3131 static GTY (()) VEC (pubname_entry
, gc
) * pubtype_table
;
3133 /* A pointer to the base of a table that contains a list of macro
3134 defines/undefines (and file start/end markers). */
3135 static GTY (()) VEC (macinfo_entry
, gc
) * macinfo_table
;
3137 /* Array of dies for which we should generate .debug_ranges info. */
3138 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
3140 /* Number of elements currently allocated for ranges_table. */
3141 static GTY(()) unsigned ranges_table_allocated
;
3143 /* Number of elements in ranges_table currently in use. */
3144 static GTY(()) unsigned ranges_table_in_use
;
3146 /* Array of pairs of labels referenced in ranges_table. */
3147 static GTY ((length ("ranges_by_label_allocated")))
3148 dw_ranges_by_label_ref ranges_by_label
;
3150 /* Number of elements currently allocated for ranges_by_label. */
3151 static GTY(()) unsigned ranges_by_label_allocated
;
3153 /* Number of elements in ranges_by_label currently in use. */
3154 static GTY(()) unsigned ranges_by_label_in_use
;
3156 /* Size (in elements) of increments by which we may expand the
3158 #define RANGES_TABLE_INCREMENT 64
3160 /* Whether we have location lists that need outputting */
3161 static GTY(()) bool have_location_lists
;
3163 /* Unique label counter. */
3164 static GTY(()) unsigned int loclabel_num
;
3166 /* Unique label counter for point-of-call tables. */
3167 static GTY(()) unsigned int poc_label_num
;
3169 /* Record whether the function being analyzed contains inlined functions. */
3170 static int current_function_has_inlines
;
3172 /* The last file entry emitted by maybe_emit_file(). */
3173 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3175 /* Number of internal labels generated by gen_internal_sym(). */
3176 static GTY(()) int label_num
;
3178 /* Cached result of previous call to lookup_filename. */
3179 static GTY(()) struct dwarf_file_data
* file_table_last_lookup
;
3181 static GTY(()) VEC(die_arg_entry
,gc
) *tmpl_value_parm_die_table
;
3183 /* Instances of generic types for which we need to generate debug
3184 info that describe their generic parameters and arguments. That
3185 generation needs to happen once all types are properly laid out so
3186 we do it at the end of compilation. */
3187 static GTY(()) VEC(tree
,gc
) *generic_type_instances
;
3189 /* Offset from the "steady-state frame pointer" to the frame base,
3190 within the current function. */
3191 static HOST_WIDE_INT frame_pointer_fb_offset
;
3192 static bool frame_pointer_fb_offset_valid
;
3194 static VEC (dw_die_ref
, heap
) *base_types
;
3196 /* Forward declarations for functions defined in this file. */
3198 static int is_pseudo_reg (const_rtx
);
3199 static tree
type_main_variant (tree
);
3200 static int is_tagged_type (const_tree
);
3201 static const char *dwarf_tag_name (unsigned);
3202 static const char *dwarf_attr_name (unsigned);
3203 static const char *dwarf_form_name (unsigned);
3204 static tree
decl_ultimate_origin (const_tree
);
3205 static tree
decl_class_context (tree
);
3206 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
3207 static inline enum dw_val_class
AT_class (dw_attr_ref
);
3208 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3209 static inline unsigned AT_flag (dw_attr_ref
);
3210 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3211 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
3212 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3213 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
3214 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3215 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3216 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3217 unsigned int, unsigned char *);
3218 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3219 static hashval_t
debug_str_do_hash (const void *);
3220 static int debug_str_eq (const void *, const void *);
3221 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3222 static inline const char *AT_string (dw_attr_ref
);
3223 static enum dwarf_form
AT_string_form (dw_attr_ref
);
3224 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3225 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3226 static inline dw_die_ref
AT_ref (dw_attr_ref
);
3227 static inline int AT_ref_external (dw_attr_ref
);
3228 static inline void set_AT_ref_external (dw_attr_ref
, int);
3229 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3230 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3231 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
3232 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3234 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
3235 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
);
3236 static inline rtx
AT_addr (dw_attr_ref
);
3237 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3238 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3239 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3240 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3241 unsigned HOST_WIDE_INT
);
3242 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3244 static inline const char *AT_lbl (dw_attr_ref
);
3245 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
3246 static const char *get_AT_low_pc (dw_die_ref
);
3247 static const char *get_AT_hi_pc (dw_die_ref
);
3248 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3249 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3250 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3251 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3252 static bool is_cxx (void);
3253 static bool is_fortran (void);
3254 static bool is_ada (void);
3255 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
3256 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3257 static void add_child_die (dw_die_ref
, dw_die_ref
);
3258 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3259 static dw_die_ref
lookup_type_die (tree
);
3260 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3261 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3262 static void equate_type_number_to_die (tree
, dw_die_ref
);
3263 static hashval_t
decl_die_table_hash (const void *);
3264 static int decl_die_table_eq (const void *, const void *);
3265 static dw_die_ref
lookup_decl_die (tree
);
3266 static hashval_t
common_block_die_table_hash (const void *);
3267 static int common_block_die_table_eq (const void *, const void *);
3268 static hashval_t
decl_loc_table_hash (const void *);
3269 static int decl_loc_table_eq (const void *, const void *);
3270 static var_loc_list
*lookup_decl_loc (const_tree
);
3271 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3272 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *);
3273 static void print_spaces (FILE *);
3274 static void print_die (dw_die_ref
, FILE *);
3275 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
3276 static dw_die_ref
pop_compile_unit (dw_die_ref
);
3277 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3278 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
3279 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3280 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3281 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3282 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3283 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_ref
,
3284 struct md5_ctx
*, int *);
3285 struct checksum_attributes
;
3286 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3287 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3288 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3289 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3290 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3291 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3292 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
3293 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3294 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
3295 static void compute_section_prefix (dw_die_ref
);
3296 static int is_type_die (dw_die_ref
);
3297 static int is_comdat_die (dw_die_ref
);
3298 static int is_symbol_die (dw_die_ref
);
3299 static void assign_symbol_names (dw_die_ref
);
3300 static void break_out_includes (dw_die_ref
);
3301 static int is_declaration_die (dw_die_ref
);
3302 static int should_move_die_to_comdat (dw_die_ref
);
3303 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3304 static dw_die_ref
clone_die (dw_die_ref
);
3305 static dw_die_ref
clone_tree (dw_die_ref
);
3306 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3307 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3308 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3309 static dw_die_ref
generate_skeleton (dw_die_ref
);
3310 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3313 static void break_out_comdat_types (dw_die_ref
);
3314 static dw_die_ref
copy_ancestor_tree (dw_die_ref
, dw_die_ref
, htab_t
);
3315 static void copy_decls_walk (dw_die_ref
, dw_die_ref
, htab_t
);
3316 static void copy_decls_for_unworthy_types (dw_die_ref
);
3318 static hashval_t
htab_cu_hash (const void *);
3319 static int htab_cu_eq (const void *, const void *);
3320 static void htab_cu_del (void *);
3321 static int check_duplicate_cu (dw_die_ref
, htab_t
, unsigned *);
3322 static void record_comdat_symbol_number (dw_die_ref
, htab_t
, unsigned);
3323 static void add_sibling_attributes (dw_die_ref
);
3324 static void build_abbrev_table (dw_die_ref
);
3325 static void output_location_lists (dw_die_ref
);
3326 static int constant_size (unsigned HOST_WIDE_INT
);
3327 static unsigned long size_of_die (dw_die_ref
);
3328 static void calc_die_sizes (dw_die_ref
);
3329 static void calc_base_type_die_sizes (void);
3330 static void mark_dies (dw_die_ref
);
3331 static void unmark_dies (dw_die_ref
);
3332 static void unmark_all_dies (dw_die_ref
);
3333 static unsigned long size_of_pubnames (VEC (pubname_entry
,gc
) *);
3334 static unsigned long size_of_aranges (void);
3335 static enum dwarf_form
value_format (dw_attr_ref
);
3336 static void output_value_format (dw_attr_ref
);
3337 static void output_abbrev_section (void);
3338 static void output_die_symbol (dw_die_ref
);
3339 static void output_die (dw_die_ref
);
3340 static void output_compilation_unit_header (void);
3341 static void output_comp_unit (dw_die_ref
, int);
3342 static void output_comdat_type_unit (comdat_type_node
*);
3343 static const char *dwarf2_name (tree
, int);
3344 static void add_pubname (tree
, dw_die_ref
);
3345 static void add_pubname_string (const char *, dw_die_ref
);
3346 static void add_pubtype (tree
, dw_die_ref
);
3347 static void output_pubnames (VEC (pubname_entry
,gc
) *);
3348 static void output_aranges (unsigned long);
3349 static unsigned int add_ranges_num (int);
3350 static unsigned int add_ranges (const_tree
);
3351 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3353 static void output_ranges (void);
3354 static dw_line_info_table
*new_line_info_table (void);
3355 static void output_line_info (void);
3356 static void output_file_names (void);
3357 static dw_die_ref
base_type_die (tree
);
3358 static int is_base_type (tree
);
3359 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, dw_die_ref
);
3360 static dw_die_ref
modified_type_die (tree
, int, int, dw_die_ref
);
3361 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3362 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3363 static int type_is_enum (const_tree
);
3364 static unsigned int dbx_reg_number (const_rtx
);
3365 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3366 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3367 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3368 enum var_init_status
);
3369 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3370 enum var_init_status
);
3371 static dw_loc_descr_ref
based_loc_descr (rtx
, HOST_WIDE_INT
,
3372 enum var_init_status
);
3373 static int is_based_loc (const_rtx
);
3374 static int resolve_one_addr (rtx
*, void *);
3375 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3376 enum var_init_status
);
3377 static dw_loc_descr_ref
loc_descriptor (rtx
, enum machine_mode mode
,
3378 enum var_init_status
);
3379 static dw_loc_list_ref
loc_list_from_tree (tree
, int);
3380 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int);
3381 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3382 static tree
field_type (const_tree
);
3383 static unsigned int simple_type_align_in_bits (const_tree
);
3384 static unsigned int simple_decl_align_in_bits (const_tree
);
3385 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3386 static HOST_WIDE_INT
field_byte_offset (const_tree
);
3387 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3389 static void add_data_member_location_attribute (dw_die_ref
, tree
);
3390 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3391 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3392 static void insert_double (double_int
, unsigned char *);
3393 static void insert_float (const_rtx
, unsigned char *);
3394 static rtx
rtl_for_decl_location (tree
);
3395 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool,
3396 enum dwarf_attribute
);
3397 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3398 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3399 static void add_name_attribute (dw_die_ref
, const char *);
3400 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3401 static void add_comp_dir_attribute (dw_die_ref
);
3402 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
3403 static void add_subscript_info (dw_die_ref
, tree
, bool);
3404 static void add_byte_size_attribute (dw_die_ref
, tree
);
3405 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3406 static void add_bit_size_attribute (dw_die_ref
, tree
);
3407 static void add_prototyped_attribute (dw_die_ref
, tree
);
3408 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3409 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3410 static void add_src_coords_attributes (dw_die_ref
, tree
);
3411 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
3412 static void push_decl_scope (tree
);
3413 static void pop_decl_scope (void);
3414 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3415 static inline int local_scope_p (dw_die_ref
);
3416 static inline int class_scope_p (dw_die_ref
);
3417 static inline int class_or_namespace_scope_p (dw_die_ref
);
3418 static void add_type_attribute (dw_die_ref
, tree
, int, int, dw_die_ref
);
3419 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3420 static const char *type_tag (const_tree
);
3421 static tree
member_declared_type (const_tree
);
3423 static const char *decl_start_label (tree
);
3425 static void gen_array_type_die (tree
, dw_die_ref
);
3426 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3428 static void gen_entry_point_die (tree
, dw_die_ref
);
3430 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3431 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3432 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3433 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3434 static void gen_formal_types_die (tree
, dw_die_ref
);
3435 static void gen_subprogram_die (tree
, dw_die_ref
);
3436 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3437 static void gen_const_die (tree
, dw_die_ref
);
3438 static void gen_label_die (tree
, dw_die_ref
);
3439 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
3440 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
3441 static void gen_field_die (tree
, dw_die_ref
);
3442 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3443 static dw_die_ref
gen_compile_unit_die (const char *);
3444 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
3445 static void gen_member_die (tree
, dw_die_ref
);
3446 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3447 enum debug_info_usage
);
3448 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3449 static void gen_typedef_die (tree
, dw_die_ref
);
3450 static void gen_type_die (tree
, dw_die_ref
);
3451 static void gen_block_die (tree
, dw_die_ref
, int);
3452 static void decls_for_scope (tree
, dw_die_ref
, int);
3453 static inline int is_redundant_typedef (const_tree
);
3454 static bool is_naming_typedef_decl (const_tree
);
3455 static inline dw_die_ref
get_context_die (tree
);
3456 static void gen_namespace_die (tree
, dw_die_ref
);
3457 static dw_die_ref
gen_decl_die (tree
, tree
, dw_die_ref
);
3458 static dw_die_ref
force_decl_die (tree
);
3459 static dw_die_ref
force_type_die (tree
);
3460 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3461 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3462 static struct dwarf_file_data
* lookup_filename (const char *);
3463 static void retry_incomplete_types (void);
3464 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3465 static void gen_generic_params_dies (tree
);
3466 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3467 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3468 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3469 static int file_info_cmp (const void *, const void *);
3470 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3471 const char *, const char *);
3472 static void output_loc_list (dw_loc_list_ref
);
3473 static char *gen_internal_sym (const char *);
3475 static void prune_unmark_dies (dw_die_ref
);
3476 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3477 static void prune_unused_types_mark (dw_die_ref
, int);
3478 static void prune_unused_types_walk (dw_die_ref
);
3479 static void prune_unused_types_walk_attribs (dw_die_ref
);
3480 static void prune_unused_types_prune (dw_die_ref
);
3481 static void prune_unused_types (void);
3482 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3483 static inline const char *AT_vms_delta1 (dw_attr_ref
);
3484 static inline const char *AT_vms_delta2 (dw_attr_ref
);
3485 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3486 const char *, const char *);
3487 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3488 static void gen_remaining_tmpl_value_param_die_attribute (void);
3489 static bool generic_type_p (tree
);
3490 static void schedule_generic_params_dies_gen (tree t
);
3491 static void gen_scheduled_generic_parms_dies (void);
3493 /* Section names used to hold DWARF debugging information. */
3494 #ifndef DEBUG_INFO_SECTION
3495 #define DEBUG_INFO_SECTION ".debug_info"
3497 #ifndef DEBUG_ABBREV_SECTION
3498 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3500 #ifndef DEBUG_ARANGES_SECTION
3501 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3503 #ifndef DEBUG_MACINFO_SECTION
3504 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
3506 #ifndef DEBUG_MACRO_SECTION
3507 #define DEBUG_MACRO_SECTION ".debug_macro"
3509 #ifndef DEBUG_LINE_SECTION
3510 #define DEBUG_LINE_SECTION ".debug_line"
3512 #ifndef DEBUG_LOC_SECTION
3513 #define DEBUG_LOC_SECTION ".debug_loc"
3515 #ifndef DEBUG_PUBNAMES_SECTION
3516 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
3518 #ifndef DEBUG_PUBTYPES_SECTION
3519 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
3521 #ifndef DEBUG_STR_SECTION
3522 #define DEBUG_STR_SECTION ".debug_str"
3524 #ifndef DEBUG_RANGES_SECTION
3525 #define DEBUG_RANGES_SECTION ".debug_ranges"
3528 /* Standard ELF section names for compiled code and data. */
3529 #ifndef TEXT_SECTION_NAME
3530 #define TEXT_SECTION_NAME ".text"
3533 /* Section flags for .debug_str section. */
3534 #define DEBUG_STR_SECTION_FLAGS \
3535 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3536 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3539 /* Labels we insert at beginning sections we can reference instead of
3540 the section names themselves. */
3542 #ifndef TEXT_SECTION_LABEL
3543 #define TEXT_SECTION_LABEL "Ltext"
3545 #ifndef COLD_TEXT_SECTION_LABEL
3546 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3548 #ifndef DEBUG_LINE_SECTION_LABEL
3549 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3551 #ifndef DEBUG_INFO_SECTION_LABEL
3552 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3554 #ifndef DEBUG_ABBREV_SECTION_LABEL
3555 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3557 #ifndef DEBUG_LOC_SECTION_LABEL
3558 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3560 #ifndef DEBUG_RANGES_SECTION_LABEL
3561 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3563 #ifndef DEBUG_MACINFO_SECTION_LABEL
3564 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3566 #ifndef DEBUG_MACRO_SECTION_LABEL
3567 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3571 /* Definitions of defaults for formats and names of various special
3572 (artificial) labels which may be generated within this file (when the -g
3573 options is used and DWARF2_DEBUGGING_INFO is in effect.
3574 If necessary, these may be overridden from within the tm.h file, but
3575 typically, overriding these defaults is unnecessary. */
3577 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3578 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3579 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3580 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3581 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3582 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3583 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3584 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3585 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3586 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3588 #ifndef TEXT_END_LABEL
3589 #define TEXT_END_LABEL "Letext"
3591 #ifndef COLD_END_LABEL
3592 #define COLD_END_LABEL "Letext_cold"
3594 #ifndef BLOCK_BEGIN_LABEL
3595 #define BLOCK_BEGIN_LABEL "LBB"
3597 #ifndef BLOCK_END_LABEL
3598 #define BLOCK_END_LABEL "LBE"
3600 #ifndef LINE_CODE_LABEL
3601 #define LINE_CODE_LABEL "LM"
3605 /* Return the root of the DIE's built for the current compilation unit. */
3607 comp_unit_die (void)
3609 if (!single_comp_unit_die
)
3610 single_comp_unit_die
= gen_compile_unit_die (NULL
);
3611 return single_comp_unit_die
;
3614 /* We allow a language front-end to designate a function that is to be
3615 called to "demangle" any name before it is put into a DIE. */
3617 static const char *(*demangle_name_func
) (const char *);
3620 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3622 demangle_name_func
= func
;
3625 /* Test if rtl node points to a pseudo register. */
3628 is_pseudo_reg (const_rtx rtl
)
3630 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3631 || (GET_CODE (rtl
) == SUBREG
3632 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3635 /* Return a reference to a type, with its const and volatile qualifiers
3639 type_main_variant (tree type
)
3641 type
= TYPE_MAIN_VARIANT (type
);
3643 /* ??? There really should be only one main variant among any group of
3644 variants of a given type (and all of the MAIN_VARIANT values for all
3645 members of the group should point to that one type) but sometimes the C
3646 front-end messes this up for array types, so we work around that bug
3648 if (TREE_CODE (type
) == ARRAY_TYPE
)
3649 while (type
!= TYPE_MAIN_VARIANT (type
))
3650 type
= TYPE_MAIN_VARIANT (type
);
3655 /* Return nonzero if the given type node represents a tagged type. */
3658 is_tagged_type (const_tree type
)
3660 enum tree_code code
= TREE_CODE (type
);
3662 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
3663 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
3666 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3669 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
3671 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
3674 /* Return die_offset of a DIE reference to a base type. */
3676 static unsigned long int
3677 get_base_type_offset (dw_die_ref ref
)
3679 if (ref
->die_offset
)
3680 return ref
->die_offset
;
3681 if (comp_unit_die ()->die_abbrev
)
3683 calc_base_type_die_sizes ();
3684 gcc_assert (ref
->die_offset
);
3686 return ref
->die_offset
;
3689 /* Return die_offset of a DIE reference other than base type. */
3691 static unsigned long int
3692 get_ref_die_offset (dw_die_ref ref
)
3694 gcc_assert (ref
->die_offset
);
3695 return ref
->die_offset
;
3698 /* Convert a DIE tag into its string name. */
3701 dwarf_tag_name (unsigned int tag
)
3705 case DW_TAG_padding
:
3706 return "DW_TAG_padding";
3707 case DW_TAG_array_type
:
3708 return "DW_TAG_array_type";
3709 case DW_TAG_class_type
:
3710 return "DW_TAG_class_type";
3711 case DW_TAG_entry_point
:
3712 return "DW_TAG_entry_point";
3713 case DW_TAG_enumeration_type
:
3714 return "DW_TAG_enumeration_type";
3715 case DW_TAG_formal_parameter
:
3716 return "DW_TAG_formal_parameter";
3717 case DW_TAG_imported_declaration
:
3718 return "DW_TAG_imported_declaration";
3720 return "DW_TAG_label";
3721 case DW_TAG_lexical_block
:
3722 return "DW_TAG_lexical_block";
3724 return "DW_TAG_member";
3725 case DW_TAG_pointer_type
:
3726 return "DW_TAG_pointer_type";
3727 case DW_TAG_reference_type
:
3728 return "DW_TAG_reference_type";
3729 case DW_TAG_compile_unit
:
3730 return "DW_TAG_compile_unit";
3731 case DW_TAG_string_type
:
3732 return "DW_TAG_string_type";
3733 case DW_TAG_structure_type
:
3734 return "DW_TAG_structure_type";
3735 case DW_TAG_subroutine_type
:
3736 return "DW_TAG_subroutine_type";
3737 case DW_TAG_typedef
:
3738 return "DW_TAG_typedef";
3739 case DW_TAG_union_type
:
3740 return "DW_TAG_union_type";
3741 case DW_TAG_unspecified_parameters
:
3742 return "DW_TAG_unspecified_parameters";
3743 case DW_TAG_variant
:
3744 return "DW_TAG_variant";
3745 case DW_TAG_common_block
:
3746 return "DW_TAG_common_block";
3747 case DW_TAG_common_inclusion
:
3748 return "DW_TAG_common_inclusion";
3749 case DW_TAG_inheritance
:
3750 return "DW_TAG_inheritance";
3751 case DW_TAG_inlined_subroutine
:
3752 return "DW_TAG_inlined_subroutine";
3754 return "DW_TAG_module";
3755 case DW_TAG_ptr_to_member_type
:
3756 return "DW_TAG_ptr_to_member_type";
3757 case DW_TAG_set_type
:
3758 return "DW_TAG_set_type";
3759 case DW_TAG_subrange_type
:
3760 return "DW_TAG_subrange_type";
3761 case DW_TAG_with_stmt
:
3762 return "DW_TAG_with_stmt";
3763 case DW_TAG_access_declaration
:
3764 return "DW_TAG_access_declaration";
3765 case DW_TAG_base_type
:
3766 return "DW_TAG_base_type";
3767 case DW_TAG_catch_block
:
3768 return "DW_TAG_catch_block";
3769 case DW_TAG_const_type
:
3770 return "DW_TAG_const_type";
3771 case DW_TAG_constant
:
3772 return "DW_TAG_constant";
3773 case DW_TAG_enumerator
:
3774 return "DW_TAG_enumerator";
3775 case DW_TAG_file_type
:
3776 return "DW_TAG_file_type";
3778 return "DW_TAG_friend";
3779 case DW_TAG_namelist
:
3780 return "DW_TAG_namelist";
3781 case DW_TAG_namelist_item
:
3782 return "DW_TAG_namelist_item";
3783 case DW_TAG_packed_type
:
3784 return "DW_TAG_packed_type";
3785 case DW_TAG_subprogram
:
3786 return "DW_TAG_subprogram";
3787 case DW_TAG_template_type_param
:
3788 return "DW_TAG_template_type_param";
3789 case DW_TAG_template_value_param
:
3790 return "DW_TAG_template_value_param";
3791 case DW_TAG_thrown_type
:
3792 return "DW_TAG_thrown_type";
3793 case DW_TAG_try_block
:
3794 return "DW_TAG_try_block";
3795 case DW_TAG_variant_part
:
3796 return "DW_TAG_variant_part";
3797 case DW_TAG_variable
:
3798 return "DW_TAG_variable";
3799 case DW_TAG_volatile_type
:
3800 return "DW_TAG_volatile_type";
3801 case DW_TAG_dwarf_procedure
:
3802 return "DW_TAG_dwarf_procedure";
3803 case DW_TAG_restrict_type
:
3804 return "DW_TAG_restrict_type";
3805 case DW_TAG_interface_type
:
3806 return "DW_TAG_interface_type";
3807 case DW_TAG_namespace
:
3808 return "DW_TAG_namespace";
3809 case DW_TAG_imported_module
:
3810 return "DW_TAG_imported_module";
3811 case DW_TAG_unspecified_type
:
3812 return "DW_TAG_unspecified_type";
3813 case DW_TAG_partial_unit
:
3814 return "DW_TAG_partial_unit";
3815 case DW_TAG_imported_unit
:
3816 return "DW_TAG_imported_unit";
3817 case DW_TAG_condition
:
3818 return "DW_TAG_condition";
3819 case DW_TAG_shared_type
:
3820 return "DW_TAG_shared_type";
3821 case DW_TAG_type_unit
:
3822 return "DW_TAG_type_unit";
3823 case DW_TAG_rvalue_reference_type
:
3824 return "DW_TAG_rvalue_reference_type";
3825 case DW_TAG_template_alias
:
3826 return "DW_TAG_template_alias";
3827 case DW_TAG_GNU_template_parameter_pack
:
3828 return "DW_TAG_GNU_template_parameter_pack";
3829 case DW_TAG_GNU_formal_parameter_pack
:
3830 return "DW_TAG_GNU_formal_parameter_pack";
3831 case DW_TAG_MIPS_loop
:
3832 return "DW_TAG_MIPS_loop";
3833 case DW_TAG_format_label
:
3834 return "DW_TAG_format_label";
3835 case DW_TAG_function_template
:
3836 return "DW_TAG_function_template";
3837 case DW_TAG_class_template
:
3838 return "DW_TAG_class_template";
3839 case DW_TAG_GNU_BINCL
:
3840 return "DW_TAG_GNU_BINCL";
3841 case DW_TAG_GNU_EINCL
:
3842 return "DW_TAG_GNU_EINCL";
3843 case DW_TAG_GNU_template_template_param
:
3844 return "DW_TAG_GNU_template_template_param";
3845 case DW_TAG_GNU_call_site
:
3846 return "DW_TAG_GNU_call_site";
3847 case DW_TAG_GNU_call_site_parameter
:
3848 return "DW_TAG_GNU_call_site_parameter";
3850 return "DW_TAG_<unknown>";
3854 /* Convert a DWARF attribute code into its string name. */
3857 dwarf_attr_name (unsigned int attr
)
3862 return "DW_AT_sibling";
3863 case DW_AT_location
:
3864 return "DW_AT_location";
3866 return "DW_AT_name";
3867 case DW_AT_ordering
:
3868 return "DW_AT_ordering";
3869 case DW_AT_subscr_data
:
3870 return "DW_AT_subscr_data";
3871 case DW_AT_byte_size
:
3872 return "DW_AT_byte_size";
3873 case DW_AT_bit_offset
:
3874 return "DW_AT_bit_offset";
3875 case DW_AT_bit_size
:
3876 return "DW_AT_bit_size";
3877 case DW_AT_element_list
:
3878 return "DW_AT_element_list";
3879 case DW_AT_stmt_list
:
3880 return "DW_AT_stmt_list";
3882 return "DW_AT_low_pc";
3884 return "DW_AT_high_pc";
3885 case DW_AT_language
:
3886 return "DW_AT_language";
3888 return "DW_AT_member";
3890 return "DW_AT_discr";
3891 case DW_AT_discr_value
:
3892 return "DW_AT_discr_value";
3893 case DW_AT_visibility
:
3894 return "DW_AT_visibility";
3896 return "DW_AT_import";
3897 case DW_AT_string_length
:
3898 return "DW_AT_string_length";
3899 case DW_AT_common_reference
:
3900 return "DW_AT_common_reference";
3901 case DW_AT_comp_dir
:
3902 return "DW_AT_comp_dir";
3903 case DW_AT_const_value
:
3904 return "DW_AT_const_value";
3905 case DW_AT_containing_type
:
3906 return "DW_AT_containing_type";
3907 case DW_AT_default_value
:
3908 return "DW_AT_default_value";
3910 return "DW_AT_inline";
3911 case DW_AT_is_optional
:
3912 return "DW_AT_is_optional";
3913 case DW_AT_lower_bound
:
3914 return "DW_AT_lower_bound";
3915 case DW_AT_producer
:
3916 return "DW_AT_producer";
3917 case DW_AT_prototyped
:
3918 return "DW_AT_prototyped";
3919 case DW_AT_return_addr
:
3920 return "DW_AT_return_addr";
3921 case DW_AT_start_scope
:
3922 return "DW_AT_start_scope";
3923 case DW_AT_bit_stride
:
3924 return "DW_AT_bit_stride";
3925 case DW_AT_upper_bound
:
3926 return "DW_AT_upper_bound";
3927 case DW_AT_abstract_origin
:
3928 return "DW_AT_abstract_origin";
3929 case DW_AT_accessibility
:
3930 return "DW_AT_accessibility";
3931 case DW_AT_address_class
:
3932 return "DW_AT_address_class";
3933 case DW_AT_artificial
:
3934 return "DW_AT_artificial";
3935 case DW_AT_base_types
:
3936 return "DW_AT_base_types";
3937 case DW_AT_calling_convention
:
3938 return "DW_AT_calling_convention";
3940 return "DW_AT_count";
3941 case DW_AT_data_member_location
:
3942 return "DW_AT_data_member_location";
3943 case DW_AT_decl_column
:
3944 return "DW_AT_decl_column";
3945 case DW_AT_decl_file
:
3946 return "DW_AT_decl_file";
3947 case DW_AT_decl_line
:
3948 return "DW_AT_decl_line";
3949 case DW_AT_declaration
:
3950 return "DW_AT_declaration";
3951 case DW_AT_discr_list
:
3952 return "DW_AT_discr_list";
3953 case DW_AT_encoding
:
3954 return "DW_AT_encoding";
3955 case DW_AT_external
:
3956 return "DW_AT_external";
3957 case DW_AT_explicit
:
3958 return "DW_AT_explicit";
3959 case DW_AT_frame_base
:
3960 return "DW_AT_frame_base";
3962 return "DW_AT_friend";
3963 case DW_AT_identifier_case
:
3964 return "DW_AT_identifier_case";
3965 case DW_AT_macro_info
:
3966 return "DW_AT_macro_info";
3967 case DW_AT_namelist_items
:
3968 return "DW_AT_namelist_items";
3969 case DW_AT_priority
:
3970 return "DW_AT_priority";
3972 return "DW_AT_segment";
3973 case DW_AT_specification
:
3974 return "DW_AT_specification";
3975 case DW_AT_static_link
:
3976 return "DW_AT_static_link";
3978 return "DW_AT_type";
3979 case DW_AT_use_location
:
3980 return "DW_AT_use_location";
3981 case DW_AT_variable_parameter
:
3982 return "DW_AT_variable_parameter";
3983 case DW_AT_virtuality
:
3984 return "DW_AT_virtuality";
3985 case DW_AT_vtable_elem_location
:
3986 return "DW_AT_vtable_elem_location";
3988 case DW_AT_allocated
:
3989 return "DW_AT_allocated";
3990 case DW_AT_associated
:
3991 return "DW_AT_associated";
3992 case DW_AT_data_location
:
3993 return "DW_AT_data_location";
3994 case DW_AT_byte_stride
:
3995 return "DW_AT_byte_stride";
3996 case DW_AT_entry_pc
:
3997 return "DW_AT_entry_pc";
3998 case DW_AT_use_UTF8
:
3999 return "DW_AT_use_UTF8";
4000 case DW_AT_extension
:
4001 return "DW_AT_extension";
4003 return "DW_AT_ranges";
4004 case DW_AT_trampoline
:
4005 return "DW_AT_trampoline";
4006 case DW_AT_call_column
:
4007 return "DW_AT_call_column";
4008 case DW_AT_call_file
:
4009 return "DW_AT_call_file";
4010 case DW_AT_call_line
:
4011 return "DW_AT_call_line";
4012 case DW_AT_object_pointer
:
4013 return "DW_AT_object_pointer";
4015 case DW_AT_signature
:
4016 return "DW_AT_signature";
4017 case DW_AT_main_subprogram
:
4018 return "DW_AT_main_subprogram";
4019 case DW_AT_data_bit_offset
:
4020 return "DW_AT_data_bit_offset";
4021 case DW_AT_const_expr
:
4022 return "DW_AT_const_expr";
4023 case DW_AT_enum_class
:
4024 return "DW_AT_enum_class";
4025 case DW_AT_linkage_name
:
4026 return "DW_AT_linkage_name";
4028 case DW_AT_MIPS_fde
:
4029 return "DW_AT_MIPS_fde";
4030 case DW_AT_MIPS_loop_begin
:
4031 return "DW_AT_MIPS_loop_begin";
4032 case DW_AT_MIPS_tail_loop_begin
:
4033 return "DW_AT_MIPS_tail_loop_begin";
4034 case DW_AT_MIPS_epilog_begin
:
4035 return "DW_AT_MIPS_epilog_begin";
4036 #if VMS_DEBUGGING_INFO
4037 case DW_AT_HP_prologue
:
4038 return "DW_AT_HP_prologue";
4040 case DW_AT_MIPS_loop_unroll_factor
:
4041 return "DW_AT_MIPS_loop_unroll_factor";
4043 case DW_AT_MIPS_software_pipeline_depth
:
4044 return "DW_AT_MIPS_software_pipeline_depth";
4045 case DW_AT_MIPS_linkage_name
:
4046 return "DW_AT_MIPS_linkage_name";
4047 #if VMS_DEBUGGING_INFO
4048 case DW_AT_HP_epilogue
:
4049 return "DW_AT_HP_epilogue";
4051 case DW_AT_MIPS_stride
:
4052 return "DW_AT_MIPS_stride";
4054 case DW_AT_MIPS_abstract_name
:
4055 return "DW_AT_MIPS_abstract_name";
4056 case DW_AT_MIPS_clone_origin
:
4057 return "DW_AT_MIPS_clone_origin";
4058 case DW_AT_MIPS_has_inlines
:
4059 return "DW_AT_MIPS_has_inlines";
4061 case DW_AT_sf_names
:
4062 return "DW_AT_sf_names";
4063 case DW_AT_src_info
:
4064 return "DW_AT_src_info";
4065 case DW_AT_mac_info
:
4066 return "DW_AT_mac_info";
4067 case DW_AT_src_coords
:
4068 return "DW_AT_src_coords";
4069 case DW_AT_body_begin
:
4070 return "DW_AT_body_begin";
4071 case DW_AT_body_end
:
4072 return "DW_AT_body_end";
4074 case DW_AT_GNU_vector
:
4075 return "DW_AT_GNU_vector";
4076 case DW_AT_GNU_guarded_by
:
4077 return "DW_AT_GNU_guarded_by";
4078 case DW_AT_GNU_pt_guarded_by
:
4079 return "DW_AT_GNU_pt_guarded_by";
4080 case DW_AT_GNU_guarded
:
4081 return "DW_AT_GNU_guarded";
4082 case DW_AT_GNU_pt_guarded
:
4083 return "DW_AT_GNU_pt_guarded";
4084 case DW_AT_GNU_locks_excluded
:
4085 return "DW_AT_GNU_locks_excluded";
4086 case DW_AT_GNU_exclusive_locks_required
:
4087 return "DW_AT_GNU_exclusive_locks_required";
4088 case DW_AT_GNU_shared_locks_required
:
4089 return "DW_AT_GNU_shared_locks_required";
4090 case DW_AT_GNU_odr_signature
:
4091 return "DW_AT_GNU_odr_signature";
4092 case DW_AT_GNU_template_name
:
4093 return "DW_AT_GNU_template_name";
4094 case DW_AT_GNU_call_site_value
:
4095 return "DW_AT_GNU_call_site_value";
4096 case DW_AT_GNU_call_site_data_value
:
4097 return "DW_AT_GNU_call_site_data_value";
4098 case DW_AT_GNU_call_site_target
:
4099 return "DW_AT_GNU_call_site_target";
4100 case DW_AT_GNU_call_site_target_clobbered
:
4101 return "DW_AT_GNU_call_site_target_clobbered";
4102 case DW_AT_GNU_tail_call
:
4103 return "DW_AT_GNU_tail_call";
4104 case DW_AT_GNU_all_tail_call_sites
:
4105 return "DW_AT_GNU_all_tail_call_sites";
4106 case DW_AT_GNU_all_call_sites
:
4107 return "DW_AT_GNU_all_call_sites";
4108 case DW_AT_GNU_all_source_call_sites
:
4109 return "DW_AT_GNU_all_source_call_sites";
4110 case DW_AT_GNU_macros
:
4111 return "DW_AT_GNU_macros";
4113 case DW_AT_GNAT_descriptive_type
:
4114 return "DW_AT_GNAT_descriptive_type";
4116 case DW_AT_VMS_rtnbeg_pd_address
:
4117 return "DW_AT_VMS_rtnbeg_pd_address";
4120 return "DW_AT_<unknown>";
4124 /* Convert a DWARF value form code into its string name. */
4127 dwarf_form_name (unsigned int form
)
4132 return "DW_FORM_addr";
4133 case DW_FORM_block2
:
4134 return "DW_FORM_block2";
4135 case DW_FORM_block4
:
4136 return "DW_FORM_block4";
4138 return "DW_FORM_data2";
4140 return "DW_FORM_data4";
4142 return "DW_FORM_data8";
4143 case DW_FORM_string
:
4144 return "DW_FORM_string";
4146 return "DW_FORM_block";
4147 case DW_FORM_block1
:
4148 return "DW_FORM_block1";
4150 return "DW_FORM_data1";
4152 return "DW_FORM_flag";
4154 return "DW_FORM_sdata";
4156 return "DW_FORM_strp";
4158 return "DW_FORM_udata";
4159 case DW_FORM_ref_addr
:
4160 return "DW_FORM_ref_addr";
4162 return "DW_FORM_ref1";
4164 return "DW_FORM_ref2";
4166 return "DW_FORM_ref4";
4168 return "DW_FORM_ref8";
4169 case DW_FORM_ref_udata
:
4170 return "DW_FORM_ref_udata";
4171 case DW_FORM_indirect
:
4172 return "DW_FORM_indirect";
4173 case DW_FORM_sec_offset
:
4174 return "DW_FORM_sec_offset";
4175 case DW_FORM_exprloc
:
4176 return "DW_FORM_exprloc";
4177 case DW_FORM_flag_present
:
4178 return "DW_FORM_flag_present";
4179 case DW_FORM_ref_sig8
:
4180 return "DW_FORM_ref_sig8";
4182 return "DW_FORM_<unknown>";
4186 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4187 instance of an inlined instance of a decl which is local to an inline
4188 function, so we have to trace all of the way back through the origin chain
4189 to find out what sort of node actually served as the original seed for the
4193 decl_ultimate_origin (const_tree decl
)
4195 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4198 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4199 nodes in the function to point to themselves; ignore that if
4200 we're trying to output the abstract instance of this function. */
4201 if (DECL_ABSTRACT (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4204 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4205 most distant ancestor, this should never happen. */
4206 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4208 return DECL_ABSTRACT_ORIGIN (decl
);
4211 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4212 of a virtual function may refer to a base class, so we check the 'this'
4216 decl_class_context (tree decl
)
4218 tree context
= NULL_TREE
;
4220 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4221 context
= DECL_CONTEXT (decl
);
4223 context
= TYPE_MAIN_VARIANT
4224 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4226 if (context
&& !TYPE_P (context
))
4227 context
= NULL_TREE
;
4232 /* Add an attribute/value pair to a DIE. */
4235 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
4237 /* Maybe this should be an assert? */
4241 if (die
->die_attr
== NULL
)
4242 die
->die_attr
= VEC_alloc (dw_attr_node
, gc
, 1);
4243 VEC_safe_push (dw_attr_node
, gc
, die
->die_attr
, attr
);
4246 static inline enum dw_val_class
4247 AT_class (dw_attr_ref a
)
4249 return a
->dw_attr_val
.val_class
;
4252 /* Add a flag value attribute to a DIE. */
4255 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4259 attr
.dw_attr
= attr_kind
;
4260 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4261 attr
.dw_attr_val
.v
.val_flag
= flag
;
4262 add_dwarf_attr (die
, &attr
);
4265 static inline unsigned
4266 AT_flag (dw_attr_ref a
)
4268 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4269 return a
->dw_attr_val
.v
.val_flag
;
4272 /* Add a signed integer attribute value to a DIE. */
4275 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4279 attr
.dw_attr
= attr_kind
;
4280 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4281 attr
.dw_attr_val
.v
.val_int
= int_val
;
4282 add_dwarf_attr (die
, &attr
);
4285 static inline HOST_WIDE_INT
4286 AT_int (dw_attr_ref a
)
4288 gcc_assert (a
&& AT_class (a
) == dw_val_class_const
);
4289 return a
->dw_attr_val
.v
.val_int
;
4292 /* Add an unsigned integer attribute value to a DIE. */
4295 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4296 unsigned HOST_WIDE_INT unsigned_val
)
4300 attr
.dw_attr
= attr_kind
;
4301 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4302 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4303 add_dwarf_attr (die
, &attr
);
4306 static inline unsigned HOST_WIDE_INT
4307 AT_unsigned (dw_attr_ref a
)
4309 gcc_assert (a
&& AT_class (a
) == dw_val_class_unsigned_const
);
4310 return a
->dw_attr_val
.v
.val_unsigned
;
4313 /* Add an unsigned double integer attribute value to a DIE. */
4316 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4317 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4321 attr
.dw_attr
= attr_kind
;
4322 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4323 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4324 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4325 add_dwarf_attr (die
, &attr
);
4328 /* Add a floating point attribute value to a DIE and return it. */
4331 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4332 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4336 attr
.dw_attr
= attr_kind
;
4337 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4338 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4339 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4340 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4341 add_dwarf_attr (die
, &attr
);
4344 /* Add an 8-byte data attribute value to a DIE. */
4347 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4348 unsigned char data8
[8])
4352 attr
.dw_attr
= attr_kind
;
4353 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4354 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4355 add_dwarf_attr (die
, &attr
);
4358 /* Hash and equality functions for debug_str_hash. */
4361 debug_str_do_hash (const void *x
)
4363 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
4367 debug_str_eq (const void *x1
, const void *x2
)
4369 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
4370 (const char *)x2
) == 0;
4373 /* Add STR to the indirect string hash table. */
4375 static struct indirect_string_node
*
4376 find_AT_string (const char *str
)
4378 struct indirect_string_node
*node
;
4381 if (! debug_str_hash
)
4382 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
4383 debug_str_eq
, NULL
);
4385 slot
= htab_find_slot_with_hash (debug_str_hash
, str
,
4386 htab_hash_string (str
), INSERT
);
4389 node
= ggc_alloc_cleared_indirect_string_node ();
4390 node
->str
= ggc_strdup (str
);
4394 node
= (struct indirect_string_node
*) *slot
;
4400 /* Add a string attribute value to a DIE. */
4403 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4406 struct indirect_string_node
*node
;
4408 node
= find_AT_string (str
);
4410 attr
.dw_attr
= attr_kind
;
4411 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4412 attr
.dw_attr_val
.v
.val_str
= node
;
4413 add_dwarf_attr (die
, &attr
);
4416 static inline const char *
4417 AT_string (dw_attr_ref a
)
4419 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4420 return a
->dw_attr_val
.v
.val_str
->str
;
4423 /* Find out whether a string should be output inline in DIE
4424 or out-of-line in .debug_str section. */
4426 static enum dwarf_form
4427 AT_string_form (dw_attr_ref a
)
4429 struct indirect_string_node
*node
;
4433 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4435 node
= a
->dw_attr_val
.v
.val_str
;
4439 len
= strlen (node
->str
) + 1;
4441 /* If the string is shorter or equal to the size of the reference, it is
4442 always better to put it inline. */
4443 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4444 return node
->form
= DW_FORM_string
;
4446 /* If we cannot expect the linker to merge strings in .debug_str
4447 section, only put it into .debug_str if it is worth even in this
4449 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4450 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4451 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4452 return node
->form
= DW_FORM_string
;
4454 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4455 ++dw2_string_counter
;
4456 node
->label
= xstrdup (label
);
4458 return node
->form
= DW_FORM_strp
;
4461 /* Add a DIE reference attribute value to a DIE. */
4464 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4468 #ifdef ENABLE_CHECKING
4469 gcc_assert (targ_die
!= NULL
);
4471 /* With LTO we can end up trying to reference something we didn't create
4472 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4473 if (targ_die
== NULL
)
4477 attr
.dw_attr
= attr_kind
;
4478 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4479 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4480 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4481 add_dwarf_attr (die
, &attr
);
4484 /* Add an AT_specification attribute to a DIE, and also make the back
4485 pointer from the specification to the definition. */
4488 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4490 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4491 gcc_assert (!targ_die
->die_definition
);
4492 targ_die
->die_definition
= die
;
4495 static inline dw_die_ref
4496 AT_ref (dw_attr_ref a
)
4498 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4499 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4503 AT_ref_external (dw_attr_ref a
)
4505 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4506 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4512 set_AT_ref_external (dw_attr_ref a
, int i
)
4514 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4515 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4518 /* Add an FDE reference attribute value to a DIE. */
4521 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4525 attr
.dw_attr
= attr_kind
;
4526 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4527 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4528 add_dwarf_attr (die
, &attr
);
4531 /* Add a location description attribute value to a DIE. */
4534 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4538 attr
.dw_attr
= attr_kind
;
4539 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4540 attr
.dw_attr_val
.v
.val_loc
= loc
;
4541 add_dwarf_attr (die
, &attr
);
4544 static inline dw_loc_descr_ref
4545 AT_loc (dw_attr_ref a
)
4547 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4548 return a
->dw_attr_val
.v
.val_loc
;
4552 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4556 attr
.dw_attr
= attr_kind
;
4557 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4558 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4559 add_dwarf_attr (die
, &attr
);
4560 have_location_lists
= true;
4563 static inline dw_loc_list_ref
4564 AT_loc_list (dw_attr_ref a
)
4566 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4567 return a
->dw_attr_val
.v
.val_loc_list
;
4570 static inline dw_loc_list_ref
*
4571 AT_loc_list_ptr (dw_attr_ref a
)
4573 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4574 return &a
->dw_attr_val
.v
.val_loc_list
;
4577 /* Add an address constant attribute value to a DIE. */
4580 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
)
4584 attr
.dw_attr
= attr_kind
;
4585 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
4586 attr
.dw_attr_val
.v
.val_addr
= addr
;
4587 add_dwarf_attr (die
, &attr
);
4590 /* Get the RTX from to an address DIE attribute. */
4593 AT_addr (dw_attr_ref a
)
4595 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
4596 return a
->dw_attr_val
.v
.val_addr
;
4599 /* Add a file attribute value to a DIE. */
4602 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4603 struct dwarf_file_data
*fd
)
4607 attr
.dw_attr
= attr_kind
;
4608 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
4609 attr
.dw_attr_val
.v
.val_file
= fd
;
4610 add_dwarf_attr (die
, &attr
);
4613 /* Get the dwarf_file_data from a file DIE attribute. */
4615 static inline struct dwarf_file_data
*
4616 AT_file (dw_attr_ref a
)
4618 gcc_assert (a
&& AT_class (a
) == dw_val_class_file
);
4619 return a
->dw_attr_val
.v
.val_file
;
4622 /* Add a vms delta attribute value to a DIE. */
4625 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4626 const char *lbl1
, const char *lbl2
)
4630 attr
.dw_attr
= attr_kind
;
4631 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
4632 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
4633 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
4634 add_dwarf_attr (die
, &attr
);
4637 /* Add a label identifier attribute value to a DIE. */
4640 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *lbl_id
)
4644 attr
.dw_attr
= attr_kind
;
4645 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4646 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4647 add_dwarf_attr (die
, &attr
);
4650 /* Add a section offset attribute value to a DIE, an offset into the
4651 debug_line section. */
4654 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4659 attr
.dw_attr
= attr_kind
;
4660 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
4661 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4662 add_dwarf_attr (die
, &attr
);
4665 /* Add a section offset attribute value to a DIE, an offset into the
4666 debug_macinfo section. */
4669 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4674 attr
.dw_attr
= attr_kind
;
4675 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
4676 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4677 add_dwarf_attr (die
, &attr
);
4680 /* Add an offset attribute value to a DIE. */
4683 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4684 unsigned HOST_WIDE_INT offset
)
4688 attr
.dw_attr
= attr_kind
;
4689 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
4690 attr
.dw_attr_val
.v
.val_offset
= offset
;
4691 add_dwarf_attr (die
, &attr
);
4694 /* Add an range_list attribute value to a DIE. */
4697 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4698 long unsigned int offset
)
4702 attr
.dw_attr
= attr_kind
;
4703 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
4704 attr
.dw_attr_val
.v
.val_offset
= offset
;
4705 add_dwarf_attr (die
, &attr
);
4708 /* Return the start label of a delta attribute. */
4710 static inline const char *
4711 AT_vms_delta1 (dw_attr_ref a
)
4713 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4714 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
4717 /* Return the end label of a delta attribute. */
4719 static inline const char *
4720 AT_vms_delta2 (dw_attr_ref a
)
4722 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4723 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
4726 static inline const char *
4727 AT_lbl (dw_attr_ref a
)
4729 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
4730 || AT_class (a
) == dw_val_class_lineptr
4731 || AT_class (a
) == dw_val_class_macptr
));
4732 return a
->dw_attr_val
.v
.val_lbl_id
;
4735 /* Get the attribute of type attr_kind. */
4738 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4742 dw_die_ref spec
= NULL
;
4747 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
4748 if (a
->dw_attr
== attr_kind
)
4750 else if (a
->dw_attr
== DW_AT_specification
4751 || a
->dw_attr
== DW_AT_abstract_origin
)
4755 return get_AT (spec
, attr_kind
);
4760 /* Return the "low pc" attribute value, typically associated with a subprogram
4761 DIE. Return null if the "low pc" attribute is either not present, or if it
4762 cannot be represented as an assembler label identifier. */
4764 static inline const char *
4765 get_AT_low_pc (dw_die_ref die
)
4767 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
4769 return a
? AT_lbl (a
) : NULL
;
4772 /* Return the "high pc" attribute value, typically associated with a subprogram
4773 DIE. Return null if the "high pc" attribute is either not present, or if it
4774 cannot be represented as an assembler label identifier. */
4776 static inline const char *
4777 get_AT_hi_pc (dw_die_ref die
)
4779 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
4781 return a
? AT_lbl (a
) : NULL
;
4784 /* Return the value of the string attribute designated by ATTR_KIND, or
4785 NULL if it is not present. */
4787 static inline const char *
4788 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4790 dw_attr_ref a
= get_AT (die
, attr_kind
);
4792 return a
? AT_string (a
) : NULL
;
4795 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4796 if it is not present. */
4799 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4801 dw_attr_ref a
= get_AT (die
, attr_kind
);
4803 return a
? AT_flag (a
) : 0;
4806 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4807 if it is not present. */
4809 static inline unsigned
4810 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4812 dw_attr_ref a
= get_AT (die
, attr_kind
);
4814 return a
? AT_unsigned (a
) : 0;
4817 static inline dw_die_ref
4818 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4820 dw_attr_ref a
= get_AT (die
, attr_kind
);
4822 return a
? AT_ref (a
) : NULL
;
4825 static inline struct dwarf_file_data
*
4826 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4828 dw_attr_ref a
= get_AT (die
, attr_kind
);
4830 return a
? AT_file (a
) : NULL
;
4833 /* Return TRUE if the language is C++. */
4838 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4840 return lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
;
4843 /* Return TRUE if the language is Fortran. */
4848 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4850 return (lang
== DW_LANG_Fortran77
4851 || lang
== DW_LANG_Fortran90
4852 || lang
== DW_LANG_Fortran95
);
4855 /* Return TRUE if the language is Ada. */
4860 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
4862 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
4865 /* Remove the specified attribute if present. */
4868 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4876 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
4877 if (a
->dw_attr
== attr_kind
)
4879 if (AT_class (a
) == dw_val_class_str
)
4880 if (a
->dw_attr_val
.v
.val_str
->refcount
)
4881 a
->dw_attr_val
.v
.val_str
->refcount
--;
4883 /* VEC_ordered_remove should help reduce the number of abbrevs
4885 VEC_ordered_remove (dw_attr_node
, die
->die_attr
, ix
);
4890 /* Remove CHILD from its parent. PREV must have the property that
4891 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4894 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
4896 gcc_assert (child
->die_parent
== prev
->die_parent
);
4897 gcc_assert (prev
->die_sib
== child
);
4900 gcc_assert (child
->die_parent
->die_child
== child
);
4904 prev
->die_sib
= child
->die_sib
;
4905 if (child
->die_parent
->die_child
== child
)
4906 child
->die_parent
->die_child
= prev
;
4909 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4910 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4913 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
4915 dw_die_ref parent
= old_child
->die_parent
;
4917 gcc_assert (parent
== prev
->die_parent
);
4918 gcc_assert (prev
->die_sib
== old_child
);
4920 new_child
->die_parent
= parent
;
4921 if (prev
== old_child
)
4923 gcc_assert (parent
->die_child
== old_child
);
4924 new_child
->die_sib
= new_child
;
4928 prev
->die_sib
= new_child
;
4929 new_child
->die_sib
= old_child
->die_sib
;
4931 if (old_child
->die_parent
->die_child
== old_child
)
4932 old_child
->die_parent
->die_child
= new_child
;
4935 /* Move all children from OLD_PARENT to NEW_PARENT. */
4938 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
4941 new_parent
->die_child
= old_parent
->die_child
;
4942 old_parent
->die_child
= NULL
;
4943 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
4946 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4950 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
4956 dw_die_ref prev
= c
;
4958 while (c
->die_tag
== tag
)
4960 remove_child_with_prev (c
, prev
);
4961 /* Might have removed every child. */
4962 if (c
== c
->die_sib
)
4966 } while (c
!= die
->die_child
);
4969 /* Add a CHILD_DIE as the last child of DIE. */
4972 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
4974 /* FIXME this should probably be an assert. */
4975 if (! die
|| ! child_die
)
4977 gcc_assert (die
!= child_die
);
4979 child_die
->die_parent
= die
;
4982 child_die
->die_sib
= die
->die_child
->die_sib
;
4983 die
->die_child
->die_sib
= child_die
;
4986 child_die
->die_sib
= child_die
;
4987 die
->die_child
= child_die
;
4990 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4991 is the specification, to the end of PARENT's list of children.
4992 This is done by removing and re-adding it. */
4995 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
4999 /* We want the declaration DIE from inside the class, not the
5000 specification DIE at toplevel. */
5001 if (child
->die_parent
!= parent
)
5003 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5009 gcc_assert (child
->die_parent
== parent
5010 || (child
->die_parent
5011 == get_AT_ref (parent
, DW_AT_specification
)));
5013 for (p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5014 if (p
->die_sib
== child
)
5016 remove_child_with_prev (child
, p
);
5020 add_child_die (parent
, child
);
5023 /* Return a pointer to a newly created DIE node. */
5025 static inline dw_die_ref
5026 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5028 dw_die_ref die
= ggc_alloc_cleared_die_node ();
5030 die
->die_tag
= tag_value
;
5032 if (parent_die
!= NULL
)
5033 add_child_die (parent_die
, die
);
5036 limbo_die_node
*limbo_node
;
5038 limbo_node
= ggc_alloc_cleared_limbo_die_node ();
5039 limbo_node
->die
= die
;
5040 limbo_node
->created_for
= t
;
5041 limbo_node
->next
= limbo_die_list
;
5042 limbo_die_list
= limbo_node
;
5048 /* Return the DIE associated with the given type specifier. */
5050 static inline dw_die_ref
5051 lookup_type_die (tree type
)
5053 return TYPE_SYMTAB_DIE (type
);
5056 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5057 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5058 anonymous type instead the one of the naming typedef. */
5060 static inline dw_die_ref
5061 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5064 && TREE_CODE (type
) == RECORD_TYPE
5066 && type_die
->die_tag
== DW_TAG_typedef
5067 && is_naming_typedef_decl (TYPE_NAME (type
)))
5068 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5072 /* Like lookup_type_die, but if type is an anonymous type named by a
5073 typedef[1], return the DIE of the anonymous type instead the one of
5074 the naming typedef. This is because in gen_typedef_die, we did
5075 equate the anonymous struct named by the typedef with the DIE of
5076 the naming typedef. So by default, lookup_type_die on an anonymous
5077 struct yields the DIE of the naming typedef.
5079 [1]: Read the comment of is_naming_typedef_decl to learn about what
5080 a naming typedef is. */
5082 static inline dw_die_ref
5083 lookup_type_die_strip_naming_typedef (tree type
)
5085 dw_die_ref die
= lookup_type_die (type
);
5086 return strip_naming_typedef (type
, die
);
5089 /* Equate a DIE to a given type specifier. */
5092 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5094 TYPE_SYMTAB_DIE (type
) = type_die
;
5097 /* Returns a hash value for X (which really is a die_struct). */
5100 decl_die_table_hash (const void *x
)
5102 return (hashval_t
) ((const_dw_die_ref
) x
)->decl_id
;
5105 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5108 decl_die_table_eq (const void *x
, const void *y
)
5110 return (((const_dw_die_ref
) x
)->decl_id
== DECL_UID ((const_tree
) y
));
5113 /* Return the DIE associated with a given declaration. */
5115 static inline dw_die_ref
5116 lookup_decl_die (tree decl
)
5118 return (dw_die_ref
) htab_find_with_hash (decl_die_table
, decl
, DECL_UID (decl
));
5121 /* Returns a hash value for X (which really is a var_loc_list). */
5124 decl_loc_table_hash (const void *x
)
5126 return (hashval_t
) ((const var_loc_list
*) x
)->decl_id
;
5129 /* Return nonzero if decl_id of var_loc_list X is the same as
5133 decl_loc_table_eq (const void *x
, const void *y
)
5135 return (((const var_loc_list
*) x
)->decl_id
== DECL_UID ((const_tree
) y
));
5138 /* Return the var_loc list associated with a given declaration. */
5140 static inline var_loc_list
*
5141 lookup_decl_loc (const_tree decl
)
5143 if (!decl_loc_table
)
5145 return (var_loc_list
*)
5146 htab_find_with_hash (decl_loc_table
, decl
, DECL_UID (decl
));
5149 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
5152 cached_dw_loc_list_table_hash (const void *x
)
5154 return (hashval_t
) ((const cached_dw_loc_list
*) x
)->decl_id
;
5157 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
5161 cached_dw_loc_list_table_eq (const void *x
, const void *y
)
5163 return (((const cached_dw_loc_list
*) x
)->decl_id
5164 == DECL_UID ((const_tree
) y
));
5167 /* Equate a DIE to a particular declaration. */
5170 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
5172 unsigned int decl_id
= DECL_UID (decl
);
5175 slot
= htab_find_slot_with_hash (decl_die_table
, decl
, decl_id
, INSERT
);
5177 decl_die
->decl_id
= decl_id
;
5180 /* Return how many bits covers PIECE EXPR_LIST. */
5183 decl_piece_bitsize (rtx piece
)
5185 int ret
= (int) GET_MODE (piece
);
5188 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
5189 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
5190 return INTVAL (XEXP (XEXP (piece
, 0), 0));
5193 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5196 decl_piece_varloc_ptr (rtx piece
)
5198 if ((int) GET_MODE (piece
))
5199 return &XEXP (piece
, 0);
5201 return &XEXP (XEXP (piece
, 0), 1);
5204 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5205 Next is the chain of following piece nodes. */
5208 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
5210 if (bitsize
<= (int) MAX_MACHINE_MODE
)
5211 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
5213 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
5218 /* Return rtx that should be stored into loc field for
5219 LOC_NOTE and BITPOS/BITSIZE. */
5222 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
5223 HOST_WIDE_INT bitsize
)
5227 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
5229 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
5234 /* This function either modifies location piece list *DEST in
5235 place (if SRC and INNER is NULL), or copies location piece list
5236 *SRC to *DEST while modifying it. Location BITPOS is modified
5237 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5238 not copied and if needed some padding around it is added.
5239 When modifying in place, DEST should point to EXPR_LIST where
5240 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5241 to the start of the whole list and INNER points to the EXPR_LIST
5242 where earlier pieces cover PIECE_BITPOS bits. */
5245 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
5246 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
5247 HOST_WIDE_INT bitsize
, rtx loc_note
)
5250 bool copy
= inner
!= NULL
;
5254 /* First copy all nodes preceeding the current bitpos. */
5255 while (src
!= inner
)
5257 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5258 decl_piece_bitsize (*src
), NULL_RTX
);
5259 dest
= &XEXP (*dest
, 1);
5260 src
= &XEXP (*src
, 1);
5263 /* Add padding if needed. */
5264 if (bitpos
!= piece_bitpos
)
5266 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
5267 copy
? NULL_RTX
: *dest
);
5268 dest
= &XEXP (*dest
, 1);
5270 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
5273 /* A piece with correct bitpos and bitsize already exist,
5274 just update the location for it and return. */
5275 *decl_piece_varloc_ptr (*dest
) = loc_note
;
5278 /* Add the piece that changed. */
5279 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
5280 dest
= &XEXP (*dest
, 1);
5281 /* Skip over pieces that overlap it. */
5282 diff
= bitpos
- piece_bitpos
+ bitsize
;
5285 while (diff
> 0 && *src
)
5288 diff
-= decl_piece_bitsize (piece
);
5290 src
= &XEXP (piece
, 1);
5293 *src
= XEXP (piece
, 1);
5294 free_EXPR_LIST_node (piece
);
5297 /* Add padding if needed. */
5298 if (diff
< 0 && *src
)
5302 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
5303 dest
= &XEXP (*dest
, 1);
5307 /* Finally copy all nodes following it. */
5310 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5311 decl_piece_bitsize (*src
), NULL_RTX
);
5312 dest
= &XEXP (*dest
, 1);
5313 src
= &XEXP (*src
, 1);
5317 /* Add a variable location node to the linked list for DECL. */
5319 static struct var_loc_node
*
5320 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
)
5322 unsigned int decl_id
;
5325 struct var_loc_node
*loc
= NULL
;
5326 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
5328 if (DECL_DEBUG_EXPR_IS_FROM (decl
))
5330 tree realdecl
= DECL_DEBUG_EXPR (decl
);
5331 if (realdecl
&& handled_component_p (realdecl
))
5333 HOST_WIDE_INT maxsize
;
5336 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
, &maxsize
);
5337 if (!DECL_P (innerdecl
)
5338 || DECL_IGNORED_P (innerdecl
)
5339 || TREE_STATIC (innerdecl
)
5341 || bitpos
+ bitsize
> 256
5342 || bitsize
!= maxsize
)
5348 decl_id
= DECL_UID (decl
);
5349 slot
= htab_find_slot_with_hash (decl_loc_table
, decl
, decl_id
, INSERT
);
5352 temp
= ggc_alloc_cleared_var_loc_list ();
5353 temp
->decl_id
= decl_id
;
5357 temp
= (var_loc_list
*) *slot
;
5359 /* For PARM_DECLs try to keep around the original incoming value,
5360 even if that means we'll emit a zero-range .debug_loc entry. */
5362 && temp
->first
== temp
->last
5363 && TREE_CODE (decl
) == PARM_DECL
5364 && GET_CODE (temp
->first
->loc
) == NOTE
5365 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
5366 && DECL_INCOMING_RTL (decl
)
5367 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
5368 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
5369 == GET_CODE (DECL_INCOMING_RTL (decl
))
5370 && prev_real_insn (temp
->first
->loc
) == NULL_RTX
5372 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
5373 NOTE_VAR_LOCATION_LOC (loc_note
))
5374 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
5375 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
5377 loc
= ggc_alloc_cleared_var_loc_node ();
5378 temp
->first
->next
= loc
;
5380 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5382 else if (temp
->last
)
5384 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
5385 rtx
*piece_loc
= NULL
, last_loc_note
;
5386 int piece_bitpos
= 0;
5390 gcc_assert (last
->next
== NULL
);
5392 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
5394 piece_loc
= &last
->loc
;
5397 int cur_bitsize
= decl_piece_bitsize (*piece_loc
);
5398 if (piece_bitpos
+ cur_bitsize
> bitpos
)
5400 piece_bitpos
+= cur_bitsize
;
5401 piece_loc
= &XEXP (*piece_loc
, 1);
5405 /* TEMP->LAST here is either pointer to the last but one or
5406 last element in the chained list, LAST is pointer to the
5408 if (label
&& strcmp (last
->label
, label
) == 0)
5410 /* For SRA optimized variables if there weren't any real
5411 insns since last note, just modify the last node. */
5412 if (piece_loc
!= NULL
)
5414 adjust_piece_list (piece_loc
, NULL
, NULL
,
5415 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5418 /* If the last note doesn't cover any instructions, remove it. */
5419 if (temp
->last
!= last
)
5421 temp
->last
->next
= NULL
;
5424 gcc_assert (strcmp (last
->label
, label
) != 0);
5428 gcc_assert (temp
->first
== temp
->last
5429 || (temp
->first
->next
== temp
->last
5430 && TREE_CODE (decl
) == PARM_DECL
));
5431 memset (temp
->last
, '\0', sizeof (*temp
->last
));
5432 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5436 if (bitsize
== -1 && NOTE_P (last
->loc
))
5437 last_loc_note
= last
->loc
;
5438 else if (piece_loc
!= NULL
5439 && *piece_loc
!= NULL_RTX
5440 && piece_bitpos
== bitpos
5441 && decl_piece_bitsize (*piece_loc
) == bitsize
)
5442 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
5444 last_loc_note
= NULL_RTX
;
5445 /* If the current location is the same as the end of the list,
5446 and either both or neither of the locations is uninitialized,
5447 we have nothing to do. */
5448 if (last_loc_note
== NULL_RTX
5449 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
5450 NOTE_VAR_LOCATION_LOC (loc_note
)))
5451 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5452 != NOTE_VAR_LOCATION_STATUS (loc_note
))
5453 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
5454 == VAR_INIT_STATUS_UNINITIALIZED
)
5455 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
5456 == VAR_INIT_STATUS_UNINITIALIZED
))))
5458 /* Add LOC to the end of list and update LAST. If the last
5459 element of the list has been removed above, reuse its
5460 memory for the new node, otherwise allocate a new one. */
5464 memset (loc
, '\0', sizeof (*loc
));
5467 loc
= ggc_alloc_cleared_var_loc_node ();
5468 if (bitsize
== -1 || piece_loc
== NULL
)
5469 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5471 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
5472 bitpos
, piece_bitpos
, bitsize
, loc_note
);
5474 /* Ensure TEMP->LAST will point either to the new last but one
5475 element of the chain, or to the last element in it. */
5476 if (last
!= temp
->last
)
5484 loc
= ggc_alloc_cleared_var_loc_node ();
5487 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5492 /* Keep track of the number of spaces used to indent the
5493 output of the debugging routines that print the structure of
5494 the DIE internal representation. */
5495 static int print_indent
;
5497 /* Indent the line the number of spaces given by print_indent. */
5500 print_spaces (FILE *outfile
)
5502 fprintf (outfile
, "%*s", print_indent
, "");
5505 /* Print a type signature in hex. */
5508 print_signature (FILE *outfile
, char *sig
)
5512 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
5513 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
5516 /* Print the information associated with a given DIE, and its children.
5517 This routine is a debugging aid only. */
5520 print_die (dw_die_ref die
, FILE *outfile
)
5526 print_spaces (outfile
);
5527 fprintf (outfile
, "DIE %4ld: %s (%p)\n",
5528 die
->die_offset
, dwarf_tag_name (die
->die_tag
),
5530 print_spaces (outfile
);
5531 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
5532 fprintf (outfile
, " offset: %ld", die
->die_offset
);
5533 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
5535 if (use_debug_types
&& die
->die_id
.die_type_node
)
5537 print_spaces (outfile
);
5538 fprintf (outfile
, " signature: ");
5539 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
5540 fprintf (outfile
, "\n");
5543 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
5545 print_spaces (outfile
);
5546 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
5548 switch (AT_class (a
))
5550 case dw_val_class_addr
:
5551 fprintf (outfile
, "address");
5553 case dw_val_class_offset
:
5554 fprintf (outfile
, "offset");
5556 case dw_val_class_loc
:
5557 fprintf (outfile
, "location descriptor");
5559 case dw_val_class_loc_list
:
5560 fprintf (outfile
, "location list -> label:%s",
5561 AT_loc_list (a
)->ll_symbol
);
5563 case dw_val_class_range_list
:
5564 fprintf (outfile
, "range list");
5566 case dw_val_class_const
:
5567 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
5569 case dw_val_class_unsigned_const
:
5570 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
5572 case dw_val_class_const_double
:
5573 fprintf (outfile
, "constant ("HOST_WIDE_INT_PRINT_DEC
","\
5574 HOST_WIDE_INT_PRINT_UNSIGNED
")",
5575 a
->dw_attr_val
.v
.val_double
.high
,
5576 a
->dw_attr_val
.v
.val_double
.low
);
5578 case dw_val_class_vec
:
5579 fprintf (outfile
, "floating-point or vector constant");
5581 case dw_val_class_flag
:
5582 fprintf (outfile
, "%u", AT_flag (a
));
5584 case dw_val_class_die_ref
:
5585 if (AT_ref (a
) != NULL
)
5587 if (use_debug_types
&& AT_ref (a
)->die_id
.die_type_node
)
5589 fprintf (outfile
, "die -> signature: ");
5590 print_signature (outfile
,
5591 AT_ref (a
)->die_id
.die_type_node
->signature
);
5593 else if (! use_debug_types
&& AT_ref (a
)->die_id
.die_symbol
)
5594 fprintf (outfile
, "die -> label: %s",
5595 AT_ref (a
)->die_id
.die_symbol
);
5597 fprintf (outfile
, "die -> %ld", AT_ref (a
)->die_offset
);
5598 fprintf (outfile
, " (%p)", (void *) AT_ref (a
));
5601 fprintf (outfile
, "die -> <null>");
5603 case dw_val_class_vms_delta
:
5604 fprintf (outfile
, "delta: @slotcount(%s-%s)",
5605 AT_vms_delta2 (a
), AT_vms_delta1 (a
));
5607 case dw_val_class_lbl_id
:
5608 case dw_val_class_lineptr
:
5609 case dw_val_class_macptr
:
5610 fprintf (outfile
, "label: %s", AT_lbl (a
));
5612 case dw_val_class_str
:
5613 if (AT_string (a
) != NULL
)
5614 fprintf (outfile
, "\"%s\"", AT_string (a
));
5616 fprintf (outfile
, "<null>");
5618 case dw_val_class_file
:
5619 fprintf (outfile
, "\"%s\" (%d)", AT_file (a
)->filename
,
5620 AT_file (a
)->emitted_number
);
5622 case dw_val_class_data8
:
5626 for (i
= 0; i
< 8; i
++)
5627 fprintf (outfile
, "%02x", a
->dw_attr_val
.v
.val_data8
[i
]);
5634 fprintf (outfile
, "\n");
5637 if (die
->die_child
!= NULL
)
5640 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
5643 if (print_indent
== 0)
5644 fprintf (outfile
, "\n");
5647 /* Print the information collected for a given DIE. */
5650 debug_dwarf_die (dw_die_ref die
)
5652 print_die (die
, stderr
);
5655 /* Print all DWARF information collected for the compilation unit.
5656 This routine is a debugging aid only. */
5662 print_die (comp_unit_die (), stderr
);
5665 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5666 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5667 DIE that marks the start of the DIEs for this include file. */
5670 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
5672 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
5673 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
5675 new_unit
->die_sib
= old_unit
;
5679 /* Close an include-file CU and reopen the enclosing one. */
5682 pop_compile_unit (dw_die_ref old_unit
)
5684 dw_die_ref new_unit
= old_unit
->die_sib
;
5686 old_unit
->die_sib
= NULL
;
5690 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5691 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5693 /* Calculate the checksum of a location expression. */
5696 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5700 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
5702 CHECKSUM (loc
->dw_loc_oprnd1
);
5703 CHECKSUM (loc
->dw_loc_oprnd2
);
5706 /* Calculate the checksum of an attribute. */
5709 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
5711 dw_loc_descr_ref loc
;
5714 CHECKSUM (at
->dw_attr
);
5716 /* We don't care that this was compiled with a different compiler
5717 snapshot; if the output is the same, that's what matters. */
5718 if (at
->dw_attr
== DW_AT_producer
)
5721 switch (AT_class (at
))
5723 case dw_val_class_const
:
5724 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
5726 case dw_val_class_unsigned_const
:
5727 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
5729 case dw_val_class_const_double
:
5730 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
5732 case dw_val_class_vec
:
5733 CHECKSUM (at
->dw_attr_val
.v
.val_vec
);
5735 case dw_val_class_flag
:
5736 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
5738 case dw_val_class_str
:
5739 CHECKSUM_STRING (AT_string (at
));
5742 case dw_val_class_addr
:
5744 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5745 CHECKSUM_STRING (XSTR (r
, 0));
5748 case dw_val_class_offset
:
5749 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
5752 case dw_val_class_loc
:
5753 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5754 loc_checksum (loc
, ctx
);
5757 case dw_val_class_die_ref
:
5758 die_checksum (AT_ref (at
), ctx
, mark
);
5761 case dw_val_class_fde_ref
:
5762 case dw_val_class_vms_delta
:
5763 case dw_val_class_lbl_id
:
5764 case dw_val_class_lineptr
:
5765 case dw_val_class_macptr
:
5768 case dw_val_class_file
:
5769 CHECKSUM_STRING (AT_file (at
)->filename
);
5772 case dw_val_class_data8
:
5773 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
5781 /* Calculate the checksum of a DIE. */
5784 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
5790 /* To avoid infinite recursion. */
5793 CHECKSUM (die
->die_mark
);
5796 die
->die_mark
= ++(*mark
);
5798 CHECKSUM (die
->die_tag
);
5800 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
5801 attr_checksum (a
, ctx
, mark
);
5803 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
5807 #undef CHECKSUM_STRING
5809 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
5810 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5811 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
5812 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
5813 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
5814 #define CHECKSUM_ATTR(FOO) \
5815 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
5817 /* Calculate the checksum of a number in signed LEB128 format. */
5820 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
5827 byte
= (value
& 0x7f);
5829 more
= !((value
== 0 && (byte
& 0x40) == 0)
5830 || (value
== -1 && (byte
& 0x40) != 0));
5839 /* Calculate the checksum of a number in unsigned LEB128 format. */
5842 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
5846 unsigned char byte
= (value
& 0x7f);
5849 /* More bytes to follow. */
5857 /* Checksum the context of the DIE. This adds the names of any
5858 surrounding namespaces or structures to the checksum. */
5861 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
5865 int tag
= die
->die_tag
;
5867 if (tag
!= DW_TAG_namespace
5868 && tag
!= DW_TAG_structure_type
5869 && tag
!= DW_TAG_class_type
)
5872 name
= get_AT_string (die
, DW_AT_name
);
5874 spec
= get_AT_ref (die
, DW_AT_specification
);
5878 if (die
->die_parent
!= NULL
)
5879 checksum_die_context (die
->die_parent
, ctx
);
5881 CHECKSUM_ULEB128 ('C');
5882 CHECKSUM_ULEB128 (tag
);
5884 CHECKSUM_STRING (name
);
5887 /* Calculate the checksum of a location expression. */
5890 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5892 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
5893 were emitted as a DW_FORM_sdata instead of a location expression. */
5894 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
5896 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5897 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
5901 /* Otherwise, just checksum the raw location expression. */
5904 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
5905 CHECKSUM (loc
->dw_loc_oprnd1
);
5906 CHECKSUM (loc
->dw_loc_oprnd2
);
5907 loc
= loc
->dw_loc_next
;
5911 /* Calculate the checksum of an attribute. */
5914 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_ref at
,
5915 struct md5_ctx
*ctx
, int *mark
)
5917 dw_loc_descr_ref loc
;
5920 if (AT_class (at
) == dw_val_class_die_ref
)
5922 dw_die_ref target_die
= AT_ref (at
);
5924 /* For pointer and reference types, we checksum only the (qualified)
5925 name of the target type (if there is a name). For friend entries,
5926 we checksum only the (qualified) name of the target type or function.
5927 This allows the checksum to remain the same whether the target type
5928 is complete or not. */
5929 if ((at
->dw_attr
== DW_AT_type
5930 && (tag
== DW_TAG_pointer_type
5931 || tag
== DW_TAG_reference_type
5932 || tag
== DW_TAG_rvalue_reference_type
5933 || tag
== DW_TAG_ptr_to_member_type
))
5934 || (at
->dw_attr
== DW_AT_friend
5935 && tag
== DW_TAG_friend
))
5937 dw_attr_ref name_attr
= get_AT (target_die
, DW_AT_name
);
5939 if (name_attr
!= NULL
)
5941 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
5945 CHECKSUM_ULEB128 ('N');
5946 CHECKSUM_ULEB128 (at
->dw_attr
);
5947 if (decl
->die_parent
!= NULL
)
5948 checksum_die_context (decl
->die_parent
, ctx
);
5949 CHECKSUM_ULEB128 ('E');
5950 CHECKSUM_STRING (AT_string (name_attr
));
5955 /* For all other references to another DIE, we check to see if the
5956 target DIE has already been visited. If it has, we emit a
5957 backward reference; if not, we descend recursively. */
5958 if (target_die
->die_mark
> 0)
5960 CHECKSUM_ULEB128 ('R');
5961 CHECKSUM_ULEB128 (at
->dw_attr
);
5962 CHECKSUM_ULEB128 (target_die
->die_mark
);
5966 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
5970 target_die
->die_mark
= ++(*mark
);
5971 CHECKSUM_ULEB128 ('T');
5972 CHECKSUM_ULEB128 (at
->dw_attr
);
5973 if (decl
->die_parent
!= NULL
)
5974 checksum_die_context (decl
->die_parent
, ctx
);
5975 die_checksum_ordered (target_die
, ctx
, mark
);
5980 CHECKSUM_ULEB128 ('A');
5981 CHECKSUM_ULEB128 (at
->dw_attr
);
5983 switch (AT_class (at
))
5985 case dw_val_class_const
:
5986 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5987 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
5990 case dw_val_class_unsigned_const
:
5991 CHECKSUM_ULEB128 (DW_FORM_sdata
);
5992 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
5995 case dw_val_class_const_double
:
5996 CHECKSUM_ULEB128 (DW_FORM_block
);
5997 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
5998 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6001 case dw_val_class_vec
:
6002 CHECKSUM_ULEB128 (DW_FORM_block
);
6003 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_vec
));
6004 CHECKSUM (at
->dw_attr_val
.v
.val_vec
);
6007 case dw_val_class_flag
:
6008 CHECKSUM_ULEB128 (DW_FORM_flag
);
6009 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
6012 case dw_val_class_str
:
6013 CHECKSUM_ULEB128 (DW_FORM_string
);
6014 CHECKSUM_STRING (AT_string (at
));
6017 case dw_val_class_addr
:
6019 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6020 CHECKSUM_ULEB128 (DW_FORM_string
);
6021 CHECKSUM_STRING (XSTR (r
, 0));
6024 case dw_val_class_offset
:
6025 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6026 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
6029 case dw_val_class_loc
:
6030 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6031 loc_checksum_ordered (loc
, ctx
);
6034 case dw_val_class_fde_ref
:
6035 case dw_val_class_lbl_id
:
6036 case dw_val_class_lineptr
:
6037 case dw_val_class_macptr
:
6040 case dw_val_class_file
:
6041 CHECKSUM_ULEB128 (DW_FORM_string
);
6042 CHECKSUM_STRING (AT_file (at
)->filename
);
6045 case dw_val_class_data8
:
6046 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6054 struct checksum_attributes
6056 dw_attr_ref at_name
;
6057 dw_attr_ref at_type
;
6058 dw_attr_ref at_friend
;
6059 dw_attr_ref at_accessibility
;
6060 dw_attr_ref at_address_class
;
6061 dw_attr_ref at_allocated
;
6062 dw_attr_ref at_artificial
;
6063 dw_attr_ref at_associated
;
6064 dw_attr_ref at_binary_scale
;
6065 dw_attr_ref at_bit_offset
;
6066 dw_attr_ref at_bit_size
;
6067 dw_attr_ref at_bit_stride
;
6068 dw_attr_ref at_byte_size
;
6069 dw_attr_ref at_byte_stride
;
6070 dw_attr_ref at_const_value
;
6071 dw_attr_ref at_containing_type
;
6072 dw_attr_ref at_count
;
6073 dw_attr_ref at_data_location
;
6074 dw_attr_ref at_data_member_location
;
6075 dw_attr_ref at_decimal_scale
;
6076 dw_attr_ref at_decimal_sign
;
6077 dw_attr_ref at_default_value
;
6078 dw_attr_ref at_digit_count
;
6079 dw_attr_ref at_discr
;
6080 dw_attr_ref at_discr_list
;
6081 dw_attr_ref at_discr_value
;
6082 dw_attr_ref at_encoding
;
6083 dw_attr_ref at_endianity
;
6084 dw_attr_ref at_explicit
;
6085 dw_attr_ref at_is_optional
;
6086 dw_attr_ref at_location
;
6087 dw_attr_ref at_lower_bound
;
6088 dw_attr_ref at_mutable
;
6089 dw_attr_ref at_ordering
;
6090 dw_attr_ref at_picture_string
;
6091 dw_attr_ref at_prototyped
;
6092 dw_attr_ref at_small
;
6093 dw_attr_ref at_segment
;
6094 dw_attr_ref at_string_length
;
6095 dw_attr_ref at_threads_scaled
;
6096 dw_attr_ref at_upper_bound
;
6097 dw_attr_ref at_use_location
;
6098 dw_attr_ref at_use_UTF8
;
6099 dw_attr_ref at_variable_parameter
;
6100 dw_attr_ref at_virtuality
;
6101 dw_attr_ref at_visibility
;
6102 dw_attr_ref at_vtable_elem_location
;
6105 /* Collect the attributes that we will want to use for the checksum. */
6108 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
6113 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
6124 attrs
->at_friend
= a
;
6126 case DW_AT_accessibility
:
6127 attrs
->at_accessibility
= a
;
6129 case DW_AT_address_class
:
6130 attrs
->at_address_class
= a
;
6132 case DW_AT_allocated
:
6133 attrs
->at_allocated
= a
;
6135 case DW_AT_artificial
:
6136 attrs
->at_artificial
= a
;
6138 case DW_AT_associated
:
6139 attrs
->at_associated
= a
;
6141 case DW_AT_binary_scale
:
6142 attrs
->at_binary_scale
= a
;
6144 case DW_AT_bit_offset
:
6145 attrs
->at_bit_offset
= a
;
6147 case DW_AT_bit_size
:
6148 attrs
->at_bit_size
= a
;
6150 case DW_AT_bit_stride
:
6151 attrs
->at_bit_stride
= a
;
6153 case DW_AT_byte_size
:
6154 attrs
->at_byte_size
= a
;
6156 case DW_AT_byte_stride
:
6157 attrs
->at_byte_stride
= a
;
6159 case DW_AT_const_value
:
6160 attrs
->at_const_value
= a
;
6162 case DW_AT_containing_type
:
6163 attrs
->at_containing_type
= a
;
6166 attrs
->at_count
= a
;
6168 case DW_AT_data_location
:
6169 attrs
->at_data_location
= a
;
6171 case DW_AT_data_member_location
:
6172 attrs
->at_data_member_location
= a
;
6174 case DW_AT_decimal_scale
:
6175 attrs
->at_decimal_scale
= a
;
6177 case DW_AT_decimal_sign
:
6178 attrs
->at_decimal_sign
= a
;
6180 case DW_AT_default_value
:
6181 attrs
->at_default_value
= a
;
6183 case DW_AT_digit_count
:
6184 attrs
->at_digit_count
= a
;
6187 attrs
->at_discr
= a
;
6189 case DW_AT_discr_list
:
6190 attrs
->at_discr_list
= a
;
6192 case DW_AT_discr_value
:
6193 attrs
->at_discr_value
= a
;
6195 case DW_AT_encoding
:
6196 attrs
->at_encoding
= a
;
6198 case DW_AT_endianity
:
6199 attrs
->at_endianity
= a
;
6201 case DW_AT_explicit
:
6202 attrs
->at_explicit
= a
;
6204 case DW_AT_is_optional
:
6205 attrs
->at_is_optional
= a
;
6207 case DW_AT_location
:
6208 attrs
->at_location
= a
;
6210 case DW_AT_lower_bound
:
6211 attrs
->at_lower_bound
= a
;
6214 attrs
->at_mutable
= a
;
6216 case DW_AT_ordering
:
6217 attrs
->at_ordering
= a
;
6219 case DW_AT_picture_string
:
6220 attrs
->at_picture_string
= a
;
6222 case DW_AT_prototyped
:
6223 attrs
->at_prototyped
= a
;
6226 attrs
->at_small
= a
;
6229 attrs
->at_segment
= a
;
6231 case DW_AT_string_length
:
6232 attrs
->at_string_length
= a
;
6234 case DW_AT_threads_scaled
:
6235 attrs
->at_threads_scaled
= a
;
6237 case DW_AT_upper_bound
:
6238 attrs
->at_upper_bound
= a
;
6240 case DW_AT_use_location
:
6241 attrs
->at_use_location
= a
;
6243 case DW_AT_use_UTF8
:
6244 attrs
->at_use_UTF8
= a
;
6246 case DW_AT_variable_parameter
:
6247 attrs
->at_variable_parameter
= a
;
6249 case DW_AT_virtuality
:
6250 attrs
->at_virtuality
= a
;
6252 case DW_AT_visibility
:
6253 attrs
->at_visibility
= a
;
6255 case DW_AT_vtable_elem_location
:
6256 attrs
->at_vtable_elem_location
= a
;
6264 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6267 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6271 struct checksum_attributes attrs
;
6273 CHECKSUM_ULEB128 ('D');
6274 CHECKSUM_ULEB128 (die
->die_tag
);
6276 memset (&attrs
, 0, sizeof (attrs
));
6278 decl
= get_AT_ref (die
, DW_AT_specification
);
6280 collect_checksum_attributes (&attrs
, decl
);
6281 collect_checksum_attributes (&attrs
, die
);
6283 CHECKSUM_ATTR (attrs
.at_name
);
6284 CHECKSUM_ATTR (attrs
.at_accessibility
);
6285 CHECKSUM_ATTR (attrs
.at_address_class
);
6286 CHECKSUM_ATTR (attrs
.at_allocated
);
6287 CHECKSUM_ATTR (attrs
.at_artificial
);
6288 CHECKSUM_ATTR (attrs
.at_associated
);
6289 CHECKSUM_ATTR (attrs
.at_binary_scale
);
6290 CHECKSUM_ATTR (attrs
.at_bit_offset
);
6291 CHECKSUM_ATTR (attrs
.at_bit_size
);
6292 CHECKSUM_ATTR (attrs
.at_bit_stride
);
6293 CHECKSUM_ATTR (attrs
.at_byte_size
);
6294 CHECKSUM_ATTR (attrs
.at_byte_stride
);
6295 CHECKSUM_ATTR (attrs
.at_const_value
);
6296 CHECKSUM_ATTR (attrs
.at_containing_type
);
6297 CHECKSUM_ATTR (attrs
.at_count
);
6298 CHECKSUM_ATTR (attrs
.at_data_location
);
6299 CHECKSUM_ATTR (attrs
.at_data_member_location
);
6300 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
6301 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
6302 CHECKSUM_ATTR (attrs
.at_default_value
);
6303 CHECKSUM_ATTR (attrs
.at_digit_count
);
6304 CHECKSUM_ATTR (attrs
.at_discr
);
6305 CHECKSUM_ATTR (attrs
.at_discr_list
);
6306 CHECKSUM_ATTR (attrs
.at_discr_value
);
6307 CHECKSUM_ATTR (attrs
.at_encoding
);
6308 CHECKSUM_ATTR (attrs
.at_endianity
);
6309 CHECKSUM_ATTR (attrs
.at_explicit
);
6310 CHECKSUM_ATTR (attrs
.at_is_optional
);
6311 CHECKSUM_ATTR (attrs
.at_location
);
6312 CHECKSUM_ATTR (attrs
.at_lower_bound
);
6313 CHECKSUM_ATTR (attrs
.at_mutable
);
6314 CHECKSUM_ATTR (attrs
.at_ordering
);
6315 CHECKSUM_ATTR (attrs
.at_picture_string
);
6316 CHECKSUM_ATTR (attrs
.at_prototyped
);
6317 CHECKSUM_ATTR (attrs
.at_small
);
6318 CHECKSUM_ATTR (attrs
.at_segment
);
6319 CHECKSUM_ATTR (attrs
.at_string_length
);
6320 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
6321 CHECKSUM_ATTR (attrs
.at_upper_bound
);
6322 CHECKSUM_ATTR (attrs
.at_use_location
);
6323 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
6324 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
6325 CHECKSUM_ATTR (attrs
.at_virtuality
);
6326 CHECKSUM_ATTR (attrs
.at_visibility
);
6327 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
6328 CHECKSUM_ATTR (attrs
.at_type
);
6329 CHECKSUM_ATTR (attrs
.at_friend
);
6331 /* Checksum the child DIEs, except for nested types and member functions. */
6334 dw_attr_ref name_attr
;
6337 name_attr
= get_AT (c
, DW_AT_name
);
6338 if ((is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
)
6339 && name_attr
!= NULL
)
6341 CHECKSUM_ULEB128 ('S');
6342 CHECKSUM_ULEB128 (c
->die_tag
);
6343 CHECKSUM_STRING (AT_string (name_attr
));
6347 /* Mark this DIE so it gets processed when unmarking. */
6348 if (c
->die_mark
== 0)
6350 die_checksum_ordered (c
, ctx
, mark
);
6352 } while (c
!= die
->die_child
);
6354 CHECKSUM_ULEB128 (0);
6358 #undef CHECKSUM_STRING
6359 #undef CHECKSUM_ATTR
6360 #undef CHECKSUM_LEB128
6361 #undef CHECKSUM_ULEB128
6363 /* Generate the type signature for DIE. This is computed by generating an
6364 MD5 checksum over the DIE's tag, its relevant attributes, and its
6365 children. Attributes that are references to other DIEs are processed
6366 by recursion, using the MARK field to prevent infinite recursion.
6367 If the DIE is nested inside a namespace or another type, we also
6368 need to include that context in the signature. The lower 64 bits
6369 of the resulting MD5 checksum comprise the signature. */
6372 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
6376 unsigned char checksum
[16];
6380 name
= get_AT_string (die
, DW_AT_name
);
6381 decl
= get_AT_ref (die
, DW_AT_specification
);
6383 /* First, compute a signature for just the type name (and its surrounding
6384 context, if any. This is stored in the type unit DIE for link-time
6385 ODR (one-definition rule) checking. */
6387 if (is_cxx() && name
!= NULL
)
6389 md5_init_ctx (&ctx
);
6391 /* Checksum the names of surrounding namespaces and structures. */
6392 if (decl
!= NULL
&& decl
->die_parent
!= NULL
)
6393 checksum_die_context (decl
->die_parent
, &ctx
);
6395 md5_process_bytes (&die
->die_tag
, sizeof (die
->die_tag
), &ctx
);
6396 md5_process_bytes (name
, strlen (name
) + 1, &ctx
);
6397 md5_finish_ctx (&ctx
, checksum
);
6399 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
6402 /* Next, compute the complete type signature. */
6404 md5_init_ctx (&ctx
);
6406 die
->die_mark
= mark
;
6408 /* Checksum the names of surrounding namespaces and structures. */
6409 if (decl
!= NULL
&& decl
->die_parent
!= NULL
)
6410 checksum_die_context (decl
->die_parent
, &ctx
);
6412 /* Checksum the DIE and its children. */
6413 die_checksum_ordered (die
, &ctx
, &mark
);
6414 unmark_all_dies (die
);
6415 md5_finish_ctx (&ctx
, checksum
);
6417 /* Store the signature in the type node and link the type DIE and the
6418 type node together. */
6419 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
6420 DWARF_TYPE_SIGNATURE_SIZE
);
6421 die
->die_id
.die_type_node
= type_node
;
6422 type_node
->type_die
= die
;
6424 /* If the DIE is a specification, link its declaration to the type node
6427 decl
->die_id
.die_type_node
= type_node
;
6430 /* Do the location expressions look same? */
6432 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
6434 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
6435 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
6436 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
6439 /* Do the values look the same? */
6441 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
6443 dw_loc_descr_ref loc1
, loc2
;
6446 if (v1
->val_class
!= v2
->val_class
)
6449 switch (v1
->val_class
)
6451 case dw_val_class_const
:
6452 return v1
->v
.val_int
== v2
->v
.val_int
;
6453 case dw_val_class_unsigned_const
:
6454 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
6455 case dw_val_class_const_double
:
6456 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
6457 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
6458 case dw_val_class_vec
:
6459 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
6460 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
6462 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
6463 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
6466 case dw_val_class_flag
:
6467 return v1
->v
.val_flag
== v2
->v
.val_flag
;
6468 case dw_val_class_str
:
6469 return !strcmp(v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
6471 case dw_val_class_addr
:
6472 r1
= v1
->v
.val_addr
;
6473 r2
= v2
->v
.val_addr
;
6474 if (GET_CODE (r1
) != GET_CODE (r2
))
6476 return !rtx_equal_p (r1
, r2
);
6478 case dw_val_class_offset
:
6479 return v1
->v
.val_offset
== v2
->v
.val_offset
;
6481 case dw_val_class_loc
:
6482 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
6484 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
6485 if (!same_loc_p (loc1
, loc2
, mark
))
6487 return !loc1
&& !loc2
;
6489 case dw_val_class_die_ref
:
6490 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
6492 case dw_val_class_fde_ref
:
6493 case dw_val_class_vms_delta
:
6494 case dw_val_class_lbl_id
:
6495 case dw_val_class_lineptr
:
6496 case dw_val_class_macptr
:
6499 case dw_val_class_file
:
6500 return v1
->v
.val_file
== v2
->v
.val_file
;
6502 case dw_val_class_data8
:
6503 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
6510 /* Do the attributes look the same? */
6513 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
6515 if (at1
->dw_attr
!= at2
->dw_attr
)
6518 /* We don't care that this was compiled with a different compiler
6519 snapshot; if the output is the same, that's what matters. */
6520 if (at1
->dw_attr
== DW_AT_producer
)
6523 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
6526 /* Do the dies look the same? */
6529 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
6535 /* To avoid infinite recursion. */
6537 return die1
->die_mark
== die2
->die_mark
;
6538 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
6540 if (die1
->die_tag
!= die2
->die_tag
)
6543 if (VEC_length (dw_attr_node
, die1
->die_attr
)
6544 != VEC_length (dw_attr_node
, die2
->die_attr
))
6547 FOR_EACH_VEC_ELT (dw_attr_node
, die1
->die_attr
, ix
, a1
)
6548 if (!same_attr_p (a1
, VEC_index (dw_attr_node
, die2
->die_attr
, ix
), mark
))
6551 c1
= die1
->die_child
;
6552 c2
= die2
->die_child
;
6561 if (!same_die_p (c1
, c2
, mark
))
6565 if (c1
== die1
->die_child
)
6567 if (c2
== die2
->die_child
)
6577 /* Do the dies look the same? Wrapper around same_die_p. */
6580 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
6583 int ret
= same_die_p (die1
, die2
, &mark
);
6585 unmark_all_dies (die1
);
6586 unmark_all_dies (die2
);
6591 /* The prefix to attach to symbols on DIEs in the current comdat debug
6593 static char *comdat_symbol_id
;
6595 /* The index of the current symbol within the current comdat CU. */
6596 static unsigned int comdat_symbol_number
;
6598 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6599 children, and set comdat_symbol_id accordingly. */
6602 compute_section_prefix (dw_die_ref unit_die
)
6604 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
6605 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
6606 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
6609 unsigned char checksum
[16];
6612 /* Compute the checksum of the DIE, then append part of it as hex digits to
6613 the name filename of the unit. */
6615 md5_init_ctx (&ctx
);
6617 die_checksum (unit_die
, &ctx
, &mark
);
6618 unmark_all_dies (unit_die
);
6619 md5_finish_ctx (&ctx
, checksum
);
6621 sprintf (name
, "%s.", base
);
6622 clean_symbol_name (name
);
6624 p
= name
+ strlen (name
);
6625 for (i
= 0; i
< 4; i
++)
6627 sprintf (p
, "%.2x", checksum
[i
]);
6631 comdat_symbol_id
= unit_die
->die_id
.die_symbol
= xstrdup (name
);
6632 comdat_symbol_number
= 0;
6635 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6638 is_type_die (dw_die_ref die
)
6640 switch (die
->die_tag
)
6642 case DW_TAG_array_type
:
6643 case DW_TAG_class_type
:
6644 case DW_TAG_interface_type
:
6645 case DW_TAG_enumeration_type
:
6646 case DW_TAG_pointer_type
:
6647 case DW_TAG_reference_type
:
6648 case DW_TAG_rvalue_reference_type
:
6649 case DW_TAG_string_type
:
6650 case DW_TAG_structure_type
:
6651 case DW_TAG_subroutine_type
:
6652 case DW_TAG_union_type
:
6653 case DW_TAG_ptr_to_member_type
:
6654 case DW_TAG_set_type
:
6655 case DW_TAG_subrange_type
:
6656 case DW_TAG_base_type
:
6657 case DW_TAG_const_type
:
6658 case DW_TAG_file_type
:
6659 case DW_TAG_packed_type
:
6660 case DW_TAG_volatile_type
:
6661 case DW_TAG_typedef
:
6668 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6669 Basically, we want to choose the bits that are likely to be shared between
6670 compilations (types) and leave out the bits that are specific to individual
6671 compilations (functions). */
6674 is_comdat_die (dw_die_ref c
)
6676 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6677 we do for stabs. The advantage is a greater likelihood of sharing between
6678 objects that don't include headers in the same order (and therefore would
6679 put the base types in a different comdat). jason 8/28/00 */
6681 if (c
->die_tag
== DW_TAG_base_type
)
6684 if (c
->die_tag
== DW_TAG_pointer_type
6685 || c
->die_tag
== DW_TAG_reference_type
6686 || c
->die_tag
== DW_TAG_rvalue_reference_type
6687 || c
->die_tag
== DW_TAG_const_type
6688 || c
->die_tag
== DW_TAG_volatile_type
)
6690 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
6692 return t
? is_comdat_die (t
) : 0;
6695 return is_type_die (c
);
6698 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6699 compilation unit. */
6702 is_symbol_die (dw_die_ref c
)
6704 return (is_type_die (c
)
6705 || is_declaration_die (c
)
6706 || c
->die_tag
== DW_TAG_namespace
6707 || c
->die_tag
== DW_TAG_module
);
6710 /* Returns true iff C is a compile-unit DIE. */
6713 is_cu_die (dw_die_ref c
)
6715 return c
&& c
->die_tag
== DW_TAG_compile_unit
;
6719 gen_internal_sym (const char *prefix
)
6723 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
6724 return xstrdup (buf
);
6727 /* Assign symbols to all worthy DIEs under DIE. */
6730 assign_symbol_names (dw_die_ref die
)
6734 if (is_symbol_die (die
))
6736 if (comdat_symbol_id
)
6738 char *p
= XALLOCAVEC (char, strlen (comdat_symbol_id
) + 64);
6740 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
6741 comdat_symbol_id
, comdat_symbol_number
++);
6742 die
->die_id
.die_symbol
= xstrdup (p
);
6745 die
->die_id
.die_symbol
= gen_internal_sym ("LDIE");
6748 FOR_EACH_CHILD (die
, c
, assign_symbol_names (c
));
6751 struct cu_hash_table_entry
6754 unsigned min_comdat_num
, max_comdat_num
;
6755 struct cu_hash_table_entry
*next
;
6758 /* Routines to manipulate hash table of CUs. */
6760 htab_cu_hash (const void *of
)
6762 const struct cu_hash_table_entry
*const entry
=
6763 (const struct cu_hash_table_entry
*) of
;
6765 return htab_hash_string (entry
->cu
->die_id
.die_symbol
);
6769 htab_cu_eq (const void *of1
, const void *of2
)
6771 const struct cu_hash_table_entry
*const entry1
=
6772 (const struct cu_hash_table_entry
*) of1
;
6773 const struct die_struct
*const entry2
= (const struct die_struct
*) of2
;
6775 return !strcmp (entry1
->cu
->die_id
.die_symbol
, entry2
->die_id
.die_symbol
);
6779 htab_cu_del (void *what
)
6781 struct cu_hash_table_entry
*next
,
6782 *entry
= (struct cu_hash_table_entry
*) what
;
6792 /* Check whether we have already seen this CU and set up SYM_NUM
6795 check_duplicate_cu (dw_die_ref cu
, htab_t htable
, unsigned int *sym_num
)
6797 struct cu_hash_table_entry dummy
;
6798 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
6800 dummy
.max_comdat_num
= 0;
6802 slot
= (struct cu_hash_table_entry
**)
6803 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_id
.die_symbol
),
6807 for (; entry
; last
= entry
, entry
= entry
->next
)
6809 if (same_die_p_wrap (cu
, entry
->cu
))
6815 *sym_num
= entry
->min_comdat_num
;
6819 entry
= XCNEW (struct cu_hash_table_entry
);
6821 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
6822 entry
->next
= *slot
;
6828 /* Record SYM_NUM to record of CU in HTABLE. */
6830 record_comdat_symbol_number (dw_die_ref cu
, htab_t htable
, unsigned int sym_num
)
6832 struct cu_hash_table_entry
**slot
, *entry
;
6834 slot
= (struct cu_hash_table_entry
**)
6835 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_id
.die_symbol
),
6839 entry
->max_comdat_num
= sym_num
;
6842 /* Traverse the DIE (which is always comp_unit_die), and set up
6843 additional compilation units for each of the include files we see
6844 bracketed by BINCL/EINCL. */
6847 break_out_includes (dw_die_ref die
)
6850 dw_die_ref unit
= NULL
;
6851 limbo_die_node
*node
, **pnode
;
6852 htab_t cu_hash_table
;
6856 dw_die_ref prev
= c
;
6858 while (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
6859 || (unit
&& is_comdat_die (c
)))
6861 dw_die_ref next
= c
->die_sib
;
6863 /* This DIE is for a secondary CU; remove it from the main one. */
6864 remove_child_with_prev (c
, prev
);
6866 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
6867 unit
= push_new_compile_unit (unit
, c
);
6868 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
6869 unit
= pop_compile_unit (unit
);
6871 add_child_die (unit
, c
);
6873 if (c
== die
->die_child
)
6876 } while (c
!= die
->die_child
);
6879 /* We can only use this in debugging, since the frontend doesn't check
6880 to make sure that we leave every include file we enter. */
6884 assign_symbol_names (die
);
6885 cu_hash_table
= htab_create (10, htab_cu_hash
, htab_cu_eq
, htab_cu_del
);
6886 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
6892 compute_section_prefix (node
->die
);
6893 is_dupl
= check_duplicate_cu (node
->die
, cu_hash_table
,
6894 &comdat_symbol_number
);
6895 assign_symbol_names (node
->die
);
6897 *pnode
= node
->next
;
6900 pnode
= &node
->next
;
6901 record_comdat_symbol_number (node
->die
, cu_hash_table
,
6902 comdat_symbol_number
);
6905 htab_delete (cu_hash_table
);
6908 /* Return non-zero if this DIE is a declaration. */
6911 is_declaration_die (dw_die_ref die
)
6916 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
6917 if (a
->dw_attr
== DW_AT_declaration
)
6923 /* Return non-zero if this DIE is nested inside a subprogram. */
6926 is_nested_in_subprogram (dw_die_ref die
)
6928 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
6932 return local_scope_p (decl
);
6935 /* Return non-zero if this DIE contains a defining declaration of a
6939 contains_subprogram_definition (dw_die_ref die
)
6943 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
6945 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition(c
)) return 1);
6949 /* Return non-zero if this is a type DIE that should be moved to a
6950 COMDAT .debug_types section. */
6953 should_move_die_to_comdat (dw_die_ref die
)
6955 switch (die
->die_tag
)
6957 case DW_TAG_class_type
:
6958 case DW_TAG_structure_type
:
6959 case DW_TAG_enumeration_type
:
6960 case DW_TAG_union_type
:
6961 /* Don't move declarations, inlined instances, or types nested in a
6963 if (is_declaration_die (die
)
6964 || get_AT (die
, DW_AT_abstract_origin
)
6965 || is_nested_in_subprogram (die
))
6967 /* A type definition should never contain a subprogram definition. */
6968 gcc_assert (!contains_subprogram_definition (die
));
6970 case DW_TAG_array_type
:
6971 case DW_TAG_interface_type
:
6972 case DW_TAG_pointer_type
:
6973 case DW_TAG_reference_type
:
6974 case DW_TAG_rvalue_reference_type
:
6975 case DW_TAG_string_type
:
6976 case DW_TAG_subroutine_type
:
6977 case DW_TAG_ptr_to_member_type
:
6978 case DW_TAG_set_type
:
6979 case DW_TAG_subrange_type
:
6980 case DW_TAG_base_type
:
6981 case DW_TAG_const_type
:
6982 case DW_TAG_file_type
:
6983 case DW_TAG_packed_type
:
6984 case DW_TAG_volatile_type
:
6985 case DW_TAG_typedef
:
6991 /* Make a clone of DIE. */
6994 clone_die (dw_die_ref die
)
7000 clone
= ggc_alloc_cleared_die_node ();
7001 clone
->die_tag
= die
->die_tag
;
7003 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
7004 add_dwarf_attr (clone
, a
);
7009 /* Make a clone of the tree rooted at DIE. */
7012 clone_tree (dw_die_ref die
)
7015 dw_die_ref clone
= clone_die (die
);
7017 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree(c
)));
7022 /* Make a clone of DIE as a declaration. */
7025 clone_as_declaration (dw_die_ref die
)
7032 /* If the DIE is already a declaration, just clone it. */
7033 if (is_declaration_die (die
))
7034 return clone_die (die
);
7036 /* If the DIE is a specification, just clone its declaration DIE. */
7037 decl
= get_AT_ref (die
, DW_AT_specification
);
7039 return clone_die (decl
);
7041 clone
= ggc_alloc_cleared_die_node ();
7042 clone
->die_tag
= die
->die_tag
;
7044 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
7046 /* We don't want to copy over all attributes.
7047 For example we don't want DW_AT_byte_size because otherwise we will no
7048 longer have a declaration and GDB will treat it as a definition. */
7052 case DW_AT_artificial
:
7053 case DW_AT_containing_type
:
7054 case DW_AT_external
:
7057 case DW_AT_virtuality
:
7058 case DW_AT_linkage_name
:
7059 case DW_AT_MIPS_linkage_name
:
7060 add_dwarf_attr (clone
, a
);
7062 case DW_AT_byte_size
:
7068 if (die
->die_id
.die_type_node
)
7069 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7071 add_AT_flag (clone
, DW_AT_declaration
, 1);
7075 /* Copy the declaration context to the new type unit DIE. This includes
7076 any surrounding namespace or type declarations. If the DIE has an
7077 AT_specification attribute, it also includes attributes and children
7078 attached to the specification, and returns a pointer to the original
7079 parent of the declaration DIE. Returns NULL otherwise. */
7082 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
7085 dw_die_ref new_decl
;
7086 dw_die_ref orig_parent
= NULL
;
7088 decl
= get_AT_ref (die
, DW_AT_specification
);
7097 /* The original DIE will be changed to a declaration, and must
7098 be moved to be a child of the original declaration DIE. */
7099 orig_parent
= decl
->die_parent
;
7101 /* Copy the type node pointer from the new DIE to the original
7102 declaration DIE so we can forward references later. */
7103 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
7105 remove_AT (die
, DW_AT_specification
);
7107 FOR_EACH_VEC_ELT (dw_attr_node
, decl
->die_attr
, ix
, a
)
7109 if (a
->dw_attr
!= DW_AT_name
7110 && a
->dw_attr
!= DW_AT_declaration
7111 && a
->dw_attr
!= DW_AT_external
)
7112 add_dwarf_attr (die
, a
);
7115 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree(c
)));
7118 if (decl
->die_parent
!= NULL
7119 && decl
->die_parent
->die_tag
!= DW_TAG_compile_unit
7120 && decl
->die_parent
->die_tag
!= DW_TAG_type_unit
)
7122 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
7123 if (new_decl
!= NULL
)
7125 remove_AT (new_decl
, DW_AT_signature
);
7126 add_AT_specification (die
, new_decl
);
7133 /* Generate the skeleton ancestor tree for the given NODE, then clone
7134 the DIE and add the clone into the tree. */
7137 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
7139 if (node
->new_die
!= NULL
)
7142 node
->new_die
= clone_as_declaration (node
->old_die
);
7144 if (node
->parent
!= NULL
)
7146 generate_skeleton_ancestor_tree (node
->parent
);
7147 add_child_die (node
->parent
->new_die
, node
->new_die
);
7151 /* Generate a skeleton tree of DIEs containing any declarations that are
7152 found in the original tree. We traverse the tree looking for declaration
7153 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7156 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
7158 skeleton_chain_node node
;
7161 dw_die_ref prev
= NULL
;
7162 dw_die_ref next
= NULL
;
7164 node
.parent
= parent
;
7166 first
= c
= parent
->old_die
->die_child
;
7170 if (prev
== NULL
|| prev
->die_sib
== c
)
7173 next
= (c
== first
? NULL
: c
->die_sib
);
7175 node
.new_die
= NULL
;
7176 if (is_declaration_die (c
))
7178 /* Clone the existing DIE, move the original to the skeleton
7179 tree (which is in the main CU), and put the clone, with
7180 all the original's children, where the original came from. */
7181 dw_die_ref clone
= clone_die (c
);
7182 move_all_children (c
, clone
);
7184 replace_child (c
, clone
, prev
);
7185 generate_skeleton_ancestor_tree (parent
);
7186 add_child_die (parent
->new_die
, c
);
7190 generate_skeleton_bottom_up (&node
);
7191 } while (next
!= NULL
);
7194 /* Wrapper function for generate_skeleton_bottom_up. */
7197 generate_skeleton (dw_die_ref die
)
7199 skeleton_chain_node node
;
7202 node
.new_die
= NULL
;
7205 /* If this type definition is nested inside another type,
7206 always leave at least a declaration in its place. */
7207 if (die
->die_parent
!= NULL
&& is_type_die (die
->die_parent
))
7208 node
.new_die
= clone_as_declaration (die
);
7210 generate_skeleton_bottom_up (&node
);
7211 return node
.new_die
;
7214 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7215 declaration. The original DIE is moved to a new compile unit so that
7216 existing references to it follow it to the new location. If any of the
7217 original DIE's descendants is a declaration, we need to replace the
7218 original DIE with a skeleton tree and move the declarations back into the
7222 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
7225 dw_die_ref skeleton
, orig_parent
;
7227 /* Copy the declaration context to the type unit DIE. If the returned
7228 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7230 orig_parent
= copy_declaration_context (unit
, child
);
7232 skeleton
= generate_skeleton (child
);
7233 if (skeleton
== NULL
)
7234 remove_child_with_prev (child
, prev
);
7237 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
7239 /* If the original DIE was a specification, we need to put
7240 the skeleton under the parent DIE of the declaration.
7241 This leaves the original declaration in the tree, but
7242 it will be pruned later since there are no longer any
7243 references to it. */
7244 if (orig_parent
!= NULL
)
7246 remove_child_with_prev (child
, prev
);
7247 add_child_die (orig_parent
, skeleton
);
7250 replace_child (child
, skeleton
, prev
);
7256 /* Traverse the DIE and set up additional .debug_types sections for each
7257 type worthy of being placed in a COMDAT section. */
7260 break_out_comdat_types (dw_die_ref die
)
7264 dw_die_ref prev
= NULL
;
7265 dw_die_ref next
= NULL
;
7266 dw_die_ref unit
= NULL
;
7268 first
= c
= die
->die_child
;
7272 if (prev
== NULL
|| prev
->die_sib
== c
)
7275 next
= (c
== first
? NULL
: c
->die_sib
);
7276 if (should_move_die_to_comdat (c
))
7278 dw_die_ref replacement
;
7279 comdat_type_node_ref type_node
;
7281 /* Create a new type unit DIE as the root for the new tree, and
7282 add it to the list of comdat types. */
7283 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
7284 add_AT_unsigned (unit
, DW_AT_language
,
7285 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
7286 type_node
= ggc_alloc_cleared_comdat_type_node ();
7287 type_node
->root_die
= unit
;
7288 type_node
->next
= comdat_type_list
;
7289 comdat_type_list
= type_node
;
7291 /* Generate the type signature. */
7292 generate_type_signature (c
, type_node
);
7294 /* Copy the declaration context, attributes, and children of the
7295 declaration into the new type unit DIE, then remove this DIE
7296 from the main CU (or replace it with a skeleton if necessary). */
7297 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
7299 /* Break out nested types into their own type units. */
7300 break_out_comdat_types (c
);
7302 /* Add the DIE to the new compunit. */
7303 add_child_die (unit
, c
);
7305 if (replacement
!= NULL
)
7308 else if (c
->die_tag
== DW_TAG_namespace
7309 || c
->die_tag
== DW_TAG_class_type
7310 || c
->die_tag
== DW_TAG_structure_type
7311 || c
->die_tag
== DW_TAG_union_type
)
7313 /* Look for nested types that can be broken out. */
7314 break_out_comdat_types (c
);
7316 } while (next
!= NULL
);
7319 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7321 struct decl_table_entry
7327 /* Routines to manipulate hash table of copied declarations. */
7330 htab_decl_hash (const void *of
)
7332 const struct decl_table_entry
*const entry
=
7333 (const struct decl_table_entry
*) of
;
7335 return htab_hash_pointer (entry
->orig
);
7339 htab_decl_eq (const void *of1
, const void *of2
)
7341 const struct decl_table_entry
*const entry1
=
7342 (const struct decl_table_entry
*) of1
;
7343 const struct die_struct
*const entry2
= (const struct die_struct
*) of2
;
7345 return entry1
->orig
== entry2
;
7349 htab_decl_del (void *what
)
7351 struct decl_table_entry
*entry
= (struct decl_table_entry
*) what
;
7356 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7357 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7358 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7359 to check if the ancestor has already been copied into UNIT. */
7362 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
, htab_t decl_table
)
7364 dw_die_ref parent
= die
->die_parent
;
7365 dw_die_ref new_parent
= unit
;
7368 struct decl_table_entry
*entry
= NULL
;
7372 /* Check if the entry has already been copied to UNIT. */
7373 slot
= htab_find_slot_with_hash (decl_table
, die
,
7374 htab_hash_pointer (die
), INSERT
);
7375 if (*slot
!= HTAB_EMPTY_ENTRY
)
7377 entry
= (struct decl_table_entry
*) *slot
;
7381 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7382 entry
= XCNEW (struct decl_table_entry
);
7390 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
7393 if (parent
->die_tag
!= DW_TAG_compile_unit
7394 && parent
->die_tag
!= DW_TAG_type_unit
)
7395 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
7398 copy
= clone_as_declaration (die
);
7399 add_child_die (new_parent
, copy
);
7401 if (decl_table
!= NULL
)
7403 /* Record the pointer to the copy. */
7410 /* Like clone_tree, but additionally enter all the children into
7411 the hash table decl_table. */
7414 clone_tree_hash (dw_die_ref die
, htab_t decl_table
)
7417 dw_die_ref clone
= clone_die (die
);
7418 struct decl_table_entry
*entry
;
7419 void **slot
= htab_find_slot_with_hash (decl_table
, die
,
7420 htab_hash_pointer (die
), INSERT
);
7421 /* Assert that DIE isn't in the hash table yet. If it would be there
7422 before, the ancestors would be necessarily there as well, therefore
7423 clone_tree_hash wouldn't be called. */
7424 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
7425 entry
= XCNEW (struct decl_table_entry
);
7427 entry
->copy
= clone
;
7430 FOR_EACH_CHILD (die
, c
,
7431 add_child_die (clone
, clone_tree_hash (c
, decl_table
)));
7436 /* Walk the DIE and its children, looking for references to incomplete
7437 or trivial types that are unmarked (i.e., that are not in the current
7441 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, htab_t decl_table
)
7447 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
7449 if (AT_class (a
) == dw_val_class_die_ref
)
7451 dw_die_ref targ
= AT_ref (a
);
7452 comdat_type_node_ref type_node
= targ
->die_id
.die_type_node
;
7454 struct decl_table_entry
*entry
;
7456 if (targ
->die_mark
!= 0 || type_node
!= NULL
)
7459 slot
= htab_find_slot_with_hash (decl_table
, targ
,
7460 htab_hash_pointer (targ
), INSERT
);
7462 if (*slot
!= HTAB_EMPTY_ENTRY
)
7464 /* TARG has already been copied, so we just need to
7465 modify the reference to point to the copy. */
7466 entry
= (struct decl_table_entry
*) *slot
;
7467 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
7471 dw_die_ref parent
= unit
;
7472 dw_die_ref copy
= clone_die (targ
);
7474 /* Record in DECL_TABLE that TARG has been copied.
7475 Need to do this now, before the recursive call,
7476 because DECL_TABLE may be expanded and SLOT
7477 would no longer be a valid pointer. */
7478 entry
= XCNEW (struct decl_table_entry
);
7483 FOR_EACH_CHILD (targ
, c
,
7484 add_child_die (copy
,
7485 clone_tree_hash (c
, decl_table
)));
7487 /* Make sure the cloned tree is marked as part of the
7491 /* If TARG has surrounding context, copy its ancestor tree
7492 into the new type unit. */
7493 if (targ
->die_parent
!= NULL
7494 && targ
->die_parent
->die_tag
!= DW_TAG_compile_unit
7495 && targ
->die_parent
->die_tag
!= DW_TAG_type_unit
)
7496 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
7499 add_child_die (parent
, copy
);
7500 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
7502 /* Make sure the newly-copied DIE is walked. If it was
7503 installed in a previously-added context, it won't
7504 get visited otherwise. */
7507 /* Find the highest point of the newly-added tree,
7508 mark each node along the way, and walk from there. */
7509 parent
->die_mark
= 1;
7510 while (parent
->die_parent
7511 && parent
->die_parent
->die_mark
== 0)
7513 parent
= parent
->die_parent
;
7514 parent
->die_mark
= 1;
7516 copy_decls_walk (unit
, parent
, decl_table
);
7522 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
7525 /* Copy declarations for "unworthy" types into the new comdat section.
7526 Incomplete types, modified types, and certain other types aren't broken
7527 out into comdat sections of their own, so they don't have a signature,
7528 and we need to copy the declaration into the same section so that we
7529 don't have an external reference. */
7532 copy_decls_for_unworthy_types (dw_die_ref unit
)
7537 decl_table
= htab_create (10, htab_decl_hash
, htab_decl_eq
, htab_decl_del
);
7538 copy_decls_walk (unit
, unit
, decl_table
);
7539 htab_delete (decl_table
);
7543 /* Traverse the DIE and add a sibling attribute if it may have the
7544 effect of speeding up access to siblings. To save some space,
7545 avoid generating sibling attributes for DIE's without children. */
7548 add_sibling_attributes (dw_die_ref die
)
7552 if (! die
->die_child
)
7555 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
7556 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
7558 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
7561 /* Output all location lists for the DIE and its children. */
7564 output_location_lists (dw_die_ref die
)
7570 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
7571 if (AT_class (a
) == dw_val_class_loc_list
)
7572 output_loc_list (AT_loc_list (a
));
7574 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
7577 /* The format of each DIE (and its attribute value pairs) is encoded in an
7578 abbreviation table. This routine builds the abbreviation table and assigns
7579 a unique abbreviation id for each abbreviation entry. The children of each
7580 die are visited recursively. */
7583 build_abbrev_table (dw_die_ref die
)
7585 unsigned long abbrev_id
;
7586 unsigned int n_alloc
;
7591 /* Scan the DIE references, and mark as external any that refer to
7592 DIEs from other CUs (i.e. those which are not marked). */
7593 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
7594 if (AT_class (a
) == dw_val_class_die_ref
7595 && AT_ref (a
)->die_mark
== 0)
7597 gcc_assert (use_debug_types
|| AT_ref (a
)->die_id
.die_symbol
);
7598 set_AT_ref_external (a
, 1);
7601 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
7603 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
7604 dw_attr_ref die_a
, abbrev_a
;
7608 if (abbrev
->die_tag
!= die
->die_tag
)
7610 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
7613 if (VEC_length (dw_attr_node
, abbrev
->die_attr
)
7614 != VEC_length (dw_attr_node
, die
->die_attr
))
7617 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, die_a
)
7619 abbrev_a
= VEC_index (dw_attr_node
, abbrev
->die_attr
, ix
);
7620 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
7621 || (value_format (abbrev_a
) != value_format (die_a
)))
7631 if (abbrev_id
>= abbrev_die_table_in_use
)
7633 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
7635 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
7636 abbrev_die_table
= GGC_RESIZEVEC (dw_die_ref
, abbrev_die_table
,
7639 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
7640 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
7641 abbrev_die_table_allocated
= n_alloc
;
7644 ++abbrev_die_table_in_use
;
7645 abbrev_die_table
[abbrev_id
] = die
;
7648 die
->die_abbrev
= abbrev_id
;
7649 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
));
7652 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7655 constant_size (unsigned HOST_WIDE_INT value
)
7662 log
= floor_log2 (value
);
7665 log
= 1 << (floor_log2 (log
) + 1);
7670 /* Return the size of a DIE as it is represented in the
7671 .debug_info section. */
7673 static unsigned long
7674 size_of_die (dw_die_ref die
)
7676 unsigned long size
= 0;
7680 size
+= size_of_uleb128 (die
->die_abbrev
);
7681 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
7683 switch (AT_class (a
))
7685 case dw_val_class_addr
:
7686 size
+= DWARF2_ADDR_SIZE
;
7688 case dw_val_class_offset
:
7689 size
+= DWARF_OFFSET_SIZE
;
7691 case dw_val_class_loc
:
7693 unsigned long lsize
= size_of_locs (AT_loc (a
));
7696 if (dwarf_version
>= 4)
7697 size
+= size_of_uleb128 (lsize
);
7699 size
+= constant_size (lsize
);
7703 case dw_val_class_loc_list
:
7704 size
+= DWARF_OFFSET_SIZE
;
7706 case dw_val_class_range_list
:
7707 size
+= DWARF_OFFSET_SIZE
;
7709 case dw_val_class_const
:
7710 size
+= size_of_sleb128 (AT_int (a
));
7712 case dw_val_class_unsigned_const
:
7714 int csize
= constant_size (AT_unsigned (a
));
7715 if (dwarf_version
== 3
7716 && a
->dw_attr
== DW_AT_data_member_location
7718 size
+= size_of_uleb128 (AT_unsigned (a
));
7723 case dw_val_class_const_double
:
7724 size
+= 2 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
7725 if (HOST_BITS_PER_WIDE_INT
>= 64)
7728 case dw_val_class_vec
:
7729 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
7730 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
7731 + a
->dw_attr_val
.v
.val_vec
.length
7732 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
7734 case dw_val_class_flag
:
7735 if (dwarf_version
>= 4)
7736 /* Currently all add_AT_flag calls pass in 1 as last argument,
7737 so DW_FORM_flag_present can be used. If that ever changes,
7738 we'll need to use DW_FORM_flag and have some optimization
7739 in build_abbrev_table that will change those to
7740 DW_FORM_flag_present if it is set to 1 in all DIEs using
7741 the same abbrev entry. */
7742 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
7746 case dw_val_class_die_ref
:
7747 if (AT_ref_external (a
))
7749 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
7750 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
7751 is sized by target address length, whereas in DWARF3
7752 it's always sized as an offset. */
7753 if (use_debug_types
)
7754 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
7755 else if (dwarf_version
== 2)
7756 size
+= DWARF2_ADDR_SIZE
;
7758 size
+= DWARF_OFFSET_SIZE
;
7761 size
+= DWARF_OFFSET_SIZE
;
7763 case dw_val_class_fde_ref
:
7764 size
+= DWARF_OFFSET_SIZE
;
7766 case dw_val_class_lbl_id
:
7767 size
+= DWARF2_ADDR_SIZE
;
7769 case dw_val_class_lineptr
:
7770 case dw_val_class_macptr
:
7771 size
+= DWARF_OFFSET_SIZE
;
7773 case dw_val_class_str
:
7774 if (AT_string_form (a
) == DW_FORM_strp
)
7775 size
+= DWARF_OFFSET_SIZE
;
7777 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
7779 case dw_val_class_file
:
7780 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
7782 case dw_val_class_data8
:
7785 case dw_val_class_vms_delta
:
7786 size
+= DWARF_OFFSET_SIZE
;
7796 /* Size the debugging information associated with a given DIE. Visits the
7797 DIE's children recursively. Updates the global variable next_die_offset, on
7798 each time through. Uses the current value of next_die_offset to update the
7799 die_offset field in each DIE. */
7802 calc_die_sizes (dw_die_ref die
)
7806 gcc_assert (die
->die_offset
== 0
7807 || (unsigned long int) die
->die_offset
== next_die_offset
);
7808 die
->die_offset
= next_die_offset
;
7809 next_die_offset
+= size_of_die (die
);
7811 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
7813 if (die
->die_child
!= NULL
)
7814 /* Count the null byte used to terminate sibling lists. */
7815 next_die_offset
+= 1;
7818 /* Size just the base type children at the start of the CU.
7819 This is needed because build_abbrev needs to size locs
7820 and sizing of type based stack ops needs to know die_offset
7821 values for the base types. */
7824 calc_base_type_die_sizes (void)
7826 unsigned long die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
7828 dw_die_ref base_type
;
7829 #if ENABLE_ASSERT_CHECKING
7830 dw_die_ref prev
= comp_unit_die ()->die_child
;
7833 die_offset
+= size_of_die (comp_unit_die ());
7834 for (i
= 0; VEC_iterate (dw_die_ref
, base_types
, i
, base_type
); i
++)
7836 #if ENABLE_ASSERT_CHECKING
7837 gcc_assert (base_type
->die_offset
== 0
7838 && prev
->die_sib
== base_type
7839 && base_type
->die_child
== NULL
7840 && base_type
->die_abbrev
);
7843 base_type
->die_offset
= die_offset
;
7844 die_offset
+= size_of_die (base_type
);
7848 /* Set the marks for a die and its children. We do this so
7849 that we know whether or not a reference needs to use FORM_ref_addr; only
7850 DIEs in the same CU will be marked. We used to clear out the offset
7851 and use that as the flag, but ran into ordering problems. */
7854 mark_dies (dw_die_ref die
)
7858 gcc_assert (!die
->die_mark
);
7861 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
7864 /* Clear the marks for a die and its children. */
7867 unmark_dies (dw_die_ref die
)
7871 if (! use_debug_types
)
7872 gcc_assert (die
->die_mark
);
7875 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
7878 /* Clear the marks for a die, its children and referred dies. */
7881 unmark_all_dies (dw_die_ref die
)
7891 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
7893 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
7894 if (AT_class (a
) == dw_val_class_die_ref
)
7895 unmark_all_dies (AT_ref (a
));
7898 /* Return the size of the .debug_pubnames or .debug_pubtypes table
7899 generated for the compilation unit. */
7901 static unsigned long
7902 size_of_pubnames (VEC (pubname_entry
, gc
) * names
)
7908 size
= DWARF_PUBNAMES_HEADER_SIZE
;
7909 FOR_EACH_VEC_ELT (pubname_entry
, names
, i
, p
)
7910 if (names
!= pubtype_table
7911 || p
->die
->die_offset
!= 0
7912 || !flag_eliminate_unused_debug_types
)
7913 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1;
7915 size
+= DWARF_OFFSET_SIZE
;
7919 /* Return the size of the information in the .debug_aranges section. */
7921 static unsigned long
7922 size_of_aranges (void)
7926 size
= DWARF_ARANGES_HEADER_SIZE
;
7928 /* Count the address/length pair for this compilation unit. */
7929 if (text_section_used
)
7930 size
+= 2 * DWARF2_ADDR_SIZE
;
7931 if (cold_text_section_used
)
7932 size
+= 2 * DWARF2_ADDR_SIZE
;
7933 if (have_multiple_function_sections
)
7938 FOR_EACH_VEC_ELT (dw_fde_ref
, fde_vec
, fde_idx
, fde
)
7940 if (!fde
->in_std_section
)
7941 size
+= 2 * DWARF2_ADDR_SIZE
;
7942 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
7943 size
+= 2 * DWARF2_ADDR_SIZE
;
7947 /* Count the two zero words used to terminated the address range table. */
7948 size
+= 2 * DWARF2_ADDR_SIZE
;
7952 /* Select the encoding of an attribute value. */
7954 static enum dwarf_form
7955 value_format (dw_attr_ref a
)
7957 switch (a
->dw_attr_val
.val_class
)
7959 case dw_val_class_addr
:
7960 /* Only very few attributes allow DW_FORM_addr. */
7965 case DW_AT_entry_pc
:
7966 case DW_AT_trampoline
:
7967 return DW_FORM_addr
;
7971 switch (DWARF2_ADDR_SIZE
)
7974 return DW_FORM_data1
;
7976 return DW_FORM_data2
;
7978 return DW_FORM_data4
;
7980 return DW_FORM_data8
;
7984 case dw_val_class_range_list
:
7985 case dw_val_class_loc_list
:
7986 if (dwarf_version
>= 4)
7987 return DW_FORM_sec_offset
;
7989 case dw_val_class_vms_delta
:
7990 case dw_val_class_offset
:
7991 switch (DWARF_OFFSET_SIZE
)
7994 return DW_FORM_data4
;
7996 return DW_FORM_data8
;
8000 case dw_val_class_loc
:
8001 if (dwarf_version
>= 4)
8002 return DW_FORM_exprloc
;
8003 switch (constant_size (size_of_locs (AT_loc (a
))))
8006 return DW_FORM_block1
;
8008 return DW_FORM_block2
;
8012 case dw_val_class_const
:
8013 return DW_FORM_sdata
;
8014 case dw_val_class_unsigned_const
:
8015 switch (constant_size (AT_unsigned (a
)))
8018 return DW_FORM_data1
;
8020 return DW_FORM_data2
;
8022 /* In DWARF3 DW_AT_data_member_location with
8023 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8024 constant, so we need to use DW_FORM_udata if we need
8025 a large constant. */
8026 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8027 return DW_FORM_udata
;
8028 return DW_FORM_data4
;
8030 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
8031 return DW_FORM_udata
;
8032 return DW_FORM_data8
;
8036 case dw_val_class_const_double
:
8037 switch (HOST_BITS_PER_WIDE_INT
)
8040 return DW_FORM_data2
;
8042 return DW_FORM_data4
;
8044 return DW_FORM_data8
;
8047 return DW_FORM_block1
;
8049 case dw_val_class_vec
:
8050 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
8051 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
8054 return DW_FORM_block1
;
8056 return DW_FORM_block2
;
8058 return DW_FORM_block4
;
8062 case dw_val_class_flag
:
8063 if (dwarf_version
>= 4)
8065 /* Currently all add_AT_flag calls pass in 1 as last argument,
8066 so DW_FORM_flag_present can be used. If that ever changes,
8067 we'll need to use DW_FORM_flag and have some optimization
8068 in build_abbrev_table that will change those to
8069 DW_FORM_flag_present if it is set to 1 in all DIEs using
8070 the same abbrev entry. */
8071 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
8072 return DW_FORM_flag_present
;
8074 return DW_FORM_flag
;
8075 case dw_val_class_die_ref
:
8076 if (AT_ref_external (a
))
8077 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
8080 case dw_val_class_fde_ref
:
8081 return DW_FORM_data
;
8082 case dw_val_class_lbl_id
:
8083 return DW_FORM_addr
;
8084 case dw_val_class_lineptr
:
8085 case dw_val_class_macptr
:
8086 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
8087 case dw_val_class_str
:
8088 return AT_string_form (a
);
8089 case dw_val_class_file
:
8090 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
8093 return DW_FORM_data1
;
8095 return DW_FORM_data2
;
8097 return DW_FORM_data4
;
8102 case dw_val_class_data8
:
8103 return DW_FORM_data8
;
8110 /* Output the encoding of an attribute value. */
8113 output_value_format (dw_attr_ref a
)
8115 enum dwarf_form form
= value_format (a
);
8117 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
8120 /* Output the .debug_abbrev section which defines the DIE abbreviation
8124 output_abbrev_section (void)
8126 unsigned long abbrev_id
;
8128 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
8130 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
8134 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
8135 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
8136 dwarf_tag_name (abbrev
->die_tag
));
8138 if (abbrev
->die_child
!= NULL
)
8139 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
8141 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
8143 for (ix
= 0; VEC_iterate (dw_attr_node
, abbrev
->die_attr
, ix
, a_attr
);
8146 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
8147 dwarf_attr_name (a_attr
->dw_attr
));
8148 output_value_format (a_attr
);
8151 dw2_asm_output_data (1, 0, NULL
);
8152 dw2_asm_output_data (1, 0, NULL
);
8155 /* Terminate the table. */
8156 dw2_asm_output_data (1, 0, NULL
);
8159 /* Output a symbol we can use to refer to this DIE from another CU. */
8162 output_die_symbol (dw_die_ref die
)
8164 char *sym
= die
->die_id
.die_symbol
;
8169 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
8170 /* We make these global, not weak; if the target doesn't support
8171 .linkonce, it doesn't support combining the sections, so debugging
8173 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
8175 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
8178 /* Return a new location list, given the begin and end range, and the
8181 static inline dw_loc_list_ref
8182 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
8183 const char *section
)
8185 dw_loc_list_ref retlist
= ggc_alloc_cleared_dw_loc_list_node ();
8187 retlist
->begin
= begin
;
8189 retlist
->expr
= expr
;
8190 retlist
->section
= section
;
8195 /* Generate a new internal symbol for this location list node, if it
8196 hasn't got one yet. */
8199 gen_llsym (dw_loc_list_ref list
)
8201 gcc_assert (!list
->ll_symbol
);
8202 list
->ll_symbol
= gen_internal_sym ("LLST");
8205 /* Output the location list given to us. */
8208 output_loc_list (dw_loc_list_ref list_head
)
8210 dw_loc_list_ref curr
= list_head
;
8212 if (list_head
->emitted
)
8214 list_head
->emitted
= true;
8216 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
8218 /* Walk the location list, and output each range + expression. */
8219 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
8222 /* Don't output an entry that starts and ends at the same address. */
8223 if (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
)
8225 size
= size_of_locs (curr
->expr
);
8226 /* If the expression is too large, drop it on the floor. We could
8227 perhaps put it into DW_TAG_dwarf_procedure and refer to that
8228 in the expression, but >= 64KB expressions for a single value
8229 in a single range are unlikely very useful. */
8232 if (!have_multiple_function_sections
)
8234 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
8235 "Location list begin address (%s)",
8236 list_head
->ll_symbol
);
8237 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
8238 "Location list end address (%s)",
8239 list_head
->ll_symbol
);
8243 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
8244 "Location list begin address (%s)",
8245 list_head
->ll_symbol
);
8246 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
8247 "Location list end address (%s)",
8248 list_head
->ll_symbol
);
8251 /* Output the block length for this list of location operations. */
8252 gcc_assert (size
<= 0xffff);
8253 dw2_asm_output_data (2, size
, "%s", "Location expression size");
8255 output_loc_sequence (curr
->expr
, -1);
8258 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8259 "Location list terminator begin (%s)",
8260 list_head
->ll_symbol
);
8261 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8262 "Location list terminator end (%s)",
8263 list_head
->ll_symbol
);
8266 /* Output a type signature. */
8269 output_signature (const char *sig
, const char *name
)
8273 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
8274 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
8277 /* Output the DIE and its attributes. Called recursively to generate
8278 the definitions of each child DIE. */
8281 output_die (dw_die_ref die
)
8288 /* If someone in another CU might refer to us, set up a symbol for
8289 them to point to. */
8290 if (! use_debug_types
&& die
->die_id
.die_symbol
)
8291 output_die_symbol (die
);
8293 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
8294 (unsigned long)die
->die_offset
,
8295 dwarf_tag_name (die
->die_tag
));
8297 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
8299 const char *name
= dwarf_attr_name (a
->dw_attr
);
8301 switch (AT_class (a
))
8303 case dw_val_class_addr
:
8304 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
8307 case dw_val_class_offset
:
8308 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8312 case dw_val_class_range_list
:
8314 char *p
= strchr (ranges_section_label
, '\0');
8316 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
8317 a
->dw_attr_val
.v
.val_offset
);
8318 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
8319 debug_ranges_section
, "%s", name
);
8324 case dw_val_class_loc
:
8325 size
= size_of_locs (AT_loc (a
));
8327 /* Output the block length for this list of location operations. */
8328 if (dwarf_version
>= 4)
8329 dw2_asm_output_data_uleb128 (size
, "%s", name
);
8331 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
8333 output_loc_sequence (AT_loc (a
), -1);
8336 case dw_val_class_const
:
8337 /* ??? It would be slightly more efficient to use a scheme like is
8338 used for unsigned constants below, but gdb 4.x does not sign
8339 extend. Gdb 5.x does sign extend. */
8340 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
8343 case dw_val_class_unsigned_const
:
8345 int csize
= constant_size (AT_unsigned (a
));
8346 if (dwarf_version
== 3
8347 && a
->dw_attr
== DW_AT_data_member_location
8349 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
8351 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
8355 case dw_val_class_const_double
:
8357 unsigned HOST_WIDE_INT first
, second
;
8359 if (HOST_BITS_PER_WIDE_INT
>= 64)
8360 dw2_asm_output_data (1,
8361 2 * HOST_BITS_PER_WIDE_INT
8362 / HOST_BITS_PER_CHAR
,
8365 if (WORDS_BIG_ENDIAN
)
8367 first
= a
->dw_attr_val
.v
.val_double
.high
;
8368 second
= a
->dw_attr_val
.v
.val_double
.low
;
8372 first
= a
->dw_attr_val
.v
.val_double
.low
;
8373 second
= a
->dw_attr_val
.v
.val_double
.high
;
8376 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8378 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
8383 case dw_val_class_vec
:
8385 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
8386 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
8390 dw2_asm_output_data (constant_size (len
* elt_size
),
8391 len
* elt_size
, "%s", name
);
8392 if (elt_size
> sizeof (HOST_WIDE_INT
))
8397 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
8400 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
8401 "fp or vector constant word %u", i
);
8405 case dw_val_class_flag
:
8406 if (dwarf_version
>= 4)
8408 /* Currently all add_AT_flag calls pass in 1 as last argument,
8409 so DW_FORM_flag_present can be used. If that ever changes,
8410 we'll need to use DW_FORM_flag and have some optimization
8411 in build_abbrev_table that will change those to
8412 DW_FORM_flag_present if it is set to 1 in all DIEs using
8413 the same abbrev entry. */
8414 gcc_assert (AT_flag (a
) == 1);
8416 fprintf (asm_out_file
, "\t\t\t%s %s\n",
8417 ASM_COMMENT_START
, name
);
8420 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
8423 case dw_val_class_loc_list
:
8425 char *sym
= AT_loc_list (a
)->ll_symbol
;
8428 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
8433 case dw_val_class_die_ref
:
8434 if (AT_ref_external (a
))
8436 if (use_debug_types
)
8438 comdat_type_node_ref type_node
=
8439 AT_ref (a
)->die_id
.die_type_node
;
8441 gcc_assert (type_node
);
8442 output_signature (type_node
->signature
, name
);
8446 char *sym
= AT_ref (a
)->die_id
.die_symbol
;
8450 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8451 length, whereas in DWARF3 it's always sized as an
8453 if (dwarf_version
== 2)
8454 size
= DWARF2_ADDR_SIZE
;
8456 size
= DWARF_OFFSET_SIZE
;
8457 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
8463 gcc_assert (AT_ref (a
)->die_offset
);
8464 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
8469 case dw_val_class_fde_ref
:
8473 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
8474 a
->dw_attr_val
.v
.val_fde_index
* 2);
8475 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
8480 case dw_val_class_vms_delta
:
8481 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
8482 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
8486 case dw_val_class_lbl_id
:
8487 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
8490 case dw_val_class_lineptr
:
8491 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8492 debug_line_section
, "%s", name
);
8495 case dw_val_class_macptr
:
8496 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8497 debug_macinfo_section
, "%s", name
);
8500 case dw_val_class_str
:
8501 if (AT_string_form (a
) == DW_FORM_strp
)
8502 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
8503 a
->dw_attr_val
.v
.val_str
->label
,
8505 "%s: \"%s\"", name
, AT_string (a
));
8507 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
8510 case dw_val_class_file
:
8512 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
8514 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
8515 a
->dw_attr_val
.v
.val_file
->filename
);
8519 case dw_val_class_data8
:
8523 for (i
= 0; i
< 8; i
++)
8524 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
8525 i
== 0 ? "%s" : NULL
, name
);
8534 FOR_EACH_CHILD (die
, c
, output_die (c
));
8536 /* Add null byte to terminate sibling list. */
8537 if (die
->die_child
!= NULL
)
8538 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
8539 (unsigned long) die
->die_offset
);
8542 /* Output the compilation unit that appears at the beginning of the
8543 .debug_info section, and precedes the DIE descriptions. */
8546 output_compilation_unit_header (void)
8548 int ver
= dwarf_version
;
8550 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8551 dw2_asm_output_data (4, 0xffffffff,
8552 "Initial length escape value indicating 64-bit DWARF extension");
8553 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
8554 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
8555 "Length of Compilation Unit Info");
8556 dw2_asm_output_data (2, ver
, "DWARF version number");
8557 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
8558 debug_abbrev_section
,
8559 "Offset Into Abbrev. Section");
8560 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
8563 /* Output the compilation unit DIE and its children. */
8566 output_comp_unit (dw_die_ref die
, int output_if_empty
)
8568 const char *secname
;
8571 /* Unless we are outputting main CU, we may throw away empty ones. */
8572 if (!output_if_empty
&& die
->die_child
== NULL
)
8575 /* Even if there are no children of this DIE, we must output the information
8576 about the compilation unit. Otherwise, on an empty translation unit, we
8577 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8578 will then complain when examining the file. First mark all the DIEs in
8579 this CU so we know which get local refs. */
8582 build_abbrev_table (die
);
8584 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8585 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8586 calc_die_sizes (die
);
8588 oldsym
= die
->die_id
.die_symbol
;
8591 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
8593 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
8595 die
->die_id
.die_symbol
= NULL
;
8596 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
8600 switch_to_section (debug_info_section
);
8601 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
8602 info_section_emitted
= true;
8605 /* Output debugging information. */
8606 output_compilation_unit_header ();
8609 /* Leave the marks on the main CU, so we can check them in
8614 die
->die_id
.die_symbol
= oldsym
;
8618 /* Output a comdat type unit DIE and its children. */
8621 output_comdat_type_unit (comdat_type_node
*node
)
8623 const char *secname
;
8626 #if defined (OBJECT_FORMAT_ELF)
8630 /* First mark all the DIEs in this CU so we know which get local refs. */
8631 mark_dies (node
->root_die
);
8633 build_abbrev_table (node
->root_die
);
8635 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8636 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
8637 calc_die_sizes (node
->root_die
);
8639 #if defined (OBJECT_FORMAT_ELF)
8640 secname
= ".debug_types";
8641 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
8642 sprintf (tmp
, "wt.");
8643 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
8644 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
8645 comdat_key
= get_identifier (tmp
);
8646 targetm
.asm_out
.named_section (secname
,
8647 SECTION_DEBUG
| SECTION_LINKONCE
,
8650 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
8651 sprintf (tmp
, ".gnu.linkonce.wt.");
8652 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
8653 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
8655 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
8658 /* Output debugging information. */
8659 output_compilation_unit_header ();
8660 output_signature (node
->signature
, "Type Signature");
8661 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
8662 "Offset to Type DIE");
8663 output_die (node
->root_die
);
8665 unmark_dies (node
->root_die
);
8668 /* Return the DWARF2/3 pubname associated with a decl. */
8671 dwarf2_name (tree decl
, int scope
)
8673 if (DECL_NAMELESS (decl
))
8675 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
8678 /* Add a new entry to .debug_pubnames if appropriate. */
8681 add_pubname_string (const char *str
, dw_die_ref die
)
8683 if (targetm
.want_debug_pub_sections
)
8688 e
.name
= xstrdup (str
);
8689 VEC_safe_push (pubname_entry
, gc
, pubname_table
, &e
);
8694 add_pubname (tree decl
, dw_die_ref die
)
8696 if (targetm
.want_debug_pub_sections
&& TREE_PUBLIC (decl
))
8698 const char *name
= dwarf2_name (decl
, 1);
8700 add_pubname_string (name
, die
);
8704 /* Add a new entry to .debug_pubtypes if appropriate. */
8707 add_pubtype (tree decl
, dw_die_ref die
)
8711 if (!targetm
.want_debug_pub_sections
)
8715 if ((TREE_PUBLIC (decl
)
8716 || is_cu_die (die
->die_parent
))
8717 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
8722 if (TYPE_NAME (decl
))
8724 if (TREE_CODE (TYPE_NAME (decl
)) == IDENTIFIER_NODE
)
8725 e
.name
= IDENTIFIER_POINTER (TYPE_NAME (decl
));
8726 else if (TREE_CODE (TYPE_NAME (decl
)) == TYPE_DECL
8727 && DECL_NAME (TYPE_NAME (decl
)))
8728 e
.name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl
)));
8730 e
.name
= xstrdup ((const char *) get_AT_string (die
, DW_AT_name
));
8735 e
.name
= dwarf2_name (decl
, 1);
8737 e
.name
= xstrdup (e
.name
);
8740 /* If we don't have a name for the type, there's no point in adding
8742 if (e
.name
&& e
.name
[0] != '\0')
8743 VEC_safe_push (pubname_entry
, gc
, pubtype_table
, &e
);
8747 /* Output the public names table used to speed up access to externally
8748 visible names; or the public types table used to find type definitions. */
8751 output_pubnames (VEC (pubname_entry
, gc
) * names
)
8754 unsigned long pubnames_length
= size_of_pubnames (names
);
8757 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8758 dw2_asm_output_data (4, 0xffffffff,
8759 "Initial length escape value indicating 64-bit DWARF extension");
8760 if (names
== pubname_table
)
8761 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
8762 "Length of Public Names Info");
8764 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
8765 "Length of Public Type Names Info");
8766 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
8767 dw2_asm_output_data (2, 2, "DWARF Version");
8768 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
8770 "Offset of Compilation Unit Info");
8771 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
8772 "Compilation Unit Length");
8774 FOR_EACH_VEC_ELT (pubname_entry
, names
, i
, pub
)
8776 /* We shouldn't see pubnames for DIEs outside of the main CU. */
8777 if (names
== pubname_table
)
8778 gcc_assert (pub
->die
->die_mark
);
8780 if (names
!= pubtype_table
8781 || pub
->die
->die_offset
!= 0
8782 || !flag_eliminate_unused_debug_types
)
8784 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pub
->die
->die_offset
,
8787 dw2_asm_output_nstring (pub
->name
, -1, "external name");
8791 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
8794 /* Output the information that goes into the .debug_aranges table.
8795 Namely, define the beginning and ending address range of the
8796 text section generated for this compilation unit. */
8799 output_aranges (unsigned long aranges_length
)
8803 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8804 dw2_asm_output_data (4, 0xffffffff,
8805 "Initial length escape value indicating 64-bit DWARF extension");
8806 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
8807 "Length of Address Ranges Info");
8808 /* Version number for aranges is still 2, even in DWARF3. */
8809 dw2_asm_output_data (2, 2, "DWARF Version");
8810 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
8812 "Offset of Compilation Unit Info");
8813 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
8814 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
8816 /* We need to align to twice the pointer size here. */
8817 if (DWARF_ARANGES_PAD_SIZE
)
8819 /* Pad using a 2 byte words so that padding is correct for any
8821 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
8822 2 * DWARF2_ADDR_SIZE
);
8823 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
8824 dw2_asm_output_data (2, 0, NULL
);
8827 /* It is necessary not to output these entries if the sections were
8828 not used; if the sections were not used, the length will be 0 and
8829 the address may end up as 0 if the section is discarded by ld
8830 --gc-sections, leaving an invalid (0, 0) entry that can be
8831 confused with the terminator. */
8832 if (text_section_used
)
8834 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
8835 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
8836 text_section_label
, "Length");
8838 if (cold_text_section_used
)
8840 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
8842 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
8843 cold_text_section_label
, "Length");
8846 if (have_multiple_function_sections
)
8851 FOR_EACH_VEC_ELT (dw_fde_ref
, fde_vec
, fde_idx
, fde
)
8853 if (!fde
->in_std_section
)
8855 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
8857 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
8858 fde
->dw_fde_begin
, "Length");
8860 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
8862 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
8864 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
8865 fde
->dw_fde_second_begin
, "Length");
8870 /* Output the terminator words. */
8871 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
8872 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
8875 /* Add a new entry to .debug_ranges. Return the offset at which it
8879 add_ranges_num (int num
)
8881 unsigned int in_use
= ranges_table_in_use
;
8883 if (in_use
== ranges_table_allocated
)
8885 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
8886 ranges_table
= GGC_RESIZEVEC (struct dw_ranges_struct
, ranges_table
,
8887 ranges_table_allocated
);
8888 memset (ranges_table
+ ranges_table_in_use
, 0,
8889 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
8892 ranges_table
[in_use
].num
= num
;
8893 ranges_table_in_use
= in_use
+ 1;
8895 return in_use
* 2 * DWARF2_ADDR_SIZE
;
8898 /* Add a new entry to .debug_ranges corresponding to a block, or a
8899 range terminator if BLOCK is NULL. */
8902 add_ranges (const_tree block
)
8904 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0);
8907 /* Add a new entry to .debug_ranges corresponding to a pair of
8911 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
8914 unsigned int in_use
= ranges_by_label_in_use
;
8915 unsigned int offset
;
8917 if (in_use
== ranges_by_label_allocated
)
8919 ranges_by_label_allocated
+= RANGES_TABLE_INCREMENT
;
8920 ranges_by_label
= GGC_RESIZEVEC (struct dw_ranges_by_label_struct
,
8922 ranges_by_label_allocated
);
8923 memset (ranges_by_label
+ ranges_by_label_in_use
, 0,
8924 RANGES_TABLE_INCREMENT
8925 * sizeof (struct dw_ranges_by_label_struct
));
8928 ranges_by_label
[in_use
].begin
= begin
;
8929 ranges_by_label
[in_use
].end
= end
;
8930 ranges_by_label_in_use
= in_use
+ 1;
8932 offset
= add_ranges_num (-(int)in_use
- 1);
8935 add_AT_range_list (die
, DW_AT_ranges
, offset
);
8941 output_ranges (void)
8944 static const char *const start_fmt
= "Offset %#x";
8945 const char *fmt
= start_fmt
;
8947 for (i
= 0; i
< ranges_table_in_use
; i
++)
8949 int block_num
= ranges_table
[i
].num
;
8953 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
8954 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
8956 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
8957 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
8959 /* If all code is in the text section, then the compilation
8960 unit base address defaults to DW_AT_low_pc, which is the
8961 base of the text section. */
8962 if (!have_multiple_function_sections
)
8964 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
8966 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
8967 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
8968 text_section_label
, NULL
);
8971 /* Otherwise, the compilation unit base address is zero,
8972 which allows us to use absolute addresses, and not worry
8973 about whether the target supports cross-section
8977 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
8978 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
8979 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
8985 /* Negative block_num stands for an index into ranges_by_label. */
8986 else if (block_num
< 0)
8988 int lab_idx
= - block_num
- 1;
8990 if (!have_multiple_function_sections
)
8994 /* If we ever use add_ranges_by_labels () for a single
8995 function section, all we have to do is to take out
8997 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
8998 ranges_by_label
[lab_idx
].begin
,
9000 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9001 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
9002 ranges_by_label
[lab_idx
].end
,
9003 text_section_label
, NULL
);
9008 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9009 ranges_by_label
[lab_idx
].begin
,
9010 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
9011 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
9012 ranges_by_label
[lab_idx
].end
,
9018 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9019 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
9025 /* Data structure containing information about input files. */
9028 const char *path
; /* Complete file name. */
9029 const char *fname
; /* File name part. */
9030 int length
; /* Length of entire string. */
9031 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
9032 int dir_idx
; /* Index in directory table. */
9035 /* Data structure containing information about directories with source
9039 const char *path
; /* Path including directory name. */
9040 int length
; /* Path length. */
9041 int prefix
; /* Index of directory entry which is a prefix. */
9042 int count
; /* Number of files in this directory. */
9043 int dir_idx
; /* Index of directory used as base. */
9046 /* Callback function for file_info comparison. We sort by looking at
9047 the directories in the path. */
9050 file_info_cmp (const void *p1
, const void *p2
)
9052 const struct file_info
*const s1
= (const struct file_info
*) p1
;
9053 const struct file_info
*const s2
= (const struct file_info
*) p2
;
9054 const unsigned char *cp1
;
9055 const unsigned char *cp2
;
9057 /* Take care of file names without directories. We need to make sure that
9058 we return consistent values to qsort since some will get confused if
9059 we return the same value when identical operands are passed in opposite
9060 orders. So if neither has a directory, return 0 and otherwise return
9061 1 or -1 depending on which one has the directory. */
9062 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
9063 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
9065 cp1
= (const unsigned char *) s1
->path
;
9066 cp2
= (const unsigned char *) s2
->path
;
9072 /* Reached the end of the first path? If so, handle like above. */
9073 if ((cp1
== (const unsigned char *) s1
->fname
)
9074 || (cp2
== (const unsigned char *) s2
->fname
))
9075 return ((cp2
== (const unsigned char *) s2
->fname
)
9076 - (cp1
== (const unsigned char *) s1
->fname
));
9078 /* Character of current path component the same? */
9079 else if (*cp1
!= *cp2
)
9084 struct file_name_acquire_data
9086 struct file_info
*files
;
9091 /* Traversal function for the hash table. */
9094 file_name_acquire (void ** slot
, void *data
)
9096 struct file_name_acquire_data
*fnad
= (struct file_name_acquire_data
*) data
;
9097 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
9098 struct file_info
*fi
;
9101 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
9103 if (! d
->emitted_number
)
9106 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
9108 fi
= fnad
->files
+ fnad
->used_files
++;
9110 /* Skip all leading "./". */
9112 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
9115 /* Create a new array entry. */
9117 fi
->length
= strlen (f
);
9120 /* Search for the file name part. */
9121 f
= strrchr (f
, DIR_SEPARATOR
);
9122 #if defined (DIR_SEPARATOR_2)
9124 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
9128 if (f
== NULL
|| f
< g
)
9134 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
9138 /* Output the directory table and the file name table. We try to minimize
9139 the total amount of memory needed. A heuristic is used to avoid large
9140 slowdowns with many input files. */
9143 output_file_names (void)
9145 struct file_name_acquire_data fnad
;
9147 struct file_info
*files
;
9148 struct dir_info
*dirs
;
9156 if (!last_emitted_file
)
9158 dw2_asm_output_data (1, 0, "End directory table");
9159 dw2_asm_output_data (1, 0, "End file name table");
9163 numfiles
= last_emitted_file
->emitted_number
;
9165 /* Allocate the various arrays we need. */
9166 files
= XALLOCAVEC (struct file_info
, numfiles
);
9167 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
9170 fnad
.used_files
= 0;
9171 fnad
.max_files
= numfiles
;
9172 htab_traverse (file_table
, file_name_acquire
, &fnad
);
9173 gcc_assert (fnad
.used_files
== fnad
.max_files
);
9175 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
9177 /* Find all the different directories used. */
9178 dirs
[0].path
= files
[0].path
;
9179 dirs
[0].length
= files
[0].fname
- files
[0].path
;
9180 dirs
[0].prefix
= -1;
9182 dirs
[0].dir_idx
= 0;
9183 files
[0].dir_idx
= 0;
9186 for (i
= 1; i
< numfiles
; i
++)
9187 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
9188 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
9189 dirs
[ndirs
- 1].length
) == 0)
9191 /* Same directory as last entry. */
9192 files
[i
].dir_idx
= ndirs
- 1;
9193 ++dirs
[ndirs
- 1].count
;
9199 /* This is a new directory. */
9200 dirs
[ndirs
].path
= files
[i
].path
;
9201 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
9202 dirs
[ndirs
].count
= 1;
9203 dirs
[ndirs
].dir_idx
= ndirs
;
9204 files
[i
].dir_idx
= ndirs
;
9206 /* Search for a prefix. */
9207 dirs
[ndirs
].prefix
= -1;
9208 for (j
= 0; j
< ndirs
; j
++)
9209 if (dirs
[j
].length
< dirs
[ndirs
].length
9210 && dirs
[j
].length
> 1
9211 && (dirs
[ndirs
].prefix
== -1
9212 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
9213 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
9214 dirs
[ndirs
].prefix
= j
;
9219 /* Now to the actual work. We have to find a subset of the directories which
9220 allow expressing the file name using references to the directory table
9221 with the least amount of characters. We do not do an exhaustive search
9222 where we would have to check out every combination of every single
9223 possible prefix. Instead we use a heuristic which provides nearly optimal
9224 results in most cases and never is much off. */
9225 saved
= XALLOCAVEC (int, ndirs
);
9226 savehere
= XALLOCAVEC (int, ndirs
);
9228 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
9229 for (i
= 0; i
< ndirs
; i
++)
9234 /* We can always save some space for the current directory. But this
9235 does not mean it will be enough to justify adding the directory. */
9236 savehere
[i
] = dirs
[i
].length
;
9237 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
9239 for (j
= i
+ 1; j
< ndirs
; j
++)
9242 if (saved
[j
] < dirs
[i
].length
)
9244 /* Determine whether the dirs[i] path is a prefix of the
9249 while (k
!= -1 && k
!= (int) i
)
9254 /* Yes it is. We can possibly save some memory by
9255 writing the filenames in dirs[j] relative to
9257 savehere
[j
] = dirs
[i
].length
;
9258 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
9263 /* Check whether we can save enough to justify adding the dirs[i]
9265 if (total
> dirs
[i
].length
+ 1)
9267 /* It's worthwhile adding. */
9268 for (j
= i
; j
< ndirs
; j
++)
9269 if (savehere
[j
] > 0)
9271 /* Remember how much we saved for this directory so far. */
9272 saved
[j
] = savehere
[j
];
9274 /* Remember the prefix directory. */
9275 dirs
[j
].dir_idx
= i
;
9280 /* Emit the directory name table. */
9281 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
9282 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
9283 dw2_asm_output_nstring (dirs
[i
].path
,
9285 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
9286 "Directory Entry: %#x", i
+ idx_offset
);
9288 dw2_asm_output_data (1, 0, "End directory table");
9290 /* We have to emit them in the order of emitted_number since that's
9291 used in the debug info generation. To do this efficiently we
9292 generate a back-mapping of the indices first. */
9293 backmap
= XALLOCAVEC (int, numfiles
);
9294 for (i
= 0; i
< numfiles
; i
++)
9295 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
9297 /* Now write all the file names. */
9298 for (i
= 0; i
< numfiles
; i
++)
9300 int file_idx
= backmap
[i
];
9301 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
9303 #ifdef VMS_DEBUGGING_INFO
9304 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
9306 /* Setting these fields can lead to debugger miscomparisons,
9307 but VMS Debug requires them to be set correctly. */
9312 int maxfilelen
= strlen (files
[file_idx
].path
)
9313 + dirs
[dir_idx
].length
9314 + MAX_VMS_VERSION_LEN
+ 1;
9315 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
9317 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
9318 snprintf (filebuf
, maxfilelen
, "%s;%d",
9319 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
9321 dw2_asm_output_nstring
9322 (filebuf
, -1, "File Entry: %#x", (unsigned) i
+ 1);
9324 /* Include directory index. */
9325 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
9327 /* Modification time. */
9328 dw2_asm_output_data_uleb128
9329 ((vms_file_stats_name (files
[file_idx
].path
, &cdt
, 0, 0, 0) == 0)
9333 /* File length in bytes. */
9334 dw2_asm_output_data_uleb128
9335 ((vms_file_stats_name (files
[file_idx
].path
, 0, &siz
, 0, 0) == 0)
9339 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
9340 "File Entry: %#x", (unsigned) i
+ 1);
9342 /* Include directory index. */
9343 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
9345 /* Modification time. */
9346 dw2_asm_output_data_uleb128 (0, NULL
);
9348 /* File length in bytes. */
9349 dw2_asm_output_data_uleb128 (0, NULL
);
9350 #endif /* VMS_DEBUGGING_INFO */
9353 dw2_asm_output_data (1, 0, "End file name table");
9357 /* Output one line number table into the .debug_line section. */
9360 output_one_line_info_table (dw_line_info_table
*table
)
9362 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
9363 unsigned int current_line
= 1;
9364 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
9365 dw_line_info_entry
*ent
;
9368 FOR_EACH_VEC_ELT (dw_line_info_entry
, table
->entries
, i
, ent
)
9370 switch (ent
->opcode
)
9372 case LI_set_address
:
9373 /* ??? Unfortunately, we have little choice here currently, and
9374 must always use the most general form. GCC does not know the
9375 address delta itself, so we can't use DW_LNS_advance_pc. Many
9376 ports do have length attributes which will give an upper bound
9377 on the address range. We could perhaps use length attributes
9378 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
9379 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
9381 /* This can handle any delta. This takes
9382 4+DWARF2_ADDR_SIZE bytes. */
9383 dw2_asm_output_data (1, 0, "set address %s", line_label
);
9384 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
9385 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
9386 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
9390 if (ent
->val
== current_line
)
9392 /* We still need to start a new row, so output a copy insn. */
9393 dw2_asm_output_data (1, DW_LNS_copy
,
9394 "copy line %u", current_line
);
9398 int line_offset
= ent
->val
- current_line
;
9399 int line_delta
= line_offset
- DWARF_LINE_BASE
;
9401 current_line
= ent
->val
;
9402 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
9404 /* This can handle deltas from -10 to 234, using the current
9405 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
9406 This takes 1 byte. */
9407 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
9408 "line %u", current_line
);
9412 /* This can handle any delta. This takes at least 4 bytes,
9413 depending on the value being encoded. */
9414 dw2_asm_output_data (1, DW_LNS_advance_line
,
9415 "advance to line %u", current_line
);
9416 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
9417 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
9423 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
9424 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
9428 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
9429 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
9432 case LI_negate_stmt
:
9433 current_is_stmt
= !current_is_stmt
;
9434 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
9435 "is_stmt %d", current_is_stmt
);
9438 case LI_set_prologue_end
:
9439 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
9440 "set prologue end");
9443 case LI_set_epilogue_begin
:
9444 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
9445 "set epilogue begin");
9448 case LI_set_discriminator
:
9449 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
9450 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
9451 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
9452 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
9457 /* Emit debug info for the address of the end of the table. */
9458 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
9459 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
9460 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
9461 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
9463 dw2_asm_output_data (1, 0, "end sequence");
9464 dw2_asm_output_data_uleb128 (1, NULL
);
9465 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
9468 /* Output the source line number correspondence information. This
9469 information goes into the .debug_line section. */
9472 output_line_info (void)
9474 char l1
[20], l2
[20], p1
[20], p2
[20];
9475 int ver
= dwarf_version
;
9476 bool saw_one
= false;
9479 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
9480 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
9481 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
9482 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
9484 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
9485 dw2_asm_output_data (4, 0xffffffff,
9486 "Initial length escape value indicating 64-bit DWARF extension");
9487 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
9488 "Length of Source Line Info");
9489 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
9491 dw2_asm_output_data (2, ver
, "DWARF Version");
9492 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
9493 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
9495 /* Define the architecture-dependent minimum instruction length (in bytes).
9496 In this implementation of DWARF, this field is used for information
9497 purposes only. Since GCC generates assembly language, we have no
9498 a priori knowledge of how many instruction bytes are generated for each
9499 source line, and therefore can use only the DW_LNE_set_address and
9500 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
9501 this as '1', which is "correct enough" for all architectures,
9502 and don't let the target override. */
9503 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
9506 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
9507 "Maximum Operations Per Instruction");
9508 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
9509 "Default is_stmt_start flag");
9510 dw2_asm_output_data (1, DWARF_LINE_BASE
,
9511 "Line Base Value (Special Opcodes)");
9512 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
9513 "Line Range Value (Special Opcodes)");
9514 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
9515 "Special Opcode Base");
9517 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
9522 case DW_LNS_advance_pc
:
9523 case DW_LNS_advance_line
:
9524 case DW_LNS_set_file
:
9525 case DW_LNS_set_column
:
9526 case DW_LNS_fixed_advance_pc
:
9527 case DW_LNS_set_isa
:
9535 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
9539 /* Write out the information about the files we use. */
9540 output_file_names ();
9541 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
9543 if (separate_line_info
)
9545 dw_line_info_table
*table
;
9548 FOR_EACH_VEC_ELT (dw_line_info_table_p
, separate_line_info
, i
, table
)
9551 output_one_line_info_table (table
);
9555 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
9557 output_one_line_info_table (cold_text_section_line_info
);
9561 /* ??? Some Darwin linkers crash on a .debug_line section with no
9562 sequences. Further, merely a DW_LNE_end_sequence entry is not
9563 sufficient -- the address column must also be initialized.
9564 Make sure to output at least one set_address/end_sequence pair,
9565 choosing .text since that section is always present. */
9566 if (text_section_line_info
->in_use
|| !saw_one
)
9567 output_one_line_info_table (text_section_line_info
);
9569 /* Output the marker for the end of the line number info. */
9570 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
9573 /* Given a pointer to a tree node for some base type, return a pointer to
9574 a DIE that describes the given type.
9576 This routine must only be called for GCC type nodes that correspond to
9577 Dwarf base (fundamental) types. */
9580 base_type_die (tree type
)
9582 dw_die_ref base_type_result
;
9583 enum dwarf_type encoding
;
9585 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
9588 /* If this is a subtype that should not be emitted as a subrange type,
9589 use the base type. See subrange_type_for_debug_p. */
9590 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
9591 type
= TREE_TYPE (type
);
9593 switch (TREE_CODE (type
))
9596 if ((dwarf_version
>= 4 || !dwarf_strict
)
9598 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
9599 && DECL_IS_BUILTIN (TYPE_NAME (type
))
9600 && DECL_NAME (TYPE_NAME (type
)))
9602 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
9603 if (strcmp (name
, "char16_t") == 0
9604 || strcmp (name
, "char32_t") == 0)
9606 encoding
= DW_ATE_UTF
;
9610 if (TYPE_STRING_FLAG (type
))
9612 if (TYPE_UNSIGNED (type
))
9613 encoding
= DW_ATE_unsigned_char
;
9615 encoding
= DW_ATE_signed_char
;
9617 else if (TYPE_UNSIGNED (type
))
9618 encoding
= DW_ATE_unsigned
;
9620 encoding
= DW_ATE_signed
;
9624 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
9626 if (dwarf_version
>= 3 || !dwarf_strict
)
9627 encoding
= DW_ATE_decimal_float
;
9629 encoding
= DW_ATE_lo_user
;
9632 encoding
= DW_ATE_float
;
9635 case FIXED_POINT_TYPE
:
9636 if (!(dwarf_version
>= 3 || !dwarf_strict
))
9637 encoding
= DW_ATE_lo_user
;
9638 else if (TYPE_UNSIGNED (type
))
9639 encoding
= DW_ATE_unsigned_fixed
;
9641 encoding
= DW_ATE_signed_fixed
;
9644 /* Dwarf2 doesn't know anything about complex ints, so use
9645 a user defined type for it. */
9647 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
9648 encoding
= DW_ATE_complex_float
;
9650 encoding
= DW_ATE_lo_user
;
9654 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
9655 encoding
= DW_ATE_boolean
;
9659 /* No other TREE_CODEs are Dwarf fundamental types. */
9663 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die (), type
);
9665 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
9666 int_size_in_bytes (type
));
9667 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
9669 return base_type_result
;
9672 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
9673 given input type is a Dwarf "fundamental" type. Otherwise return null. */
9676 is_base_type (tree type
)
9678 switch (TREE_CODE (type
))
9684 case FIXED_POINT_TYPE
:
9692 case QUAL_UNION_TYPE
:
9697 case REFERENCE_TYPE
:
9711 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
9712 node, return the size in bits for the type if it is a constant, or else
9713 return the alignment for the type if the type's size is not constant, or
9714 else return BITS_PER_WORD if the type actually turns out to be an
9717 static inline unsigned HOST_WIDE_INT
9718 simple_type_size_in_bits (const_tree type
)
9720 if (TREE_CODE (type
) == ERROR_MARK
)
9721 return BITS_PER_WORD
;
9722 else if (TYPE_SIZE (type
) == NULL_TREE
)
9724 else if (host_integerp (TYPE_SIZE (type
), 1))
9725 return tree_low_cst (TYPE_SIZE (type
), 1);
9727 return TYPE_ALIGN (type
);
9730 /* Similarly, but return a double_int instead of UHWI. */
9732 static inline double_int
9733 double_int_type_size_in_bits (const_tree type
)
9735 if (TREE_CODE (type
) == ERROR_MARK
)
9736 return uhwi_to_double_int (BITS_PER_WORD
);
9737 else if (TYPE_SIZE (type
) == NULL_TREE
)
9738 return double_int_zero
;
9739 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
9740 return tree_to_double_int (TYPE_SIZE (type
));
9742 return uhwi_to_double_int (TYPE_ALIGN (type
));
9745 /* Given a pointer to a tree node for a subrange type, return a pointer
9746 to a DIE that describes the given type. */
9749 subrange_type_die (tree type
, tree low
, tree high
, dw_die_ref context_die
)
9751 dw_die_ref subrange_die
;
9752 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
9754 if (context_die
== NULL
)
9755 context_die
= comp_unit_die ();
9757 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
9759 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
9761 /* The size of the subrange type and its base type do not match,
9762 so we need to generate a size attribute for the subrange type. */
9763 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
9767 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
);
9769 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
);
9771 return subrange_die
;
9774 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
9775 entry that chains various modifiers in front of the given type. */
9778 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
9779 dw_die_ref context_die
)
9781 enum tree_code code
= TREE_CODE (type
);
9782 dw_die_ref mod_type_die
;
9783 dw_die_ref sub_die
= NULL
;
9784 tree item_type
= NULL
;
9785 tree qualified_type
;
9786 tree name
, low
, high
;
9788 if (code
== ERROR_MARK
)
9791 /* See if we already have the appropriately qualified variant of
9794 = get_qualified_type (type
,
9795 ((is_const_type
? TYPE_QUAL_CONST
: 0)
9796 | (is_volatile_type
? TYPE_QUAL_VOLATILE
: 0)));
9798 if (qualified_type
== sizetype
9799 && TYPE_NAME (qualified_type
)
9800 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
9802 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
9804 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
9805 && TYPE_PRECISION (t
)
9806 == TYPE_PRECISION (qualified_type
)
9807 && TYPE_UNSIGNED (t
)
9808 == TYPE_UNSIGNED (qualified_type
));
9812 /* If we do, then we can just use its DIE, if it exists. */
9815 mod_type_die
= lookup_type_die (qualified_type
);
9817 return mod_type_die
;
9820 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
9822 /* Handle C typedef types. */
9823 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
9824 && !DECL_ARTIFICIAL (name
))
9826 tree dtype
= TREE_TYPE (name
);
9828 if (qualified_type
== dtype
)
9830 /* For a named type, use the typedef. */
9831 gen_type_die (qualified_type
, context_die
);
9832 return lookup_type_die (qualified_type
);
9834 else if (is_const_type
< TYPE_READONLY (dtype
)
9835 || is_volatile_type
< TYPE_VOLATILE (dtype
)
9836 || (is_const_type
<= TYPE_READONLY (dtype
)
9837 && is_volatile_type
<= TYPE_VOLATILE (dtype
)
9838 && DECL_ORIGINAL_TYPE (name
) != type
))
9839 /* cv-unqualified version of named type. Just use the unnamed
9840 type to which it refers. */
9841 return modified_type_die (DECL_ORIGINAL_TYPE (name
),
9842 is_const_type
, is_volatile_type
,
9844 /* Else cv-qualified version of named type; fall through. */
9848 /* If both is_const_type and is_volatile_type, prefer the path
9849 which leads to a qualified type. */
9850 && (!is_volatile_type
9851 || get_qualified_type (type
, TYPE_QUAL_CONST
) == NULL_TREE
9852 || get_qualified_type (type
, TYPE_QUAL_VOLATILE
) != NULL_TREE
))
9854 mod_type_die
= new_die (DW_TAG_const_type
, comp_unit_die (), type
);
9855 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
9857 else if (is_volatile_type
)
9859 mod_type_die
= new_die (DW_TAG_volatile_type
, comp_unit_die (), type
);
9860 sub_die
= modified_type_die (type
, is_const_type
, 0, context_die
);
9862 else if (code
== POINTER_TYPE
)
9864 mod_type_die
= new_die (DW_TAG_pointer_type
, comp_unit_die (), type
);
9865 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
9866 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
9867 item_type
= TREE_TYPE (type
);
9868 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
9869 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
9870 TYPE_ADDR_SPACE (item_type
));
9872 else if (code
== REFERENCE_TYPE
)
9874 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
9875 mod_type_die
= new_die (DW_TAG_rvalue_reference_type
, comp_unit_die (),
9878 mod_type_die
= new_die (DW_TAG_reference_type
, comp_unit_die (), type
);
9879 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
9880 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
9881 item_type
= TREE_TYPE (type
);
9882 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
9883 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
9884 TYPE_ADDR_SPACE (item_type
));
9886 else if (code
== INTEGER_TYPE
9887 && TREE_TYPE (type
) != NULL_TREE
9888 && subrange_type_for_debug_p (type
, &low
, &high
))
9890 mod_type_die
= subrange_type_die (type
, low
, high
, context_die
);
9891 item_type
= TREE_TYPE (type
);
9893 else if (is_base_type (type
))
9894 mod_type_die
= base_type_die (type
);
9897 gen_type_die (type
, context_die
);
9899 /* We have to get the type_main_variant here (and pass that to the
9900 `lookup_type_die' routine) because the ..._TYPE node we have
9901 might simply be a *copy* of some original type node (where the
9902 copy was created to help us keep track of typedef names) and
9903 that copy might have a different TYPE_UID from the original
9905 if (TREE_CODE (type
) != VECTOR_TYPE
)
9906 return lookup_type_die (type_main_variant (type
));
9908 /* Vectors have the debugging information in the type,
9909 not the main variant. */
9910 return lookup_type_die (type
);
9913 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
9914 don't output a DW_TAG_typedef, since there isn't one in the
9915 user's program; just attach a DW_AT_name to the type.
9916 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
9917 if the base type already has the same name. */
9919 && ((TREE_CODE (name
) != TYPE_DECL
9920 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
9921 || (!is_const_type
&& !is_volatile_type
)))
9922 || (TREE_CODE (name
) == TYPE_DECL
9923 && TREE_TYPE (name
) == qualified_type
9924 && DECL_NAME (name
))))
9926 if (TREE_CODE (name
) == TYPE_DECL
)
9927 /* Could just call add_name_and_src_coords_attributes here,
9928 but since this is a builtin type it doesn't have any
9929 useful source coordinates anyway. */
9930 name
= DECL_NAME (name
);
9931 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
9932 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
9933 if (TYPE_ARTIFICIAL (type
))
9934 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
9936 /* This probably indicates a bug. */
9937 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
9939 name
= TYPE_NAME (type
);
9941 && TREE_CODE (name
) == TYPE_DECL
)
9942 name
= DECL_NAME (name
);
9943 add_name_attribute (mod_type_die
,
9944 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
9948 equate_type_number_to_die (qualified_type
, mod_type_die
);
9951 /* We must do this after the equate_type_number_to_die call, in case
9952 this is a recursive type. This ensures that the modified_type_die
9953 recursion will terminate even if the type is recursive. Recursive
9954 types are possible in Ada. */
9955 sub_die
= modified_type_die (item_type
,
9956 TYPE_READONLY (item_type
),
9957 TYPE_VOLATILE (item_type
),
9960 if (sub_die
!= NULL
)
9961 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
9963 return mod_type_die
;
9966 /* Generate DIEs for the generic parameters of T.
9967 T must be either a generic type or a generic function.
9968 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
9971 gen_generic_params_dies (tree t
)
9975 dw_die_ref die
= NULL
;
9977 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
9981 die
= lookup_type_die (t
);
9982 else if (DECL_P (t
))
9983 die
= lookup_decl_die (t
);
9987 parms
= lang_hooks
.get_innermost_generic_parms (t
);
9989 /* T has no generic parameter. It means T is neither a generic type
9990 or function. End of story. */
9993 parms_num
= TREE_VEC_LENGTH (parms
);
9994 args
= lang_hooks
.get_innermost_generic_args (t
);
9995 for (i
= 0; i
< parms_num
; i
++)
9997 tree parm
, arg
, arg_pack_elems
;
9999 parm
= TREE_VEC_ELT (parms
, i
);
10000 arg
= TREE_VEC_ELT (args
, i
);
10001 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
10002 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
10004 if (parm
&& TREE_VALUE (parm
) && arg
)
10006 /* If PARM represents a template parameter pack,
10007 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10008 by DW_TAG_template_*_parameter DIEs for the argument
10009 pack elements of ARG. Note that ARG would then be
10010 an argument pack. */
10011 if (arg_pack_elems
)
10012 template_parameter_pack_die (TREE_VALUE (parm
),
10016 generic_parameter_die (TREE_VALUE (parm
), arg
,
10017 true /* Emit DW_AT_name */, die
);
10022 /* Create and return a DIE for PARM which should be
10023 the representation of a generic type parameter.
10024 For instance, in the C++ front end, PARM would be a template parameter.
10025 ARG is the argument to PARM.
10026 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10028 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10029 as a child node. */
10032 generic_parameter_die (tree parm
, tree arg
,
10034 dw_die_ref parent_die
)
10036 dw_die_ref tmpl_die
= NULL
;
10037 const char *name
= NULL
;
10039 if (!parm
|| !DECL_NAME (parm
) || !arg
)
10042 /* We support non-type generic parameters and arguments,
10043 type generic parameters and arguments, as well as
10044 generic generic parameters (a.k.a. template template parameters in C++)
10046 if (TREE_CODE (parm
) == PARM_DECL
)
10047 /* PARM is a nontype generic parameter */
10048 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
10049 else if (TREE_CODE (parm
) == TYPE_DECL
)
10050 /* PARM is a type generic parameter. */
10051 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
10052 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10053 /* PARM is a generic generic parameter.
10054 Its DIE is a GNU extension. It shall have a
10055 DW_AT_name attribute to represent the name of the template template
10056 parameter, and a DW_AT_GNU_template_name attribute to represent the
10057 name of the template template argument. */
10058 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
10061 gcc_unreachable ();
10067 /* If PARM is a generic parameter pack, it means we are
10068 emitting debug info for a template argument pack element.
10069 In other terms, ARG is a template argument pack element.
10070 In that case, we don't emit any DW_AT_name attribute for
10074 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
10076 add_AT_string (tmpl_die
, DW_AT_name
, name
);
10079 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
10081 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10082 TMPL_DIE should have a child DW_AT_type attribute that is set
10083 to the type of the argument to PARM, which is ARG.
10084 If PARM is a type generic parameter, TMPL_DIE should have a
10085 child DW_AT_type that is set to ARG. */
10086 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
10087 add_type_attribute (tmpl_die
, tmpl_type
, 0,
10088 TREE_THIS_VOLATILE (tmpl_type
),
10093 /* So TMPL_DIE is a DIE representing a
10094 a generic generic template parameter, a.k.a template template
10095 parameter in C++ and arg is a template. */
10097 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10098 to the name of the argument. */
10099 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
10101 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
10104 if (TREE_CODE (parm
) == PARM_DECL
)
10105 /* So PARM is a non-type generic parameter.
10106 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10107 attribute of TMPL_DIE which value represents the value
10109 We must be careful here:
10110 The value of ARG might reference some function decls.
10111 We might currently be emitting debug info for a generic
10112 type and types are emitted before function decls, we don't
10113 know if the function decls referenced by ARG will actually be
10114 emitted after cgraph computations.
10115 So must defer the generation of the DW_AT_const_value to
10116 after cgraph is ready. */
10117 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
10123 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
10124 PARM_PACK must be a template parameter pack. The returned DIE
10125 will be child DIE of PARENT_DIE. */
10128 template_parameter_pack_die (tree parm_pack
,
10129 tree parm_pack_args
,
10130 dw_die_ref parent_die
)
10135 gcc_assert (parent_die
&& parm_pack
);
10137 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
10138 add_name_and_src_coords_attributes (die
, parm_pack
);
10139 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
10140 generic_parameter_die (parm_pack
,
10141 TREE_VEC_ELT (parm_pack_args
, j
),
10142 false /* Don't emit DW_AT_name */,
10147 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10148 an enumerated type. */
10151 type_is_enum (const_tree type
)
10153 return TREE_CODE (type
) == ENUMERAL_TYPE
;
10156 /* Return the DBX register number described by a given RTL node. */
10158 static unsigned int
10159 dbx_reg_number (const_rtx rtl
)
10161 unsigned regno
= REGNO (rtl
);
10163 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
10165 #ifdef LEAF_REG_REMAP
10166 if (current_function_uses_only_leaf_regs
)
10168 int leaf_reg
= LEAF_REG_REMAP (regno
);
10169 if (leaf_reg
!= -1)
10170 regno
= (unsigned) leaf_reg
;
10174 return DBX_REGISTER_NUMBER (regno
);
10177 /* Optionally add a DW_OP_piece term to a location description expression.
10178 DW_OP_piece is only added if the location description expression already
10179 doesn't end with DW_OP_piece. */
10182 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
10184 dw_loc_descr_ref loc
;
10186 if (*list_head
!= NULL
)
10188 /* Find the end of the chain. */
10189 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
10192 if (loc
->dw_loc_opc
!= DW_OP_piece
)
10193 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
10197 /* Return a location descriptor that designates a machine register or
10198 zero if there is none. */
10200 static dw_loc_descr_ref
10201 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
10205 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
10208 /* We only use "frame base" when we're sure we're talking about the
10209 post-prologue local stack frame. We do this by *not* running
10210 register elimination until this point, and recognizing the special
10211 argument pointer and soft frame pointer rtx's.
10212 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
10213 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
10214 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
10216 dw_loc_descr_ref result
= NULL
;
10218 if (dwarf_version
>= 4 || !dwarf_strict
)
10220 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
10223 add_loc_descr (&result
,
10224 new_loc_descr (DW_OP_stack_value
, 0, 0));
10229 regs
= targetm
.dwarf_register_span (rtl
);
10231 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1 || regs
)
10232 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
10234 return one_reg_loc_descriptor (dbx_reg_number (rtl
), initialized
);
10237 /* Return a location descriptor that designates a machine register for
10238 a given hard register number. */
10240 static dw_loc_descr_ref
10241 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
10243 dw_loc_descr_ref reg_loc_descr
;
10247 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
10249 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
10251 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10252 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10254 return reg_loc_descr
;
10257 /* Given an RTL of a register, return a location descriptor that
10258 designates a value that spans more than one register. */
10260 static dw_loc_descr_ref
10261 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
10262 enum var_init_status initialized
)
10264 int nregs
, size
, i
;
10266 dw_loc_descr_ref loc_result
= NULL
;
10269 #ifdef LEAF_REG_REMAP
10270 if (current_function_uses_only_leaf_regs
)
10272 int leaf_reg
= LEAF_REG_REMAP (reg
);
10273 if (leaf_reg
!= -1)
10274 reg
= (unsigned) leaf_reg
;
10277 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
10278 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
10280 /* Simple, contiguous registers. */
10281 if (regs
== NULL_RTX
)
10283 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
10288 dw_loc_descr_ref t
;
10290 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
10291 VAR_INIT_STATUS_INITIALIZED
);
10292 add_loc_descr (&loc_result
, t
);
10293 add_loc_descr_op_piece (&loc_result
, size
);
10299 /* Now onto stupid register sets in non contiguous locations. */
10301 gcc_assert (GET_CODE (regs
) == PARALLEL
);
10303 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
10306 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
10308 dw_loc_descr_ref t
;
10310 t
= one_reg_loc_descriptor (REGNO (XVECEXP (regs
, 0, i
)),
10311 VAR_INIT_STATUS_INITIALIZED
);
10312 add_loc_descr (&loc_result
, t
);
10313 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
10314 add_loc_descr_op_piece (&loc_result
, size
);
10317 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10318 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10322 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
10324 /* Return a location descriptor that designates a constant i,
10325 as a compound operation from constant (i >> shift), constant shift
10328 static dw_loc_descr_ref
10329 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
10331 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
10332 add_loc_descr (&ret
, int_loc_descriptor (shift
));
10333 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
10337 /* Return a location descriptor that designates a constant. */
10339 static dw_loc_descr_ref
10340 int_loc_descriptor (HOST_WIDE_INT i
)
10342 enum dwarf_location_atom op
;
10344 /* Pick the smallest representation of a constant, rather than just
10345 defaulting to the LEB encoding. */
10348 int clz
= clz_hwi (i
);
10349 int ctz
= ctz_hwi (i
);
10351 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
10352 else if (i
<= 0xff)
10353 op
= DW_OP_const1u
;
10354 else if (i
<= 0xffff)
10355 op
= DW_OP_const2u
;
10356 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
10357 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
10358 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
10359 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
10360 while DW_OP_const4u is 5 bytes. */
10361 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
10362 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
10363 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
10364 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
10365 while DW_OP_const4u is 5 bytes. */
10366 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
10367 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
10368 op
= DW_OP_const4u
;
10369 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
10370 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
10371 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
10372 while DW_OP_constu of constant >= 0x100000000 takes at least
10374 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
10375 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
10376 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
10377 >= HOST_BITS_PER_WIDE_INT
)
10378 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
10379 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
10380 while DW_OP_constu takes in this case at least 6 bytes. */
10381 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
10382 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
10383 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
10384 && size_of_uleb128 (i
) > 6)
10385 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
10386 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
10393 op
= DW_OP_const1s
;
10394 else if (i
>= -0x8000)
10395 op
= DW_OP_const2s
;
10396 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
10398 if (size_of_int_loc_descriptor (i
) < 5)
10400 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
10401 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
10404 op
= DW_OP_const4s
;
10408 if (size_of_int_loc_descriptor (i
)
10409 < (unsigned long) 1 + size_of_sleb128 (i
))
10411 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
10412 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
10419 return new_loc_descr (op
, i
, 0);
10422 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
10423 without actually allocating it. */
10425 static unsigned long
10426 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
10428 return size_of_int_loc_descriptor (i
>> shift
)
10429 + size_of_int_loc_descriptor (shift
)
10433 /* Return size_of_locs (int_loc_descriptor (i)) without
10434 actually allocating it. */
10436 static unsigned long
10437 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
10446 else if (i
<= 0xff)
10448 else if (i
<= 0xffff)
10452 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
10453 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
10454 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
10456 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
10457 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
10458 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
10460 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
10462 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
10463 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
10464 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
10465 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
10467 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
10468 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
10469 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
10471 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
10472 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
10474 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
10483 else if (i
>= -0x8000)
10485 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
10487 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
10489 s
= size_of_int_loc_descriptor (-i
) + 1;
10497 unsigned long r
= 1 + size_of_sleb128 (i
);
10498 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
10500 s
= size_of_int_loc_descriptor (-i
) + 1;
10509 /* Return loc description representing "address" of integer value.
10510 This can appear only as toplevel expression. */
10512 static dw_loc_descr_ref
10513 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
10516 dw_loc_descr_ref loc_result
= NULL
;
10518 if (!(dwarf_version
>= 4 || !dwarf_strict
))
10521 litsize
= size_of_int_loc_descriptor (i
);
10522 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
10523 is more compact. For DW_OP_stack_value we need:
10524 litsize + 1 (DW_OP_stack_value)
10525 and for DW_OP_implicit_value:
10526 1 (DW_OP_implicit_value) + 1 (length) + size. */
10527 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
10529 loc_result
= int_loc_descriptor (i
);
10530 add_loc_descr (&loc_result
,
10531 new_loc_descr (DW_OP_stack_value
, 0, 0));
10535 loc_result
= new_loc_descr (DW_OP_implicit_value
,
10537 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
10538 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
10542 /* Return a location descriptor that designates a base+offset location. */
10544 static dw_loc_descr_ref
10545 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
10546 enum var_init_status initialized
)
10548 unsigned int regno
;
10549 dw_loc_descr_ref result
;
10550 dw_fde_ref fde
= cfun
->fde
;
10552 /* We only use "frame base" when we're sure we're talking about the
10553 post-prologue local stack frame. We do this by *not* running
10554 register elimination until this point, and recognizing the special
10555 argument pointer and soft frame pointer rtx's. */
10556 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
10558 rtx elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
10562 if (GET_CODE (elim
) == PLUS
)
10564 offset
+= INTVAL (XEXP (elim
, 1));
10565 elim
= XEXP (elim
, 0);
10567 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
10568 && (elim
== hard_frame_pointer_rtx
10569 || elim
== stack_pointer_rtx
))
10570 || elim
== (frame_pointer_needed
10571 ? hard_frame_pointer_rtx
10572 : stack_pointer_rtx
));
10574 /* If drap register is used to align stack, use frame
10575 pointer + offset to access stack variables. If stack
10576 is aligned without drap, use stack pointer + offset to
10577 access stack variables. */
10578 if (crtl
->stack_realign_tried
10579 && reg
== frame_pointer_rtx
)
10582 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
10583 ? HARD_FRAME_POINTER_REGNUM
10585 return new_reg_loc_descr (base_reg
, offset
);
10588 gcc_assert (frame_pointer_fb_offset_valid
);
10589 offset
+= frame_pointer_fb_offset
;
10590 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
10594 regno
= DWARF_FRAME_REGNUM (REGNO (reg
));
10596 if (!optimize
&& fde
10597 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
))
10599 /* Use cfa+offset to represent the location of arguments passed
10600 on the stack when drap is used to align stack.
10601 Only do this when not optimizing, for optimized code var-tracking
10602 is supposed to track where the arguments live and the register
10603 used as vdrap or drap in some spot might be used for something
10604 else in other part of the routine. */
10605 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
10609 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
10612 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
10614 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10615 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10620 /* Return true if this RTL expression describes a base+offset calculation. */
10623 is_based_loc (const_rtx rtl
)
10625 return (GET_CODE (rtl
) == PLUS
10626 && ((REG_P (XEXP (rtl
, 0))
10627 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
10628 && CONST_INT_P (XEXP (rtl
, 1)))));
10631 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
10634 static dw_loc_descr_ref
10635 tls_mem_loc_descriptor (rtx mem
)
10638 dw_loc_descr_ref loc_result
;
10640 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
10643 base
= get_base_address (MEM_EXPR (mem
));
10645 || TREE_CODE (base
) != VAR_DECL
10646 || !DECL_THREAD_LOCAL_P (base
))
10649 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1);
10650 if (loc_result
== NULL
)
10653 if (MEM_OFFSET (mem
))
10654 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
10659 /* Output debug info about reason why we failed to expand expression as dwarf
10663 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
10665 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10667 fprintf (dump_file
, "Failed to expand as dwarf: ");
10669 print_generic_expr (dump_file
, expr
, dump_flags
);
10672 fprintf (dump_file
, "\n");
10673 print_rtl (dump_file
, rtl
);
10675 fprintf (dump_file
, "\nReason: %s\n", reason
);
10679 /* Helper function for const_ok_for_output, called either directly
10680 or via for_each_rtx. */
10683 const_ok_for_output_1 (rtx
*rtlp
, void *data ATTRIBUTE_UNUSED
)
10687 if (GET_CODE (rtl
) == UNSPEC
)
10689 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
10690 we can't express it in the debug info. */
10691 #ifdef ENABLE_CHECKING
10692 /* Don't complain about TLS UNSPECs, those are just too hard to
10694 if (XVECLEN (rtl
, 0) != 1
10695 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
10696 || SYMBOL_REF_DECL (XVECEXP (rtl
, 0, 0)) == NULL
10697 || TREE_CODE (SYMBOL_REF_DECL (XVECEXP (rtl
, 0, 0))) != VAR_DECL
10698 || !DECL_THREAD_LOCAL_P (SYMBOL_REF_DECL (XVECEXP (rtl
, 0, 0))))
10699 inform (current_function_decl
10700 ? DECL_SOURCE_LOCATION (current_function_decl
)
10701 : UNKNOWN_LOCATION
,
10702 #if NUM_UNSPEC_VALUES > 0
10703 "non-delegitimized UNSPEC %s (%d) found in variable location",
10704 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
10705 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
10708 "non-delegitimized UNSPEC %d found in variable location",
10712 expansion_failed (NULL_TREE
, rtl
,
10713 "UNSPEC hasn't been delegitimized.\n");
10717 if (targetm
.const_not_ok_for_debug_p (rtl
))
10719 expansion_failed (NULL_TREE
, rtl
,
10720 "Expression rejected for debug by the backend.\n");
10724 if (GET_CODE (rtl
) != SYMBOL_REF
)
10727 if (CONSTANT_POOL_ADDRESS_P (rtl
))
10730 get_pool_constant_mark (rtl
, &marked
);
10731 /* If all references to this pool constant were optimized away,
10732 it was not output and thus we can't represent it. */
10735 expansion_failed (NULL_TREE
, rtl
,
10736 "Constant was removed from constant pool.\n");
10741 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
10744 /* Avoid references to external symbols in debug info, on several targets
10745 the linker might even refuse to link when linking a shared library,
10746 and in many other cases the relocations for .debug_info/.debug_loc are
10747 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
10748 to be defined within the same shared library or executable are fine. */
10749 if (SYMBOL_REF_EXTERNAL_P (rtl
))
10751 tree decl
= SYMBOL_REF_DECL (rtl
);
10753 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
10755 expansion_failed (NULL_TREE
, rtl
,
10756 "Symbol not defined in current TU.\n");
10764 /* Return true if constant RTL can be emitted in DW_OP_addr or
10765 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
10766 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
10769 const_ok_for_output (rtx rtl
)
10771 if (GET_CODE (rtl
) == SYMBOL_REF
)
10772 return const_ok_for_output_1 (&rtl
, NULL
) == 0;
10774 if (GET_CODE (rtl
) == CONST
)
10775 return for_each_rtx (&XEXP (rtl
, 0), const_ok_for_output_1
, NULL
) == 0;
10780 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
10781 if possible, NULL otherwise. */
10784 base_type_for_mode (enum machine_mode mode
, bool unsignedp
)
10786 dw_die_ref type_die
;
10787 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
10791 switch (TREE_CODE (type
))
10799 type_die
= lookup_type_die (type
);
10801 type_die
= modified_type_die (type
, false, false, comp_unit_die ());
10802 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
10807 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
10808 type matching MODE, or, if MODE is narrower than or as wide as
10809 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
10812 static dw_loc_descr_ref
10813 convert_descriptor_to_mode (enum machine_mode mode
, dw_loc_descr_ref op
)
10815 enum machine_mode outer_mode
= mode
;
10816 dw_die_ref type_die
;
10817 dw_loc_descr_ref cvt
;
10819 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
10821 add_loc_descr (&op
, new_loc_descr (DW_OP_GNU_convert
, 0, 0));
10824 type_die
= base_type_for_mode (outer_mode
, 1);
10825 if (type_die
== NULL
)
10827 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
10828 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
10829 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
10830 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
10831 add_loc_descr (&op
, cvt
);
10835 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
10837 static dw_loc_descr_ref
10838 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
10839 dw_loc_descr_ref op1
)
10841 dw_loc_descr_ref ret
= op0
;
10842 add_loc_descr (&ret
, op1
);
10843 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
10844 if (STORE_FLAG_VALUE
!= 1)
10846 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
10847 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
10852 /* Return location descriptor for signed comparison OP RTL. */
10854 static dw_loc_descr_ref
10855 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
10856 enum machine_mode mem_mode
)
10858 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
10859 dw_loc_descr_ref op0
, op1
;
10862 if (op_mode
== VOIDmode
)
10863 op_mode
= GET_MODE (XEXP (rtl
, 1));
10864 if (op_mode
== VOIDmode
)
10868 && (GET_MODE_CLASS (op_mode
) != MODE_INT
10869 || GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
))
10872 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
10873 VAR_INIT_STATUS_INITIALIZED
);
10874 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
10875 VAR_INIT_STATUS_INITIALIZED
);
10877 if (op0
== NULL
|| op1
== NULL
)
10880 if (GET_MODE_CLASS (op_mode
) != MODE_INT
10881 || GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
10882 return compare_loc_descriptor (op
, op0
, op1
);
10884 if (GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
10886 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
10887 dw_loc_descr_ref cvt
;
10889 if (type_die
== NULL
)
10891 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
10892 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
10893 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
10894 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
10895 add_loc_descr (&op0
, cvt
);
10896 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
10897 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
10898 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
10899 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
10900 add_loc_descr (&op1
, cvt
);
10901 return compare_loc_descriptor (op
, op0
, op1
);
10904 shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
10905 /* For eq/ne, if the operands are known to be zero-extended,
10906 there is no need to do the fancy shifting up. */
10907 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
10909 dw_loc_descr_ref last0
, last1
;
10910 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
10912 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
10914 /* deref_size zero extends, and for constants we can check
10915 whether they are zero extended or not. */
10916 if (((last0
->dw_loc_opc
== DW_OP_deref_size
10917 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
10918 || (CONST_INT_P (XEXP (rtl
, 0))
10919 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
10920 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
10921 && ((last1
->dw_loc_opc
== DW_OP_deref_size
10922 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
10923 || (CONST_INT_P (XEXP (rtl
, 1))
10924 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
10925 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
10926 return compare_loc_descriptor (op
, op0
, op1
);
10928 /* EQ/NE comparison against constant in narrower type than
10929 DWARF2_ADDR_SIZE can be performed either as
10930 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
10933 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
10934 DW_OP_{eq,ne}. Pick whatever is shorter. */
10935 if (CONST_INT_P (XEXP (rtl
, 1))
10936 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
10937 && (size_of_int_loc_descriptor (shift
) + 1
10938 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
)
10939 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
10940 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
10941 & GET_MODE_MASK (op_mode
))))
10943 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
10944 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
10945 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
10946 & GET_MODE_MASK (op_mode
));
10947 return compare_loc_descriptor (op
, op0
, op1
);
10950 add_loc_descr (&op0
, int_loc_descriptor (shift
));
10951 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
10952 if (CONST_INT_P (XEXP (rtl
, 1)))
10953 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
);
10956 add_loc_descr (&op1
, int_loc_descriptor (shift
));
10957 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
10959 return compare_loc_descriptor (op
, op0
, op1
);
10962 /* Return location descriptor for unsigned comparison OP RTL. */
10964 static dw_loc_descr_ref
10965 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
10966 enum machine_mode mem_mode
)
10968 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
10969 dw_loc_descr_ref op0
, op1
;
10971 if (op_mode
== VOIDmode
)
10972 op_mode
= GET_MODE (XEXP (rtl
, 1));
10973 if (op_mode
== VOIDmode
)
10975 if (GET_MODE_CLASS (op_mode
) != MODE_INT
)
10978 if (dwarf_strict
&& GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
10981 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
10982 VAR_INIT_STATUS_INITIALIZED
);
10983 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
10984 VAR_INIT_STATUS_INITIALIZED
);
10986 if (op0
== NULL
|| op1
== NULL
)
10989 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
10991 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
10992 dw_loc_descr_ref last0
, last1
;
10993 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
10995 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
10997 if (CONST_INT_P (XEXP (rtl
, 0)))
10998 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
10999 /* deref_size zero extends, so no need to mask it again. */
11000 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
11001 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11003 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11004 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11006 if (CONST_INT_P (XEXP (rtl
, 1)))
11007 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
11008 /* deref_size zero extends, so no need to mask it again. */
11009 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
11010 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
11012 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11013 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11016 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
11018 HOST_WIDE_INT bias
= 1;
11019 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11020 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11021 if (CONST_INT_P (XEXP (rtl
, 1)))
11022 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
11023 + INTVAL (XEXP (rtl
, 1)));
11025 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
11028 return compare_loc_descriptor (op
, op0
, op1
);
11031 /* Return location descriptor for {U,S}{MIN,MAX}. */
11033 static dw_loc_descr_ref
11034 minmax_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11035 enum machine_mode mem_mode
)
11037 enum dwarf_location_atom op
;
11038 dw_loc_descr_ref op0
, op1
, ret
;
11039 dw_loc_descr_ref bra_node
, drop_node
;
11042 && (GET_MODE_CLASS (mode
) != MODE_INT
11043 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
))
11046 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11047 VAR_INIT_STATUS_INITIALIZED
);
11048 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11049 VAR_INIT_STATUS_INITIALIZED
);
11051 if (op0
== NULL
|| op1
== NULL
)
11054 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
11055 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
11056 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
11057 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
11059 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11061 HOST_WIDE_INT mask
= GET_MODE_MASK (mode
);
11062 add_loc_descr (&op0
, int_loc_descriptor (mask
));
11063 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
11064 add_loc_descr (&op1
, int_loc_descriptor (mask
));
11065 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
11067 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
11069 HOST_WIDE_INT bias
= 1;
11070 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
11071 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11072 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
11075 else if (GET_MODE_CLASS (mode
) == MODE_INT
11076 && GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11078 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (mode
)) * BITS_PER_UNIT
;
11079 add_loc_descr (&op0
, int_loc_descriptor (shift
));
11080 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
11081 add_loc_descr (&op1
, int_loc_descriptor (shift
));
11082 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
11084 else if (GET_MODE_CLASS (mode
) == MODE_INT
11085 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11087 dw_die_ref type_die
= base_type_for_mode (mode
, 0);
11088 dw_loc_descr_ref cvt
;
11089 if (type_die
== NULL
)
11091 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11092 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11093 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11094 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11095 add_loc_descr (&op0
, cvt
);
11096 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11097 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11098 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11099 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11100 add_loc_descr (&op1
, cvt
);
11103 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
11108 add_loc_descr (&ret
, op1
);
11109 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
11110 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
11111 add_loc_descr (&ret
, bra_node
);
11112 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11113 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
11114 add_loc_descr (&ret
, drop_node
);
11115 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11116 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
11117 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
11118 && GET_MODE_CLASS (mode
) == MODE_INT
11119 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11120 ret
= convert_descriptor_to_mode (mode
, ret
);
11124 /* Helper function for mem_loc_descriptor. Perform OP binary op,
11125 but after converting arguments to type_die, afterwards
11126 convert back to unsigned. */
11128 static dw_loc_descr_ref
11129 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
11130 enum machine_mode mode
, enum machine_mode mem_mode
)
11132 dw_loc_descr_ref cvt
, op0
, op1
;
11134 if (type_die
== NULL
)
11136 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11137 VAR_INIT_STATUS_INITIALIZED
);
11138 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11139 VAR_INIT_STATUS_INITIALIZED
);
11140 if (op0
== NULL
|| op1
== NULL
)
11142 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11143 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11144 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11145 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11146 add_loc_descr (&op0
, cvt
);
11147 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11148 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11149 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11150 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11151 add_loc_descr (&op1
, cvt
);
11152 add_loc_descr (&op0
, op1
);
11153 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
11154 return convert_descriptor_to_mode (mode
, op0
);
11157 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
11158 const0 is DW_OP_lit0 or corresponding typed constant,
11159 const1 is DW_OP_lit1 or corresponding typed constant
11160 and constMSB is constant with just the MSB bit set
11162 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11163 L1: const0 DW_OP_swap
11164 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
11165 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11170 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11171 L1: const0 DW_OP_swap
11172 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11173 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11178 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
11179 L1: const1 DW_OP_swap
11180 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11181 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11185 static dw_loc_descr_ref
11186 clz_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11187 enum machine_mode mem_mode
)
11189 dw_loc_descr_ref op0
, ret
, tmp
;
11190 HOST_WIDE_INT valv
;
11191 dw_loc_descr_ref l1jump
, l1label
;
11192 dw_loc_descr_ref l2jump
, l2label
;
11193 dw_loc_descr_ref l3jump
, l3label
;
11194 dw_loc_descr_ref l4jump
, l4label
;
11197 if (GET_MODE_CLASS (mode
) != MODE_INT
11198 || GET_MODE (XEXP (rtl
, 0)) != mode
11199 || (GET_CODE (rtl
) == CLZ
11200 && GET_MODE_BITSIZE (mode
) > 2 * HOST_BITS_PER_WIDE_INT
))
11203 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11204 VAR_INIT_STATUS_INITIALIZED
);
11208 if (GET_CODE (rtl
) == CLZ
)
11210 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11211 valv
= GET_MODE_BITSIZE (mode
);
11213 else if (GET_CODE (rtl
) == FFS
)
11215 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
11216 valv
= GET_MODE_BITSIZE (mode
);
11217 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11218 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11219 add_loc_descr (&ret
, l1jump
);
11220 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
11221 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
11222 VAR_INIT_STATUS_INITIALIZED
);
11225 add_loc_descr (&ret
, tmp
);
11226 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11227 add_loc_descr (&ret
, l4jump
);
11228 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
11229 ? const1_rtx
: const0_rtx
,
11231 VAR_INIT_STATUS_INITIALIZED
);
11232 if (l1label
== NULL
)
11234 add_loc_descr (&ret
, l1label
);
11235 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11236 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
11237 add_loc_descr (&ret
, l2label
);
11238 if (GET_CODE (rtl
) != CLZ
)
11240 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
11241 msb
= GEN_INT ((unsigned HOST_WIDE_INT
) 1
11242 << (GET_MODE_BITSIZE (mode
) - 1));
11244 msb
= immed_double_const (0, (unsigned HOST_WIDE_INT
) 1
11245 << (GET_MODE_BITSIZE (mode
)
11246 - HOST_BITS_PER_WIDE_INT
- 1), mode
);
11247 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
11248 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
11249 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
11250 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
11252 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
11253 VAR_INIT_STATUS_INITIALIZED
);
11256 add_loc_descr (&ret
, tmp
);
11257 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
11258 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11259 add_loc_descr (&ret
, l3jump
);
11260 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11261 VAR_INIT_STATUS_INITIALIZED
);
11264 add_loc_descr (&ret
, tmp
);
11265 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
11266 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
11267 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11268 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
11269 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11270 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11271 add_loc_descr (&ret
, l2jump
);
11272 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
11273 add_loc_descr (&ret
, l3label
);
11274 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
11275 add_loc_descr (&ret
, l4label
);
11276 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11277 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
11278 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11279 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
11280 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11281 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
11282 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11283 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
11287 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
11288 const1 is DW_OP_lit1 or corresponding typed constant):
11290 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
11291 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
11295 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
11296 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
11299 static dw_loc_descr_ref
11300 popcount_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11301 enum machine_mode mem_mode
)
11303 dw_loc_descr_ref op0
, ret
, tmp
;
11304 dw_loc_descr_ref l1jump
, l1label
;
11305 dw_loc_descr_ref l2jump
, l2label
;
11307 if (GET_MODE_CLASS (mode
) != MODE_INT
11308 || GET_MODE (XEXP (rtl
, 0)) != mode
)
11311 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11312 VAR_INIT_STATUS_INITIALIZED
);
11316 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
11317 VAR_INIT_STATUS_INITIALIZED
);
11320 add_loc_descr (&ret
, tmp
);
11321 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11322 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
11323 add_loc_descr (&ret
, l1label
);
11324 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11325 add_loc_descr (&ret
, l2jump
);
11326 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11327 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
11328 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11329 VAR_INIT_STATUS_INITIALIZED
);
11332 add_loc_descr (&ret
, tmp
);
11333 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
11334 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
11335 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
11336 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11337 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
11338 VAR_INIT_STATUS_INITIALIZED
);
11339 add_loc_descr (&ret
, tmp
);
11340 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
11341 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11342 add_loc_descr (&ret
, l1jump
);
11343 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
11344 add_loc_descr (&ret
, l2label
);
11345 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11346 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
11347 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11348 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
11352 /* BSWAP (constS is initial shift count, either 56 or 24):
11354 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
11355 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
11356 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
11357 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
11358 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
11360 static dw_loc_descr_ref
11361 bswap_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11362 enum machine_mode mem_mode
)
11364 dw_loc_descr_ref op0
, ret
, tmp
;
11365 dw_loc_descr_ref l1jump
, l1label
;
11366 dw_loc_descr_ref l2jump
, l2label
;
11368 if (GET_MODE_CLASS (mode
) != MODE_INT
11369 || BITS_PER_UNIT
!= 8
11370 || (GET_MODE_BITSIZE (mode
) != 32
11371 && GET_MODE_BITSIZE (mode
) != 64))
11374 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11375 VAR_INIT_STATUS_INITIALIZED
);
11380 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
11382 VAR_INIT_STATUS_INITIALIZED
);
11385 add_loc_descr (&ret
, tmp
);
11386 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
11387 VAR_INIT_STATUS_INITIALIZED
);
11390 add_loc_descr (&ret
, tmp
);
11391 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
11392 add_loc_descr (&ret
, l1label
);
11393 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
11395 VAR_INIT_STATUS_INITIALIZED
);
11396 add_loc_descr (&ret
, tmp
);
11397 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
11398 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
11399 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
11400 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
11401 VAR_INIT_STATUS_INITIALIZED
);
11404 add_loc_descr (&ret
, tmp
);
11405 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
11406 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
11407 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
11408 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
11409 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11410 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
11411 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
11412 VAR_INIT_STATUS_INITIALIZED
);
11413 add_loc_descr (&ret
, tmp
);
11414 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
11415 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
11416 add_loc_descr (&ret
, l2jump
);
11417 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
11418 VAR_INIT_STATUS_INITIALIZED
);
11419 add_loc_descr (&ret
, tmp
);
11420 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
11421 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11422 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
11423 add_loc_descr (&ret
, l1jump
);
11424 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
11425 add_loc_descr (&ret
, l2label
);
11426 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11427 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
11428 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11429 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
11430 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11431 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
11435 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
11436 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
11437 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
11438 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
11440 ROTATERT is similar:
11441 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
11442 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
11443 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
11445 static dw_loc_descr_ref
11446 rotate_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11447 enum machine_mode mem_mode
)
11449 rtx rtlop1
= XEXP (rtl
, 1);
11450 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
11453 if (GET_MODE_CLASS (mode
) != MODE_INT
)
11456 if (GET_MODE (rtlop1
) != VOIDmode
11457 && GET_MODE_BITSIZE (GET_MODE (rtlop1
)) < GET_MODE_BITSIZE (mode
))
11458 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
11459 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11460 VAR_INIT_STATUS_INITIALIZED
);
11461 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
11462 VAR_INIT_STATUS_INITIALIZED
);
11463 if (op0
== NULL
|| op1
== NULL
)
11465 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
11466 for (i
= 0; i
< 2; i
++)
11468 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
11469 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
11471 VAR_INIT_STATUS_INITIALIZED
);
11472 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
11473 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
11475 : HOST_BITS_PER_WIDE_INT
== 64
11476 ? DW_OP_const8u
: DW_OP_constu
,
11477 GET_MODE_MASK (mode
), 0);
11480 if (mask
[i
] == NULL
)
11482 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
11485 add_loc_descr (&ret
, op1
);
11486 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
11487 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
11488 if (GET_CODE (rtl
) == ROTATERT
)
11490 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11491 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
11492 GET_MODE_BITSIZE (mode
), 0));
11494 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
11495 if (mask
[0] != NULL
)
11496 add_loc_descr (&ret
, mask
[0]);
11497 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
11498 if (mask
[1] != NULL
)
11500 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11501 add_loc_descr (&ret
, mask
[1]);
11502 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
11504 if (GET_CODE (rtl
) == ROTATE
)
11506 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
11507 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
11508 GET_MODE_BITSIZE (mode
), 0));
11510 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
11511 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
11515 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
11516 for DEBUG_PARAMETER_REF RTL. */
11518 static dw_loc_descr_ref
11519 parameter_ref_descriptor (rtx rtl
)
11521 dw_loc_descr_ref ret
;
11526 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
11527 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
11528 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
11531 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11532 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
11533 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11537 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
11538 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
11543 /* Helper function to get mode of MEM's address. */
11546 get_address_mode (rtx mem
)
11548 enum machine_mode mode
= GET_MODE (XEXP (mem
, 0));
11549 if (mode
!= VOIDmode
)
11551 return targetm
.addr_space
.address_mode (MEM_ADDR_SPACE (mem
));
11554 /* The following routine converts the RTL for a variable or parameter
11555 (resident in memory) into an equivalent Dwarf representation of a
11556 mechanism for getting the address of that same variable onto the top of a
11557 hypothetical "address evaluation" stack.
11559 When creating memory location descriptors, we are effectively transforming
11560 the RTL for a memory-resident object into its Dwarf postfix expression
11561 equivalent. This routine recursively descends an RTL tree, turning
11562 it into Dwarf postfix code as it goes.
11564 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
11566 MEM_MODE is the mode of the memory reference, needed to handle some
11567 autoincrement addressing modes.
11569 Return 0 if we can't represent the location. */
11572 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
,
11573 enum machine_mode mem_mode
,
11574 enum var_init_status initialized
)
11576 dw_loc_descr_ref mem_loc_result
= NULL
;
11577 enum dwarf_location_atom op
;
11578 dw_loc_descr_ref op0
, op1
;
11580 if (mode
== VOIDmode
)
11581 mode
= GET_MODE (rtl
);
11583 /* Note that for a dynamically sized array, the location we will generate a
11584 description of here will be the lowest numbered location which is
11585 actually within the array. That's *not* necessarily the same as the
11586 zeroth element of the array. */
11588 rtl
= targetm
.delegitimize_address (rtl
);
11590 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
11593 switch (GET_CODE (rtl
))
11598 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
11601 /* The case of a subreg may arise when we have a local (register)
11602 variable or a formal (register) parameter which doesn't quite fill
11603 up an entire register. For now, just assume that it is
11604 legitimate to make the Dwarf info refer to the whole register which
11605 contains the given subreg. */
11606 if (!subreg_lowpart_p (rtl
))
11608 if (GET_MODE_CLASS (mode
) == MODE_INT
11609 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (rtl
))) == MODE_INT
11610 && (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
11611 #ifdef POINTERS_EXTEND_UNSIGNED
11612 || (mode
== Pmode
&& mem_mode
!= VOIDmode
)
11615 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl
))) <= DWARF2_ADDR_SIZE
)
11617 mem_loc_result
= mem_loc_descriptor (SUBREG_REG (rtl
),
11618 GET_MODE (SUBREG_REG (rtl
)),
11619 mem_mode
, initialized
);
11624 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl
))))
11626 if (GET_MODE_SIZE (mode
) != GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl
)))
11627 && (GET_MODE_CLASS (mode
) != MODE_INT
11628 || GET_MODE_CLASS (GET_MODE (SUBREG_REG (rtl
))) != MODE_INT
))
11632 dw_die_ref type_die
;
11633 dw_loc_descr_ref cvt
;
11635 mem_loc_result
= mem_loc_descriptor (SUBREG_REG (rtl
),
11636 GET_MODE (SUBREG_REG (rtl
)),
11637 mem_mode
, initialized
);
11638 if (mem_loc_result
== NULL
)
11640 type_die
= base_type_for_mode (mode
,
11641 GET_MODE_CLASS (mode
) == MODE_INT
);
11642 if (type_die
== NULL
)
11644 mem_loc_result
= NULL
;
11647 if (GET_MODE_SIZE (mode
)
11648 != GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl
))))
11649 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11651 cvt
= new_loc_descr (DW_OP_GNU_reinterpret
, 0, 0);
11652 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11653 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
11654 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11655 add_loc_descr (&mem_loc_result
, cvt
);
11660 if (GET_MODE_CLASS (mode
) != MODE_INT
11661 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
11662 #ifdef POINTERS_EXTEND_UNSIGNED
11663 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
11667 dw_die_ref type_die
;
11671 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
11673 type_die
= base_type_for_mode (mode
,
11674 GET_MODE_CLASS (mode
) == MODE_INT
);
11675 if (type_die
== NULL
)
11677 mem_loc_result
= new_loc_descr (DW_OP_GNU_regval_type
,
11678 dbx_reg_number (rtl
), 0);
11679 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
11680 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
11681 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
11684 /* Whenever a register number forms a part of the description of the
11685 method for calculating the (dynamic) address of a memory resident
11686 object, DWARF rules require the register number be referred to as
11687 a "base register". This distinction is not based in any way upon
11688 what category of register the hardware believes the given register
11689 belongs to. This is strictly DWARF terminology we're dealing with
11690 here. Note that in cases where the location of a memory-resident
11691 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
11692 OP_CONST (0)) the actual DWARF location descriptor that we generate
11693 may just be OP_BASEREG (basereg). This may look deceptively like
11694 the object in question was allocated to a register (rather than in
11695 memory) so DWARF consumers need to be aware of the subtle
11696 distinction between OP_REG and OP_BASEREG. */
11697 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
11698 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
11699 else if (stack_realign_drap
11701 && crtl
->args
.internal_arg_pointer
== rtl
11702 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
11704 /* If RTL is internal_arg_pointer, which has been optimized
11705 out, use DRAP instead. */
11706 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
11707 VAR_INIT_STATUS_INITIALIZED
);
11713 if (GET_MODE_CLASS (mode
) != MODE_INT
)
11715 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
11716 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
11719 else if (GET_CODE (rtl
) == ZERO_EXTEND
11720 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
11721 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
11722 < HOST_BITS_PER_WIDE_INT
11723 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
11724 to expand zero extend as two shifts instead of
11726 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= 4)
11728 enum machine_mode imode
= GET_MODE (XEXP (rtl
, 0));
11729 mem_loc_result
= op0
;
11730 add_loc_descr (&mem_loc_result
,
11731 int_loc_descriptor (GET_MODE_MASK (imode
)));
11732 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
11734 else if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
11736 int shift
= DWARF2_ADDR_SIZE
11737 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
11738 shift
*= BITS_PER_UNIT
;
11739 if (GET_CODE (rtl
) == SIGN_EXTEND
)
11743 mem_loc_result
= op0
;
11744 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
11745 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
11746 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
11747 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
11749 else if (!dwarf_strict
)
11751 dw_die_ref type_die1
, type_die2
;
11752 dw_loc_descr_ref cvt
;
11754 type_die1
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
11755 GET_CODE (rtl
) == ZERO_EXTEND
);
11756 if (type_die1
== NULL
)
11758 type_die2
= base_type_for_mode (mode
, 1);
11759 if (type_die2
== NULL
)
11761 mem_loc_result
= op0
;
11762 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11763 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11764 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
11765 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11766 add_loc_descr (&mem_loc_result
, cvt
);
11767 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
11768 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
11769 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
11770 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
11771 add_loc_descr (&mem_loc_result
, cvt
);
11777 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
11778 if (new_rtl
!= rtl
)
11780 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
11782 if (mem_loc_result
!= NULL
)
11783 return mem_loc_result
;
11786 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
11787 get_address_mode (rtl
), mode
,
11788 VAR_INIT_STATUS_INITIALIZED
);
11789 if (mem_loc_result
== NULL
)
11790 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
11791 if (mem_loc_result
!= NULL
)
11793 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
11794 || GET_MODE_CLASS (mode
) != MODE_INT
)
11796 dw_die_ref type_die
;
11797 dw_loc_descr_ref deref
;
11802 = base_type_for_mode (mode
, GET_MODE_CLASS (mode
) == MODE_INT
);
11803 if (type_die
== NULL
)
11805 deref
= new_loc_descr (DW_OP_GNU_deref_type
,
11806 GET_MODE_SIZE (mode
), 0);
11807 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
11808 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
11809 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
11810 add_loc_descr (&mem_loc_result
, deref
);
11812 else if (GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
)
11813 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
11815 add_loc_descr (&mem_loc_result
,
11816 new_loc_descr (DW_OP_deref_size
,
11817 GET_MODE_SIZE (mode
), 0));
11822 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
11825 /* Some ports can transform a symbol ref into a label ref, because
11826 the symbol ref is too far away and has to be dumped into a constant
11830 if (GET_MODE_CLASS (mode
) != MODE_INT
11831 || (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
11832 #ifdef POINTERS_EXTEND_UNSIGNED
11833 && (mode
!= Pmode
|| mem_mode
== VOIDmode
)
11837 if (GET_CODE (rtl
) == SYMBOL_REF
11838 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
11840 dw_loc_descr_ref temp
;
11842 /* If this is not defined, we have no way to emit the data. */
11843 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
11846 /* We used to emit DW_OP_addr here, but that's wrong, since
11847 DW_OP_addr should be relocated by the debug info consumer,
11848 while DW_OP_GNU_push_tls_address operand should not. */
11849 temp
= new_loc_descr (DWARF2_ADDR_SIZE
== 4
11850 ? DW_OP_const4u
: DW_OP_const8u
, 0, 0);
11851 temp
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
11852 temp
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
11853 temp
->dtprel
= true;
11855 mem_loc_result
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
11856 add_loc_descr (&mem_loc_result
, temp
);
11861 if (!const_ok_for_output (rtl
))
11865 mem_loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
11866 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
11867 mem_loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
11868 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
11874 case DEBUG_IMPLICIT_PTR
:
11875 expansion_failed (NULL_TREE
, rtl
,
11876 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
11882 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
11884 if (GET_MODE_CLASS (mode
) != MODE_INT
11885 || GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11886 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
11887 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
11890 = one_reg_loc_descriptor (dbx_reg_number (ENTRY_VALUE_EXP (rtl
)),
11891 VAR_INIT_STATUS_INITIALIZED
);
11893 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
11894 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
11896 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
11897 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
11898 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
11902 gcc_unreachable ();
11905 mem_loc_result
= new_loc_descr (DW_OP_GNU_entry_value
, 0, 0);
11906 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
11907 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
11910 case DEBUG_PARAMETER_REF
:
11911 mem_loc_result
= parameter_ref_descriptor (rtl
);
11915 /* Extract the PLUS expression nested inside and fall into
11916 PLUS code below. */
11917 rtl
= XEXP (rtl
, 1);
11922 /* Turn these into a PLUS expression and fall into the PLUS code
11924 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
11925 GEN_INT (GET_CODE (rtl
) == PRE_INC
11926 ? GET_MODE_UNIT_SIZE (mem_mode
)
11927 : -GET_MODE_UNIT_SIZE (mem_mode
)));
11929 /* ... fall through ... */
11933 if (is_based_loc (rtl
)
11934 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
11935 && GET_MODE_CLASS (mode
) == MODE_INT
)
11936 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
11937 INTVAL (XEXP (rtl
, 1)),
11938 VAR_INIT_STATUS_INITIALIZED
);
11941 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
11942 VAR_INIT_STATUS_INITIALIZED
);
11943 if (mem_loc_result
== 0)
11946 if (CONST_INT_P (XEXP (rtl
, 1))
11947 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
11948 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
11951 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
11952 VAR_INIT_STATUS_INITIALIZED
);
11955 add_loc_descr (&mem_loc_result
, op1
);
11956 add_loc_descr (&mem_loc_result
,
11957 new_loc_descr (DW_OP_plus
, 0, 0));
11962 /* If a pseudo-reg is optimized away, it is possible for it to
11963 be replaced with a MEM containing a multiply or shift. */
11974 && GET_MODE_CLASS (mode
) == MODE_INT
11975 && GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
)
11977 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
11978 base_type_for_mode (mode
, 0),
12002 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12004 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12005 VAR_INIT_STATUS_INITIALIZED
);
12007 rtx rtlop1
= XEXP (rtl
, 1);
12008 if (GET_MODE (rtlop1
) != VOIDmode
12009 && GET_MODE_BITSIZE (GET_MODE (rtlop1
))
12010 < GET_MODE_BITSIZE (mode
))
12011 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
12012 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
12013 VAR_INIT_STATUS_INITIALIZED
);
12016 if (op0
== 0 || op1
== 0)
12019 mem_loc_result
= op0
;
12020 add_loc_descr (&mem_loc_result
, op1
);
12021 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12037 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12038 VAR_INIT_STATUS_INITIALIZED
);
12039 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12040 VAR_INIT_STATUS_INITIALIZED
);
12042 if (op0
== 0 || op1
== 0)
12045 mem_loc_result
= op0
;
12046 add_loc_descr (&mem_loc_result
, op1
);
12047 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12051 if (GET_MODE_SIZE (mode
) > DWARF2_ADDR_SIZE
&& !dwarf_strict
)
12053 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
12054 base_type_for_mode (mode
, 0),
12059 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12060 VAR_INIT_STATUS_INITIALIZED
);
12061 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12062 VAR_INIT_STATUS_INITIALIZED
);
12064 if (op0
== 0 || op1
== 0)
12067 mem_loc_result
= op0
;
12068 add_loc_descr (&mem_loc_result
, op1
);
12069 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12070 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
12071 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
12072 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
12073 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
12077 if (!dwarf_strict
&& GET_MODE_CLASS (mode
) == MODE_INT
)
12079 if (GET_MODE_CLASS (mode
) > DWARF2_ADDR_SIZE
)
12084 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
12085 base_type_for_mode (mode
, 1),
12103 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
12104 VAR_INIT_STATUS_INITIALIZED
);
12109 mem_loc_result
= op0
;
12110 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12114 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12115 #ifdef POINTERS_EXTEND_UNSIGNED
12117 && mem_mode
!= VOIDmode
12118 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
12122 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12126 && (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
12127 || GET_MODE_BITSIZE (mode
) == 2 * HOST_BITS_PER_WIDE_INT
))
12129 dw_die_ref type_die
= base_type_for_mode (mode
, 1);
12130 enum machine_mode amode
;
12131 if (type_die
== NULL
)
12133 amode
= mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
,
12135 if (INTVAL (rtl
) >= 0
12136 && amode
!= BLKmode
12137 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
12138 /* const DW_OP_GNU_convert <XXX> vs.
12139 DW_OP_GNU_const_type <XXX, 1, const>. */
12140 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
12141 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode
))
12143 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
12144 op0
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12145 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12146 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12147 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12148 add_loc_descr (&mem_loc_result
, op0
);
12149 return mem_loc_result
;
12151 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0,
12153 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12154 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12155 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12156 if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
12157 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
12160 mem_loc_result
->dw_loc_oprnd2
.val_class
12161 = dw_val_class_const_double
;
12162 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12163 = shwi_to_double_int (INTVAL (rtl
));
12171 dw_die_ref type_die
;
12173 /* Note that a CONST_DOUBLE rtx could represent either an integer
12174 or a floating-point constant. A CONST_DOUBLE is used whenever
12175 the constant requires more than one word in order to be
12176 adequately represented. We output CONST_DOUBLEs as blocks. */
12177 if (mode
== VOIDmode
12178 || (GET_MODE (rtl
) == VOIDmode
12179 && GET_MODE_BITSIZE (mode
) != 2 * HOST_BITS_PER_WIDE_INT
))
12181 type_die
= base_type_for_mode (mode
,
12182 GET_MODE_CLASS (mode
) == MODE_INT
);
12183 if (type_die
== NULL
)
12185 mem_loc_result
= new_loc_descr (DW_OP_GNU_const_type
, 0, 0);
12186 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12187 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12188 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12189 if (SCALAR_FLOAT_MODE_P (mode
))
12191 unsigned int length
= GET_MODE_SIZE (mode
);
12192 unsigned char *array
12193 = (unsigned char*) ggc_alloc_atomic (length
);
12195 insert_float (rtl
, array
);
12196 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
12197 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
12198 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
12199 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
12203 mem_loc_result
->dw_loc_oprnd2
.val_class
12204 = dw_val_class_const_double
;
12205 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
12206 = rtx_to_double_int (rtl
);
12212 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
12216 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
12220 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
12224 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
12228 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
12232 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
12236 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
12240 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
12244 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
12248 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
12253 if (GET_MODE_CLASS (mode
) != MODE_INT
)
12258 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
12263 if (CONST_INT_P (XEXP (rtl
, 1))
12264 && CONST_INT_P (XEXP (rtl
, 2))
12265 && ((unsigned) INTVAL (XEXP (rtl
, 1))
12266 + (unsigned) INTVAL (XEXP (rtl
, 2))
12267 <= GET_MODE_BITSIZE (mode
))
12268 && GET_MODE_CLASS (mode
) == MODE_INT
12269 && GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
12270 && GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
12273 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12274 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12277 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
12281 mem_loc_result
= op0
;
12282 size
= INTVAL (XEXP (rtl
, 1));
12283 shift
= INTVAL (XEXP (rtl
, 2));
12284 if (BITS_BIG_ENDIAN
)
12285 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
12287 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
12289 add_loc_descr (&mem_loc_result
,
12290 int_loc_descriptor (DWARF2_ADDR_SIZE
12292 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
12294 if (size
!= (int) DWARF2_ADDR_SIZE
)
12296 add_loc_descr (&mem_loc_result
,
12297 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
12298 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
12305 dw_loc_descr_ref op2
, bra_node
, drop_node
;
12306 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
12307 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
12308 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
12309 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12310 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
12311 VAR_INIT_STATUS_INITIALIZED
);
12312 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
12313 VAR_INIT_STATUS_INITIALIZED
);
12314 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
12317 mem_loc_result
= op1
;
12318 add_loc_descr (&mem_loc_result
, op2
);
12319 add_loc_descr (&mem_loc_result
, op0
);
12320 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
12321 add_loc_descr (&mem_loc_result
, bra_node
);
12322 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
12323 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
12324 add_loc_descr (&mem_loc_result
, drop_node
);
12325 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
12326 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
12331 case FLOAT_TRUNCATE
:
12333 case UNSIGNED_FLOAT
:
12338 dw_die_ref type_die
;
12339 dw_loc_descr_ref cvt
;
12341 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
12342 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
12345 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl
, 0))) == MODE_INT
12346 && (GET_CODE (rtl
) == FLOAT
12347 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)))
12348 <= DWARF2_ADDR_SIZE
))
12350 type_die
= base_type_for_mode (GET_MODE (XEXP (rtl
, 0)),
12351 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
12352 if (type_die
== NULL
)
12354 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12355 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12356 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12357 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12358 add_loc_descr (&op0
, cvt
);
12360 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
12361 if (type_die
== NULL
)
12363 cvt
= new_loc_descr (DW_OP_GNU_convert
, 0, 0);
12364 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12365 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
12366 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12367 add_loc_descr (&op0
, cvt
);
12368 if (GET_MODE_CLASS (mode
) == MODE_INT
12369 && (GET_CODE (rtl
) == FIX
12370 || GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
))
12372 op0
= convert_descriptor_to_mode (mode
, op0
);
12376 mem_loc_result
= op0
;
12383 mem_loc_result
= clz_loc_descriptor (rtl
, mode
, mem_mode
);
12388 mem_loc_result
= popcount_loc_descriptor (rtl
, mode
, mem_mode
);
12392 mem_loc_result
= bswap_loc_descriptor (rtl
, mode
, mem_mode
);
12397 mem_loc_result
= rotate_loc_descriptor (rtl
, mode
, mem_mode
);
12402 /* In theory, we could implement the above. */
12403 /* DWARF cannot represent the unsigned compare operations
12428 case FRACT_CONVERT
:
12429 case UNSIGNED_FRACT_CONVERT
:
12431 case UNSIGNED_SAT_FRACT
:
12437 case VEC_DUPLICATE
:
12441 case STRICT_LOW_PART
:
12445 /* If delegitimize_address couldn't do anything with the UNSPEC, we
12446 can't express it in the debug info. This can happen e.g. with some
12451 resolve_one_addr (&rtl
, NULL
);
12455 #ifdef ENABLE_CHECKING
12456 print_rtl (stderr
, rtl
);
12457 gcc_unreachable ();
12463 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
12464 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
12466 return mem_loc_result
;
12469 /* Return a descriptor that describes the concatenation of two locations.
12470 This is typically a complex variable. */
12472 static dw_loc_descr_ref
12473 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
12475 dw_loc_descr_ref cc_loc_result
= NULL
;
12476 dw_loc_descr_ref x0_ref
12477 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12478 dw_loc_descr_ref x1_ref
12479 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12481 if (x0_ref
== 0 || x1_ref
== 0)
12484 cc_loc_result
= x0_ref
;
12485 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
12487 add_loc_descr (&cc_loc_result
, x1_ref
);
12488 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
12490 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
12491 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
12493 return cc_loc_result
;
12496 /* Return a descriptor that describes the concatenation of N
12499 static dw_loc_descr_ref
12500 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
12503 dw_loc_descr_ref cc_loc_result
= NULL
;
12504 unsigned int n
= XVECLEN (concatn
, 0);
12506 for (i
= 0; i
< n
; ++i
)
12508 dw_loc_descr_ref ref
;
12509 rtx x
= XVECEXP (concatn
, 0, i
);
12511 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
12515 add_loc_descr (&cc_loc_result
, ref
);
12516 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
12519 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
12520 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
12522 return cc_loc_result
;
12525 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
12526 for DEBUG_IMPLICIT_PTR RTL. */
12528 static dw_loc_descr_ref
12529 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
12531 dw_loc_descr_ref ret
;
12536 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
12537 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
12538 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
12539 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
12540 ret
= new_loc_descr (DW_OP_GNU_implicit_pointer
, 0, offset
);
12541 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
12544 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
12545 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
12546 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
12550 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
12551 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
12556 /* Output a proper Dwarf location descriptor for a variable or parameter
12557 which is either allocated in a register or in a memory location. For a
12558 register, we just generate an OP_REG and the register number. For a
12559 memory location we provide a Dwarf postfix expression describing how to
12560 generate the (dynamic) address of the object onto the address stack.
12562 MODE is mode of the decl if this loc_descriptor is going to be used in
12563 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
12564 allowed, VOIDmode otherwise.
12566 If we don't know how to describe it, return 0. */
12568 static dw_loc_descr_ref
12569 loc_descriptor (rtx rtl
, enum machine_mode mode
,
12570 enum var_init_status initialized
)
12572 dw_loc_descr_ref loc_result
= NULL
;
12574 switch (GET_CODE (rtl
))
12577 /* The case of a subreg may arise when we have a local (register)
12578 variable or a formal (register) parameter which doesn't quite fill
12579 up an entire register. For now, just assume that it is
12580 legitimate to make the Dwarf info refer to the whole register which
12581 contains the given subreg. */
12582 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
12583 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
12584 GET_MODE (SUBREG_REG (rtl
)), initialized
);
12590 loc_result
= reg_loc_descriptor (rtl
, initialized
);
12594 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
12595 GET_MODE (rtl
), initialized
);
12596 if (loc_result
== NULL
)
12597 loc_result
= tls_mem_loc_descriptor (rtl
);
12598 if (loc_result
== NULL
)
12600 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
12601 if (new_rtl
!= rtl
)
12602 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
12607 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
12612 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
12617 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
12619 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
12620 if (GET_CODE (loc
) == EXPR_LIST
)
12621 loc
= XEXP (loc
, 0);
12622 loc_result
= loc_descriptor (loc
, mode
, initialized
);
12626 rtl
= XEXP (rtl
, 1);
12631 rtvec par_elems
= XVEC (rtl
, 0);
12632 int num_elem
= GET_NUM_ELEM (par_elems
);
12633 enum machine_mode mode
;
12636 /* Create the first one, so we have something to add to. */
12637 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
12638 VOIDmode
, initialized
);
12639 if (loc_result
== NULL
)
12641 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
12642 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
12643 for (i
= 1; i
< num_elem
; i
++)
12645 dw_loc_descr_ref temp
;
12647 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
12648 VOIDmode
, initialized
);
12651 add_loc_descr (&loc_result
, temp
);
12652 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
12653 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
12659 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
12660 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
12665 if (mode
== VOIDmode
)
12666 mode
= GET_MODE (rtl
);
12668 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
12670 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
12672 /* Note that a CONST_DOUBLE rtx could represent either an integer
12673 or a floating-point constant. A CONST_DOUBLE is used whenever
12674 the constant requires more than one word in order to be
12675 adequately represented. We output CONST_DOUBLEs as blocks. */
12676 loc_result
= new_loc_descr (DW_OP_implicit_value
,
12677 GET_MODE_SIZE (mode
), 0);
12678 if (SCALAR_FLOAT_MODE_P (mode
))
12680 unsigned int length
= GET_MODE_SIZE (mode
);
12681 unsigned char *array
12682 = (unsigned char*) ggc_alloc_atomic (length
);
12684 insert_float (rtl
, array
);
12685 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
12686 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
12687 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
12688 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
12692 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
12693 loc_result
->dw_loc_oprnd2
.v
.val_double
12694 = rtx_to_double_int (rtl
);
12700 if (mode
== VOIDmode
)
12701 mode
= GET_MODE (rtl
);
12703 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
12705 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
12706 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
12707 unsigned char *array
= (unsigned char *)
12708 ggc_alloc_atomic (length
* elt_size
);
12712 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
12713 switch (GET_MODE_CLASS (mode
))
12715 case MODE_VECTOR_INT
:
12716 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
12718 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
12719 double_int val
= rtx_to_double_int (elt
);
12721 if (elt_size
<= sizeof (HOST_WIDE_INT
))
12722 insert_int (double_int_to_shwi (val
), elt_size
, p
);
12725 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
12726 insert_double (val
, p
);
12731 case MODE_VECTOR_FLOAT
:
12732 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
12734 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
12735 insert_float (elt
, p
);
12740 gcc_unreachable ();
12743 loc_result
= new_loc_descr (DW_OP_implicit_value
,
12744 length
* elt_size
, 0);
12745 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
12746 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
12747 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
12748 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
12753 if (mode
== VOIDmode
12754 || GET_CODE (XEXP (rtl
, 0)) == CONST_INT
12755 || GET_CODE (XEXP (rtl
, 0)) == CONST_DOUBLE
12756 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
12758 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
12763 if (!const_ok_for_output (rtl
))
12766 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
12767 && (dwarf_version
>= 4 || !dwarf_strict
))
12769 loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
12770 loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
12771 loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
12772 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
12773 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
12777 case DEBUG_IMPLICIT_PTR
:
12778 loc_result
= implicit_ptr_descriptor (rtl
, 0);
12782 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
12783 && CONST_INT_P (XEXP (rtl
, 1)))
12786 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
12792 if ((GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE (rtl
) == mode
12793 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
12794 && dwarf_version
>= 4)
12795 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
12797 /* Value expression. */
12798 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
12800 add_loc_descr (&loc_result
,
12801 new_loc_descr (DW_OP_stack_value
, 0, 0));
12809 /* We need to figure out what section we should use as the base for the
12810 address ranges where a given location is valid.
12811 1. If this particular DECL has a section associated with it, use that.
12812 2. If this function has a section associated with it, use that.
12813 3. Otherwise, use the text section.
12814 XXX: If you split a variable across multiple sections, we won't notice. */
12816 static const char *
12817 secname_for_decl (const_tree decl
)
12819 const char *secname
;
12821 if (VAR_OR_FUNCTION_DECL_P (decl
) && DECL_SECTION_NAME (decl
))
12823 tree sectree
= DECL_SECTION_NAME (decl
);
12824 secname
= TREE_STRING_POINTER (sectree
);
12826 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
12828 tree sectree
= DECL_SECTION_NAME (current_function_decl
);
12829 secname
= TREE_STRING_POINTER (sectree
);
12831 else if (cfun
&& in_cold_section_p
)
12832 secname
= crtl
->subsections
.cold_section_label
;
12834 secname
= text_section_label
;
12839 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
12842 decl_by_reference_p (tree decl
)
12844 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
12845 || TREE_CODE (decl
) == VAR_DECL
)
12846 && DECL_BY_REFERENCE (decl
));
12849 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
12852 static dw_loc_descr_ref
12853 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
12854 enum var_init_status initialized
)
12856 int have_address
= 0;
12857 dw_loc_descr_ref descr
;
12858 enum machine_mode mode
;
12860 if (want_address
!= 2)
12862 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
12864 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
12866 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
12867 if (GET_CODE (varloc
) == EXPR_LIST
)
12868 varloc
= XEXP (varloc
, 0);
12869 mode
= GET_MODE (varloc
);
12870 if (MEM_P (varloc
))
12872 rtx addr
= XEXP (varloc
, 0);
12873 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
12874 mode
, initialized
);
12879 rtx x
= avoid_constant_pool_reference (varloc
);
12881 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
12886 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
12893 if (GET_CODE (varloc
) == VAR_LOCATION
)
12894 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
12896 mode
= DECL_MODE (loc
);
12897 descr
= loc_descriptor (varloc
, mode
, initialized
);
12904 if (want_address
== 2 && !have_address
12905 && (dwarf_version
>= 4 || !dwarf_strict
))
12907 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
12909 expansion_failed (loc
, NULL_RTX
,
12910 "DWARF address size mismatch");
12913 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
12916 /* Show if we can't fill the request for an address. */
12917 if (want_address
&& !have_address
)
12919 expansion_failed (loc
, NULL_RTX
,
12920 "Want address and only have value");
12924 /* If we've got an address and don't want one, dereference. */
12925 if (!want_address
&& have_address
)
12927 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
12928 enum dwarf_location_atom op
;
12930 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
12932 expansion_failed (loc
, NULL_RTX
,
12933 "DWARF address size mismatch");
12936 else if (size
== DWARF2_ADDR_SIZE
)
12939 op
= DW_OP_deref_size
;
12941 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
12947 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
12948 if it is not possible. */
12950 static dw_loc_descr_ref
12951 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
12953 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
12954 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
12955 else if (dwarf_version
>= 3 || !dwarf_strict
)
12956 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
12961 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
12962 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
12964 static dw_loc_descr_ref
12965 dw_sra_loc_expr (tree decl
, rtx loc
)
12968 unsigned int padsize
= 0;
12969 dw_loc_descr_ref descr
, *descr_tail
;
12970 unsigned HOST_WIDE_INT decl_size
;
12972 enum var_init_status initialized
;
12974 if (DECL_SIZE (decl
) == NULL
12975 || !host_integerp (DECL_SIZE (decl
), 1))
12978 decl_size
= tree_low_cst (DECL_SIZE (decl
), 1);
12980 descr_tail
= &descr
;
12982 for (p
= loc
; p
; p
= XEXP (p
, 1))
12984 unsigned int bitsize
= decl_piece_bitsize (p
);
12985 rtx loc_note
= *decl_piece_varloc_ptr (p
);
12986 dw_loc_descr_ref cur_descr
;
12987 dw_loc_descr_ref
*tail
, last
= NULL
;
12988 unsigned int opsize
= 0;
12990 if (loc_note
== NULL_RTX
12991 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
12993 padsize
+= bitsize
;
12996 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
12997 varloc
= NOTE_VAR_LOCATION (loc_note
);
12998 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
12999 if (cur_descr
== NULL
)
13001 padsize
+= bitsize
;
13005 /* Check that cur_descr either doesn't use
13006 DW_OP_*piece operations, or their sum is equal
13007 to bitsize. Otherwise we can't embed it. */
13008 for (tail
= &cur_descr
; *tail
!= NULL
;
13009 tail
= &(*tail
)->dw_loc_next
)
13010 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
13012 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
13016 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
13018 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
13022 if (last
!= NULL
&& opsize
!= bitsize
)
13024 padsize
+= bitsize
;
13028 /* If there is a hole, add DW_OP_*piece after empty DWARF
13029 expression, which means that those bits are optimized out. */
13032 if (padsize
> decl_size
)
13034 decl_size
-= padsize
;
13035 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
13036 if (*descr_tail
== NULL
)
13038 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13041 *descr_tail
= cur_descr
;
13043 if (bitsize
> decl_size
)
13045 decl_size
-= bitsize
;
13048 HOST_WIDE_INT offset
= 0;
13049 if (GET_CODE (varloc
) == VAR_LOCATION
13050 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
13052 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
13053 if (GET_CODE (varloc
) == EXPR_LIST
)
13054 varloc
= XEXP (varloc
, 0);
13058 if (GET_CODE (varloc
) == CONST
13059 || GET_CODE (varloc
) == SIGN_EXTEND
13060 || GET_CODE (varloc
) == ZERO_EXTEND
)
13061 varloc
= XEXP (varloc
, 0);
13062 else if (GET_CODE (varloc
) == SUBREG
)
13063 varloc
= SUBREG_REG (varloc
);
13068 /* DW_OP_bit_size offset should be zero for register
13069 or implicit location descriptions and empty location
13070 descriptions, but for memory addresses needs big endian
13072 if (MEM_P (varloc
))
13074 unsigned HOST_WIDE_INT memsize
13075 = MEM_SIZE (varloc
) * BITS_PER_UNIT
;
13076 if (memsize
!= bitsize
)
13078 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
13079 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
13081 if (memsize
< bitsize
)
13083 if (BITS_BIG_ENDIAN
)
13084 offset
= memsize
- bitsize
;
13088 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
13089 if (*descr_tail
== NULL
)
13091 descr_tail
= &(*descr_tail
)->dw_loc_next
;
13095 /* If there were any non-empty expressions, add padding till the end of
13097 if (descr
!= NULL
&& decl_size
!= 0)
13099 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
13100 if (*descr_tail
== NULL
)
13106 /* Return the dwarf representation of the location list LOC_LIST of
13107 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
13110 static dw_loc_list_ref
13111 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
13113 const char *endname
, *secname
;
13115 enum var_init_status initialized
;
13116 struct var_loc_node
*node
;
13117 dw_loc_descr_ref descr
;
13118 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
13119 dw_loc_list_ref list
= NULL
;
13120 dw_loc_list_ref
*listp
= &list
;
13122 /* Now that we know what section we are using for a base,
13123 actually construct the list of locations.
13124 The first location information is what is passed to the
13125 function that creates the location list, and the remaining
13126 locations just get added on to that list.
13127 Note that we only know the start address for a location
13128 (IE location changes), so to build the range, we use
13129 the range [current location start, next location start].
13130 This means we have to special case the last node, and generate
13131 a range of [last location start, end of function label]. */
13133 secname
= secname_for_decl (decl
);
13135 for (node
= loc_list
->first
; node
; node
= node
->next
)
13136 if (GET_CODE (node
->loc
) == EXPR_LIST
13137 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
13139 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13141 /* This requires DW_OP_{,bit_}piece, which is not usable
13142 inside DWARF expressions. */
13143 if (want_address
!= 2)
13145 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13151 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13152 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13153 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
13157 bool range_across_switch
= false;
13158 /* If section switch happens in between node->label
13159 and node->next->label (or end of function) and
13160 we can't emit it as a single entry list,
13161 emit two ranges, first one ending at the end
13162 of first partition and second one starting at the
13163 beginning of second partition. */
13164 if (node
== loc_list
->last_before_switch
13165 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
13166 && current_function_decl
)
13168 endname
= cfun
->fde
->dw_fde_end
;
13169 range_across_switch
= true;
13171 /* The variable has a location between NODE->LABEL and
13172 NODE->NEXT->LABEL. */
13173 else if (node
->next
)
13174 endname
= node
->next
->label
;
13175 /* If the variable has a location at the last label
13176 it keeps its location until the end of function. */
13177 else if (!current_function_decl
)
13178 endname
= text_end_label
;
13181 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
13182 current_function_funcdef_no
);
13183 endname
= ggc_strdup (label_id
);
13186 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
13187 if (TREE_CODE (decl
) == PARM_DECL
13188 && node
== loc_list
->first
13189 && GET_CODE (node
->loc
) == NOTE
13190 && strcmp (node
->label
, endname
) == 0)
13191 (*listp
)->force
= true;
13192 listp
= &(*listp
)->dw_loc_next
;
13194 if (range_across_switch
)
13196 if (GET_CODE (node
->loc
) == EXPR_LIST
)
13197 descr
= dw_sra_loc_expr (decl
, node
->loc
);
13200 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
13201 varloc
= NOTE_VAR_LOCATION (node
->loc
);
13202 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
13205 gcc_assert (descr
);
13206 /* The variable has a location between NODE->LABEL and
13207 NODE->NEXT->LABEL. */
13209 endname
= node
->next
->label
;
13211 endname
= cfun
->fde
->dw_fde_second_end
;
13212 *listp
= new_loc_list (descr
,
13213 cfun
->fde
->dw_fde_second_begin
,
13215 listp
= &(*listp
)->dw_loc_next
;
13220 /* Try to avoid the overhead of a location list emitting a location
13221 expression instead, but only if we didn't have more than one
13222 location entry in the first place. If some entries were not
13223 representable, we don't want to pretend a single entry that was
13224 applies to the entire scope in which the variable is
13226 if (list
&& loc_list
->first
->next
)
13232 /* Return if the loc_list has only single element and thus can be represented
13233 as location description. */
13236 single_element_loc_list_p (dw_loc_list_ref list
)
13238 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
13239 return !list
->ll_symbol
;
13242 /* To each location in list LIST add loc descr REF. */
13245 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
13247 dw_loc_descr_ref copy
;
13248 add_loc_descr (&list
->expr
, ref
);
13249 list
= list
->dw_loc_next
;
13252 copy
= ggc_alloc_dw_loc_descr_node ();
13253 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
13254 add_loc_descr (&list
->expr
, copy
);
13255 while (copy
->dw_loc_next
)
13257 dw_loc_descr_ref new_copy
= ggc_alloc_dw_loc_descr_node ();
13258 memcpy (new_copy
, copy
->dw_loc_next
, sizeof (dw_loc_descr_node
));
13259 copy
->dw_loc_next
= new_copy
;
13262 list
= list
->dw_loc_next
;
13266 /* Given two lists RET and LIST
13267 produce location list that is result of adding expression in LIST
13268 to expression in RET on each possition in program.
13269 Might be destructive on both RET and LIST.
13271 TODO: We handle only simple cases of RET or LIST having at most one
13272 element. General case would inolve sorting the lists in program order
13273 and merging them that will need some additional work.
13274 Adding that will improve quality of debug info especially for SRA-ed
13278 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
13287 if (!list
->dw_loc_next
)
13289 add_loc_descr_to_each (*ret
, list
->expr
);
13292 if (!(*ret
)->dw_loc_next
)
13294 add_loc_descr_to_each (list
, (*ret
)->expr
);
13298 expansion_failed (NULL_TREE
, NULL_RTX
,
13299 "Don't know how to merge two non-trivial"
13300 " location lists.\n");
13305 /* LOC is constant expression. Try a luck, look it up in constant
13306 pool and return its loc_descr of its address. */
13308 static dw_loc_descr_ref
13309 cst_pool_loc_descr (tree loc
)
13311 /* Get an RTL for this, if something has been emitted. */
13312 rtx rtl
= lookup_constant_def (loc
);
13314 if (!rtl
|| !MEM_P (rtl
))
13319 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
13321 /* TODO: We might get more coverage if we was actually delaying expansion
13322 of all expressions till end of compilation when constant pools are fully
13324 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
13326 expansion_failed (loc
, NULL_RTX
,
13327 "CST value in contant pool but not marked.");
13330 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
13331 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
13334 /* Return dw_loc_list representing address of addr_expr LOC
13335 by looking for innder INDIRECT_REF expression and turing it
13336 into simple arithmetics. */
13338 static dw_loc_list_ref
13339 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
)
13342 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
13343 enum machine_mode mode
;
13345 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (loc
));
13346 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
13348 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
13349 &bitsize
, &bitpos
, &offset
, &mode
,
13350 &unsignedp
, &volatilep
, false);
13352 if (bitpos
% BITS_PER_UNIT
)
13354 expansion_failed (loc
, NULL_RTX
, "bitfield access");
13357 if (!INDIRECT_REF_P (obj
))
13359 expansion_failed (obj
,
13360 NULL_RTX
, "no indirect ref in inner refrence");
13363 if (!offset
&& !bitpos
)
13364 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1);
13366 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
13367 && (dwarf_version
>= 4 || !dwarf_strict
))
13369 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0);
13374 /* Variable offset. */
13375 list_ret1
= loc_list_from_tree (offset
, 0);
13376 if (list_ret1
== 0)
13378 add_loc_list (&list_ret
, list_ret1
);
13381 add_loc_descr_to_each (list_ret
,
13382 new_loc_descr (DW_OP_plus
, 0, 0));
13384 bytepos
= bitpos
/ BITS_PER_UNIT
;
13386 add_loc_descr_to_each (list_ret
,
13387 new_loc_descr (DW_OP_plus_uconst
,
13389 else if (bytepos
< 0)
13390 loc_list_plus_const (list_ret
, bytepos
);
13391 add_loc_descr_to_each (list_ret
,
13392 new_loc_descr (DW_OP_stack_value
, 0, 0));
13398 /* Generate Dwarf location list representing LOC.
13399 If WANT_ADDRESS is false, expression computing LOC will be computed
13400 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
13401 if WANT_ADDRESS is 2, expression computing address useable in location
13402 will be returned (i.e. DW_OP_reg can be used
13403 to refer to register values). */
13405 static dw_loc_list_ref
13406 loc_list_from_tree (tree loc
, int want_address
)
13408 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
13409 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
13410 int have_address
= 0;
13411 enum dwarf_location_atom op
;
13413 /* ??? Most of the time we do not take proper care for sign/zero
13414 extending the values properly. Hopefully this won't be a real
13417 switch (TREE_CODE (loc
))
13420 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
13423 case PLACEHOLDER_EXPR
:
13424 /* This case involves extracting fields from an object to determine the
13425 position of other fields. We don't try to encode this here. The
13426 only user of this is Ada, which encodes the needed information using
13427 the names of types. */
13428 expansion_failed (loc
, NULL_RTX
, "PLACEHOLDER_EXPR");
13432 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
13433 /* There are no opcodes for these operations. */
13436 case PREINCREMENT_EXPR
:
13437 case PREDECREMENT_EXPR
:
13438 case POSTINCREMENT_EXPR
:
13439 case POSTDECREMENT_EXPR
:
13440 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
13441 /* There are no opcodes for these operations. */
13445 /* If we already want an address, see if there is INDIRECT_REF inside
13446 e.g. for &this->field. */
13449 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
13450 (loc
, want_address
== 2);
13453 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
13454 && (ret
= cst_pool_loc_descr (loc
)))
13457 /* Otherwise, process the argument and look for the address. */
13458 if (!list_ret
&& !ret
)
13459 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 1);
13463 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
13469 if (DECL_THREAD_LOCAL_P (loc
))
13472 enum dwarf_location_atom first_op
;
13473 enum dwarf_location_atom second_op
;
13474 bool dtprel
= false;
13476 if (targetm
.have_tls
)
13478 /* If this is not defined, we have no way to emit the
13480 if (!targetm
.asm_out
.output_dwarf_dtprel
)
13483 /* The way DW_OP_GNU_push_tls_address is specified, we
13484 can only look up addresses of objects in the current
13485 module. We used DW_OP_addr as first op, but that's
13486 wrong, because DW_OP_addr is relocated by the debug
13487 info consumer, while DW_OP_GNU_push_tls_address
13488 operand shouldn't be. */
13489 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
13491 first_op
= DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
;
13493 second_op
= DW_OP_GNU_push_tls_address
;
13497 if (!targetm
.emutls
.debug_form_tls_address
13498 || !(dwarf_version
>= 3 || !dwarf_strict
))
13500 /* We stuffed the control variable into the DECL_VALUE_EXPR
13501 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
13502 no longer appear in gimple code. We used the control
13503 variable in specific so that we could pick it up here. */
13504 loc
= DECL_VALUE_EXPR (loc
);
13505 first_op
= DW_OP_addr
;
13506 second_op
= DW_OP_form_tls_address
;
13509 rtl
= rtl_for_decl_location (loc
);
13510 if (rtl
== NULL_RTX
)
13515 rtl
= XEXP (rtl
, 0);
13516 if (! CONSTANT_P (rtl
))
13519 ret
= new_loc_descr (first_op
, 0, 0);
13520 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
13521 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
13522 ret
->dtprel
= dtprel
;
13524 ret1
= new_loc_descr (second_op
, 0, 0);
13525 add_loc_descr (&ret
, ret1
);
13534 if (DECL_HAS_VALUE_EXPR_P (loc
))
13535 return loc_list_from_tree (DECL_VALUE_EXPR (loc
),
13539 case FUNCTION_DECL
:
13542 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
13544 if (loc_list
&& loc_list
->first
)
13546 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
13547 have_address
= want_address
!= 0;
13550 rtl
= rtl_for_decl_location (loc
);
13551 if (rtl
== NULL_RTX
)
13553 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
13556 else if (CONST_INT_P (rtl
))
13558 HOST_WIDE_INT val
= INTVAL (rtl
);
13559 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
13560 val
&= GET_MODE_MASK (DECL_MODE (loc
));
13561 ret
= int_loc_descriptor (val
);
13563 else if (GET_CODE (rtl
) == CONST_STRING
)
13565 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
13568 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
13570 ret
= new_loc_descr (DW_OP_addr
, 0, 0);
13571 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
13572 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
13576 enum machine_mode mode
, mem_mode
;
13578 /* Certain constructs can only be represented at top-level. */
13579 if (want_address
== 2)
13581 ret
= loc_descriptor (rtl
, VOIDmode
,
13582 VAR_INIT_STATUS_INITIALIZED
);
13587 mode
= GET_MODE (rtl
);
13588 mem_mode
= VOIDmode
;
13592 mode
= get_address_mode (rtl
);
13593 rtl
= XEXP (rtl
, 0);
13596 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
13597 VAR_INIT_STATUS_INITIALIZED
);
13600 expansion_failed (loc
, rtl
,
13601 "failed to produce loc descriptor for rtl");
13608 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
13612 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
13616 case COMPOUND_EXPR
:
13617 return loc_list_from_tree (TREE_OPERAND (loc
, 1), want_address
);
13620 case VIEW_CONVERT_EXPR
:
13623 return loc_list_from_tree (TREE_OPERAND (loc
, 0), want_address
);
13625 case COMPONENT_REF
:
13626 case BIT_FIELD_REF
:
13628 case ARRAY_RANGE_REF
:
13629 case REALPART_EXPR
:
13630 case IMAGPART_EXPR
:
13633 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
13634 enum machine_mode mode
;
13636 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (loc
));
13638 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
13639 &unsignedp
, &volatilep
, false);
13641 gcc_assert (obj
!= loc
);
13643 list_ret
= loc_list_from_tree (obj
,
13645 && !bitpos
&& !offset
? 2 : 1);
13646 /* TODO: We can extract value of the small expression via shifting even
13647 for nonzero bitpos. */
13650 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
13652 expansion_failed (loc
, NULL_RTX
,
13653 "bitfield access");
13657 if (offset
!= NULL_TREE
)
13659 /* Variable offset. */
13660 list_ret1
= loc_list_from_tree (offset
, 0);
13661 if (list_ret1
== 0)
13663 add_loc_list (&list_ret
, list_ret1
);
13666 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
13669 bytepos
= bitpos
/ BITS_PER_UNIT
;
13671 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
13672 else if (bytepos
< 0)
13673 loc_list_plus_const (list_ret
, bytepos
);
13680 if ((want_address
|| !host_integerp (loc
, 0))
13681 && (ret
= cst_pool_loc_descr (loc
)))
13683 else if (want_address
== 2
13684 && host_integerp (loc
, 0)
13685 && (ret
= address_of_int_loc_descriptor
13686 (int_size_in_bytes (TREE_TYPE (loc
)),
13687 tree_low_cst (loc
, 0))))
13689 else if (host_integerp (loc
, 0))
13690 ret
= int_loc_descriptor (tree_low_cst (loc
, 0));
13693 expansion_failed (loc
, NULL_RTX
,
13694 "Integer operand is not host integer");
13703 if ((ret
= cst_pool_loc_descr (loc
)))
13706 /* We can construct small constants here using int_loc_descriptor. */
13707 expansion_failed (loc
, NULL_RTX
,
13708 "constructor or constant not in constant pool");
13711 case TRUTH_AND_EXPR
:
13712 case TRUTH_ANDIF_EXPR
:
13717 case TRUTH_XOR_EXPR
:
13722 case TRUTH_OR_EXPR
:
13723 case TRUTH_ORIF_EXPR
:
13728 case FLOOR_DIV_EXPR
:
13729 case CEIL_DIV_EXPR
:
13730 case ROUND_DIV_EXPR
:
13731 case TRUNC_DIV_EXPR
:
13732 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
13741 case FLOOR_MOD_EXPR
:
13742 case CEIL_MOD_EXPR
:
13743 case ROUND_MOD_EXPR
:
13744 case TRUNC_MOD_EXPR
:
13745 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
13750 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
13751 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
13752 if (list_ret
== 0 || list_ret1
== 0)
13755 add_loc_list (&list_ret
, list_ret1
);
13758 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
13759 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
13760 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
13761 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
13762 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
13774 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
13777 case POINTER_PLUS_EXPR
:
13779 if (host_integerp (TREE_OPERAND (loc
, 1), 0))
13781 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
13785 loc_list_plus_const (list_ret
, tree_low_cst (TREE_OPERAND (loc
, 1), 0));
13793 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
13800 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
13807 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
13814 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
13829 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
13830 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
13831 if (list_ret
== 0 || list_ret1
== 0)
13834 add_loc_list (&list_ret
, list_ret1
);
13837 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
13840 case TRUTH_NOT_EXPR
:
13854 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
13858 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
13864 const enum tree_code code
=
13865 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
13867 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
13868 build2 (code
, integer_type_node
,
13869 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
13870 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
13873 /* ... fall through ... */
13877 dw_loc_descr_ref lhs
13878 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
13879 dw_loc_list_ref rhs
13880 = loc_list_from_tree (TREE_OPERAND (loc
, 2), 0);
13881 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
13883 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
13884 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
13887 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
13888 add_loc_descr_to_each (list_ret
, bra_node
);
13890 add_loc_list (&list_ret
, rhs
);
13891 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
13892 add_loc_descr_to_each (list_ret
, jump_node
);
13894 add_loc_descr_to_each (list_ret
, lhs
);
13895 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13896 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
13898 /* ??? Need a node to point the skip at. Use a nop. */
13899 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
13900 add_loc_descr_to_each (list_ret
, tmp
);
13901 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13902 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
13906 case FIX_TRUNC_EXPR
:
13910 /* Leave front-end specific codes as simply unknown. This comes
13911 up, for instance, with the C STMT_EXPR. */
13912 if ((unsigned int) TREE_CODE (loc
)
13913 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
13915 expansion_failed (loc
, NULL_RTX
,
13916 "language specific tree node");
13920 #ifdef ENABLE_CHECKING
13921 /* Otherwise this is a generic code; we should just lists all of
13922 these explicitly. We forgot one. */
13923 gcc_unreachable ();
13925 /* In a release build, we want to degrade gracefully: better to
13926 generate incomplete debugging information than to crash. */
13931 if (!ret
&& !list_ret
)
13934 if (want_address
== 2 && !have_address
13935 && (dwarf_version
>= 4 || !dwarf_strict
))
13937 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
13939 expansion_failed (loc
, NULL_RTX
,
13940 "DWARF address size mismatch");
13944 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
13946 add_loc_descr_to_each (list_ret
,
13947 new_loc_descr (DW_OP_stack_value
, 0, 0));
13950 /* Show if we can't fill the request for an address. */
13951 if (want_address
&& !have_address
)
13953 expansion_failed (loc
, NULL_RTX
,
13954 "Want address and only have value");
13958 gcc_assert (!ret
|| !list_ret
);
13960 /* If we've got an address and don't want one, dereference. */
13961 if (!want_address
&& have_address
)
13963 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
13965 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
13967 expansion_failed (loc
, NULL_RTX
,
13968 "DWARF address size mismatch");
13971 else if (size
== DWARF2_ADDR_SIZE
)
13974 op
= DW_OP_deref_size
;
13977 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
13979 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
13982 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
13987 /* Same as above but return only single location expression. */
13988 static dw_loc_descr_ref
13989 loc_descriptor_from_tree (tree loc
, int want_address
)
13991 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
);
13994 if (ret
->dw_loc_next
)
13996 expansion_failed (loc
, NULL_RTX
,
13997 "Location list where only loc descriptor needed");
14003 /* Given a value, round it up to the lowest multiple of `boundary'
14004 which is not less than the value itself. */
14006 static inline HOST_WIDE_INT
14007 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
14009 return (((value
+ boundary
- 1) / boundary
) * boundary
);
14012 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
14013 pointer to the declared type for the relevant field variable, or return
14014 `integer_type_node' if the given node turns out to be an
14015 ERROR_MARK node. */
14018 field_type (const_tree decl
)
14022 if (TREE_CODE (decl
) == ERROR_MARK
)
14023 return integer_type_node
;
14025 type
= DECL_BIT_FIELD_TYPE (decl
);
14026 if (type
== NULL_TREE
)
14027 type
= TREE_TYPE (decl
);
14032 /* Given a pointer to a tree node, return the alignment in bits for
14033 it, or else return BITS_PER_WORD if the node actually turns out to
14034 be an ERROR_MARK node. */
14036 static inline unsigned
14037 simple_type_align_in_bits (const_tree type
)
14039 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
14042 static inline unsigned
14043 simple_decl_align_in_bits (const_tree decl
)
14045 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
14048 /* Return the result of rounding T up to ALIGN. */
14050 static inline double_int
14051 round_up_to_align (double_int t
, unsigned int align
)
14053 double_int alignd
= uhwi_to_double_int (align
);
14054 t
= double_int_add (t
, alignd
);
14055 t
= double_int_add (t
, double_int_minus_one
);
14056 t
= double_int_div (t
, alignd
, true, TRUNC_DIV_EXPR
);
14057 t
= double_int_mul (t
, alignd
);
14061 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
14062 lowest addressed byte of the "containing object" for the given FIELD_DECL,
14063 or return 0 if we are unable to determine what that offset is, either
14064 because the argument turns out to be a pointer to an ERROR_MARK node, or
14065 because the offset is actually variable. (We can't handle the latter case
14068 static HOST_WIDE_INT
14069 field_byte_offset (const_tree decl
)
14071 double_int object_offset_in_bits
;
14072 double_int object_offset_in_bytes
;
14073 double_int bitpos_int
;
14075 if (TREE_CODE (decl
) == ERROR_MARK
)
14078 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
14080 /* We cannot yet cope with fields whose positions are variable, so
14081 for now, when we see such things, we simply return 0. Someday, we may
14082 be able to handle such cases, but it will be damn difficult. */
14083 if (TREE_CODE (bit_position (decl
)) != INTEGER_CST
)
14086 bitpos_int
= tree_to_double_int (bit_position (decl
));
14088 #ifdef PCC_BITFIELD_TYPE_MATTERS
14089 if (PCC_BITFIELD_TYPE_MATTERS
)
14092 tree field_size_tree
;
14093 double_int deepest_bitpos
;
14094 double_int field_size_in_bits
;
14095 unsigned int type_align_in_bits
;
14096 unsigned int decl_align_in_bits
;
14097 double_int type_size_in_bits
;
14099 type
= field_type (decl
);
14100 type_size_in_bits
= double_int_type_size_in_bits (type
);
14101 type_align_in_bits
= simple_type_align_in_bits (type
);
14103 field_size_tree
= DECL_SIZE (decl
);
14105 /* The size could be unspecified if there was an error, or for
14106 a flexible array member. */
14107 if (!field_size_tree
)
14108 field_size_tree
= bitsize_zero_node
;
14110 /* If the size of the field is not constant, use the type size. */
14111 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
14112 field_size_in_bits
= tree_to_double_int (field_size_tree
);
14114 field_size_in_bits
= type_size_in_bits
;
14116 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
14118 /* The GCC front-end doesn't make any attempt to keep track of the
14119 starting bit offset (relative to the start of the containing
14120 structure type) of the hypothetical "containing object" for a
14121 bit-field. Thus, when computing the byte offset value for the
14122 start of the "containing object" of a bit-field, we must deduce
14123 this information on our own. This can be rather tricky to do in
14124 some cases. For example, handling the following structure type
14125 definition when compiling for an i386/i486 target (which only
14126 aligns long long's to 32-bit boundaries) can be very tricky:
14128 struct S { int field1; long long field2:31; };
14130 Fortunately, there is a simple rule-of-thumb which can be used
14131 in such cases. When compiling for an i386/i486, GCC will
14132 allocate 8 bytes for the structure shown above. It decides to
14133 do this based upon one simple rule for bit-field allocation.
14134 GCC allocates each "containing object" for each bit-field at
14135 the first (i.e. lowest addressed) legitimate alignment boundary
14136 (based upon the required minimum alignment for the declared
14137 type of the field) which it can possibly use, subject to the
14138 condition that there is still enough available space remaining
14139 in the containing object (when allocated at the selected point)
14140 to fully accommodate all of the bits of the bit-field itself.
14142 This simple rule makes it obvious why GCC allocates 8 bytes for
14143 each object of the structure type shown above. When looking
14144 for a place to allocate the "containing object" for `field2',
14145 the compiler simply tries to allocate a 64-bit "containing
14146 object" at each successive 32-bit boundary (starting at zero)
14147 until it finds a place to allocate that 64- bit field such that
14148 at least 31 contiguous (and previously unallocated) bits remain
14149 within that selected 64 bit field. (As it turns out, for the
14150 example above, the compiler finds it is OK to allocate the
14151 "containing object" 64-bit field at bit-offset zero within the
14154 Here we attempt to work backwards from the limited set of facts
14155 we're given, and we try to deduce from those facts, where GCC
14156 must have believed that the containing object started (within
14157 the structure type). The value we deduce is then used (by the
14158 callers of this routine) to generate DW_AT_location and
14159 DW_AT_bit_offset attributes for fields (both bit-fields and, in
14160 the case of DW_AT_location, regular fields as well). */
14162 /* Figure out the bit-distance from the start of the structure to
14163 the "deepest" bit of the bit-field. */
14164 deepest_bitpos
= double_int_add (bitpos_int
, field_size_in_bits
);
14166 /* This is the tricky part. Use some fancy footwork to deduce
14167 where the lowest addressed bit of the containing object must
14169 object_offset_in_bits
14170 = double_int_sub (deepest_bitpos
, type_size_in_bits
);
14172 /* Round up to type_align by default. This works best for
14174 object_offset_in_bits
14175 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
14177 if (double_int_ucmp (object_offset_in_bits
, bitpos_int
) > 0)
14179 object_offset_in_bits
14180 = double_int_sub (deepest_bitpos
, type_size_in_bits
);
14182 /* Round up to decl_align instead. */
14183 object_offset_in_bits
14184 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
14188 #endif /* PCC_BITFIELD_TYPE_MATTERS */
14189 object_offset_in_bits
= bitpos_int
;
14191 object_offset_in_bytes
14192 = double_int_div (object_offset_in_bits
,
14193 uhwi_to_double_int (BITS_PER_UNIT
), true,
14195 return double_int_to_shwi (object_offset_in_bytes
);
14198 /* The following routines define various Dwarf attributes and any data
14199 associated with them. */
14201 /* Add a location description attribute value to a DIE.
14203 This emits location attributes suitable for whole variables and
14204 whole parameters. Note that the location attributes for struct fields are
14205 generated by the routine `data_member_location_attribute' below. */
14208 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
14209 dw_loc_list_ref descr
)
14213 if (single_element_loc_list_p (descr
))
14214 add_AT_loc (die
, attr_kind
, descr
->expr
);
14216 add_AT_loc_list (die
, attr_kind
, descr
);
14219 /* Add DW_AT_accessibility attribute to DIE if needed. */
14222 add_accessibility_attribute (dw_die_ref die
, tree decl
)
14224 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
14225 children, otherwise the default is DW_ACCESS_public. In DWARF2
14226 the default has always been DW_ACCESS_public. */
14227 if (TREE_PROTECTED (decl
))
14228 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
14229 else if (TREE_PRIVATE (decl
))
14231 if (dwarf_version
== 2
14232 || die
->die_parent
== NULL
14233 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
14234 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
14236 else if (dwarf_version
> 2
14238 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
14239 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
14242 /* Attach the specialized form of location attribute used for data members of
14243 struct and union types. In the special case of a FIELD_DECL node which
14244 represents a bit-field, the "offset" part of this special location
14245 descriptor must indicate the distance in bytes from the lowest-addressed
14246 byte of the containing struct or union type to the lowest-addressed byte of
14247 the "containing object" for the bit-field. (See the `field_byte_offset'
14250 For any given bit-field, the "containing object" is a hypothetical object
14251 (of some integral or enum type) within which the given bit-field lives. The
14252 type of this hypothetical "containing object" is always the same as the
14253 declared type of the individual bit-field itself (for GCC anyway... the
14254 DWARF spec doesn't actually mandate this). Note that it is the size (in
14255 bytes) of the hypothetical "containing object" which will be given in the
14256 DW_AT_byte_size attribute for this bit-field. (See the
14257 `byte_size_attribute' function below.) It is also used when calculating the
14258 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
14259 function below.) */
14262 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
14264 HOST_WIDE_INT offset
;
14265 dw_loc_descr_ref loc_descr
= 0;
14267 if (TREE_CODE (decl
) == TREE_BINFO
)
14269 /* We're working on the TAG_inheritance for a base class. */
14270 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
14272 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
14273 aren't at a fixed offset from all (sub)objects of the same
14274 type. We need to extract the appropriate offset from our
14275 vtable. The following dwarf expression means
14277 BaseAddr = ObAddr + *((*ObAddr) - Offset)
14279 This is specific to the V3 ABI, of course. */
14281 dw_loc_descr_ref tmp
;
14283 /* Make a copy of the object address. */
14284 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
14285 add_loc_descr (&loc_descr
, tmp
);
14287 /* Extract the vtable address. */
14288 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
14289 add_loc_descr (&loc_descr
, tmp
);
14291 /* Calculate the address of the offset. */
14292 offset
= tree_low_cst (BINFO_VPTR_FIELD (decl
), 0);
14293 gcc_assert (offset
< 0);
14295 tmp
= int_loc_descriptor (-offset
);
14296 add_loc_descr (&loc_descr
, tmp
);
14297 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
14298 add_loc_descr (&loc_descr
, tmp
);
14300 /* Extract the offset. */
14301 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
14302 add_loc_descr (&loc_descr
, tmp
);
14304 /* Add it to the object address. */
14305 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
14306 add_loc_descr (&loc_descr
, tmp
);
14309 offset
= tree_low_cst (BINFO_OFFSET (decl
), 0);
14312 offset
= field_byte_offset (decl
);
14316 if (dwarf_version
> 2)
14318 /* Don't need to output a location expression, just the constant. */
14320 add_AT_int (die
, DW_AT_data_member_location
, offset
);
14322 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
14327 enum dwarf_location_atom op
;
14329 /* The DWARF2 standard says that we should assume that the structure
14330 address is already on the stack, so we can specify a structure
14331 field address by using DW_OP_plus_uconst. */
14333 #ifdef MIPS_DEBUGGING_INFO
14334 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
14335 operator correctly. It works only if we leave the offset on the
14339 op
= DW_OP_plus_uconst
;
14342 loc_descr
= new_loc_descr (op
, offset
, 0);
14346 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
14349 /* Writes integer values to dw_vec_const array. */
14352 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
14356 *dest
++ = val
& 0xff;
14362 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
14364 static HOST_WIDE_INT
14365 extract_int (const unsigned char *src
, unsigned int size
)
14367 HOST_WIDE_INT val
= 0;
14373 val
|= *--src
& 0xff;
14379 /* Writes double_int values to dw_vec_const array. */
14382 insert_double (double_int val
, unsigned char *dest
)
14384 unsigned char *p0
= dest
;
14385 unsigned char *p1
= dest
+ sizeof (HOST_WIDE_INT
);
14387 if (WORDS_BIG_ENDIAN
)
14393 insert_int ((HOST_WIDE_INT
) val
.low
, sizeof (HOST_WIDE_INT
), p0
);
14394 insert_int ((HOST_WIDE_INT
) val
.high
, sizeof (HOST_WIDE_INT
), p1
);
14397 /* Writes floating point values to dw_vec_const array. */
14400 insert_float (const_rtx rtl
, unsigned char *array
)
14402 REAL_VALUE_TYPE rv
;
14406 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
14407 real_to_target (val
, &rv
, GET_MODE (rtl
));
14409 /* real_to_target puts 32-bit pieces in each long. Pack them. */
14410 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
14412 insert_int (val
[i
], 4, array
);
14417 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
14418 does not have a "location" either in memory or in a register. These
14419 things can arise in GNU C when a constant is passed as an actual parameter
14420 to an inlined function. They can also arise in C++ where declared
14421 constants do not necessarily get memory "homes". */
14424 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
14426 switch (GET_CODE (rtl
))
14430 HOST_WIDE_INT val
= INTVAL (rtl
);
14433 add_AT_int (die
, DW_AT_const_value
, val
);
14435 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
14440 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
14441 floating-point constant. A CONST_DOUBLE is used whenever the
14442 constant requires more than one word in order to be adequately
14445 enum machine_mode mode
= GET_MODE (rtl
);
14447 if (SCALAR_FLOAT_MODE_P (mode
))
14449 unsigned int length
= GET_MODE_SIZE (mode
);
14450 unsigned char *array
= (unsigned char *) ggc_alloc_atomic (length
);
14452 insert_float (rtl
, array
);
14453 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
14456 add_AT_double (die
, DW_AT_const_value
,
14457 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
14463 enum machine_mode mode
= GET_MODE (rtl
);
14464 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
14465 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
14466 unsigned char *array
= (unsigned char *) ggc_alloc_atomic
14467 (length
* elt_size
);
14471 switch (GET_MODE_CLASS (mode
))
14473 case MODE_VECTOR_INT
:
14474 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
14476 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
14477 double_int val
= rtx_to_double_int (elt
);
14479 if (elt_size
<= sizeof (HOST_WIDE_INT
))
14480 insert_int (double_int_to_shwi (val
), elt_size
, p
);
14483 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
14484 insert_double (val
, p
);
14489 case MODE_VECTOR_FLOAT
:
14490 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
14492 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
14493 insert_float (elt
, p
);
14498 gcc_unreachable ();
14501 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
14506 if (dwarf_version
>= 4 || !dwarf_strict
)
14508 dw_loc_descr_ref loc_result
;
14509 resolve_one_addr (&rtl
, NULL
);
14511 loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
14512 loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
14513 loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
14514 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14515 add_AT_loc (die
, DW_AT_location
, loc_result
);
14516 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
14522 if (CONSTANT_P (XEXP (rtl
, 0)))
14523 return add_const_value_attribute (die
, XEXP (rtl
, 0));
14526 if (!const_ok_for_output (rtl
))
14529 if (dwarf_version
>= 4 || !dwarf_strict
)
14534 /* In cases where an inlined instance of an inline function is passed
14535 the address of an `auto' variable (which is local to the caller) we
14536 can get a situation where the DECL_RTL of the artificial local
14537 variable (for the inlining) which acts as a stand-in for the
14538 corresponding formal parameter (of the inline function) will look
14539 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
14540 exactly a compile-time constant expression, but it isn't the address
14541 of the (artificial) local variable either. Rather, it represents the
14542 *value* which the artificial local variable always has during its
14543 lifetime. We currently have no way to represent such quasi-constant
14544 values in Dwarf, so for now we just punt and generate nothing. */
14552 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
14553 && MEM_READONLY_P (rtl
)
14554 && GET_MODE (rtl
) == BLKmode
)
14556 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
14562 /* No other kinds of rtx should be possible here. */
14563 gcc_unreachable ();
14568 /* Determine whether the evaluation of EXPR references any variables
14569 or functions which aren't otherwise used (and therefore may not be
14572 reference_to_unused (tree
* tp
, int * walk_subtrees
,
14573 void * data ATTRIBUTE_UNUSED
)
14575 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
14576 *walk_subtrees
= 0;
14578 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
14579 && ! TREE_ASM_WRITTEN (*tp
))
14581 /* ??? The C++ FE emits debug information for using decls, so
14582 putting gcc_unreachable here falls over. See PR31899. For now
14583 be conservative. */
14584 else if (!cgraph_global_info_ready
14585 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
14587 else if (TREE_CODE (*tp
) == VAR_DECL
)
14589 struct varpool_node
*node
= varpool_get_node (*tp
);
14590 if (!node
|| !node
->needed
)
14593 else if (TREE_CODE (*tp
) == FUNCTION_DECL
14594 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
14596 /* The call graph machinery must have finished analyzing,
14597 optimizing and gimplifying the CU by now.
14598 So if *TP has no call graph node associated
14599 to it, it means *TP will not be emitted. */
14600 if (!cgraph_get_node (*tp
))
14603 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
14609 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
14610 for use in a later add_const_value_attribute call. */
14613 rtl_for_decl_init (tree init
, tree type
)
14615 rtx rtl
= NULL_RTX
;
14619 /* If a variable is initialized with a string constant without embedded
14620 zeros, build CONST_STRING. */
14621 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
14623 tree enttype
= TREE_TYPE (type
);
14624 tree domain
= TYPE_DOMAIN (type
);
14625 enum machine_mode mode
= TYPE_MODE (enttype
);
14627 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
14629 && integer_zerop (TYPE_MIN_VALUE (domain
))
14630 && compare_tree_int (TYPE_MAX_VALUE (domain
),
14631 TREE_STRING_LENGTH (init
) - 1) == 0
14632 && ((size_t) TREE_STRING_LENGTH (init
)
14633 == strlen (TREE_STRING_POINTER (init
)) + 1))
14635 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
14636 ggc_strdup (TREE_STRING_POINTER (init
)));
14637 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
14638 MEM_READONLY_P (rtl
) = 1;
14641 /* Other aggregates, and complex values, could be represented using
14643 else if (AGGREGATE_TYPE_P (type
)
14644 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
14645 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
14646 || TREE_CODE (type
) == COMPLEX_TYPE
)
14648 /* Vectors only work if their mode is supported by the target.
14649 FIXME: generic vectors ought to work too. */
14650 else if (TREE_CODE (type
) == VECTOR_TYPE
14651 && !VECTOR_MODE_P (TYPE_MODE (type
)))
14653 /* If the initializer is something that we know will expand into an
14654 immediate RTL constant, expand it now. We must be careful not to
14655 reference variables which won't be output. */
14656 else if (initializer_constant_valid_p (init
, type
)
14657 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
14659 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
14661 if (TREE_CODE (type
) == VECTOR_TYPE
)
14662 switch (TREE_CODE (init
))
14667 if (TREE_CONSTANT (init
))
14669 VEC(constructor_elt
,gc
) *elts
= CONSTRUCTOR_ELTS (init
);
14670 bool constant_p
= true;
14672 unsigned HOST_WIDE_INT ix
;
14674 /* Even when ctor is constant, it might contain non-*_CST
14675 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
14676 belong into VECTOR_CST nodes. */
14677 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
14678 if (!CONSTANT_CLASS_P (value
))
14680 constant_p
= false;
14686 init
= build_vector_from_ctor (type
, elts
);
14696 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
14698 /* If expand_expr returns a MEM, it wasn't immediate. */
14699 gcc_assert (!rtl
|| !MEM_P (rtl
));
14705 /* Generate RTL for the variable DECL to represent its location. */
14708 rtl_for_decl_location (tree decl
)
14712 /* Here we have to decide where we are going to say the parameter "lives"
14713 (as far as the debugger is concerned). We only have a couple of
14714 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
14716 DECL_RTL normally indicates where the parameter lives during most of the
14717 activation of the function. If optimization is enabled however, this
14718 could be either NULL or else a pseudo-reg. Both of those cases indicate
14719 that the parameter doesn't really live anywhere (as far as the code
14720 generation parts of GCC are concerned) during most of the function's
14721 activation. That will happen (for example) if the parameter is never
14722 referenced within the function.
14724 We could just generate a location descriptor here for all non-NULL
14725 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
14726 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
14727 where DECL_RTL is NULL or is a pseudo-reg.
14729 Note however that we can only get away with using DECL_INCOMING_RTL as
14730 a backup substitute for DECL_RTL in certain limited cases. In cases
14731 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
14732 we can be sure that the parameter was passed using the same type as it is
14733 declared to have within the function, and that its DECL_INCOMING_RTL
14734 points us to a place where a value of that type is passed.
14736 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
14737 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
14738 because in these cases DECL_INCOMING_RTL points us to a value of some
14739 type which is *different* from the type of the parameter itself. Thus,
14740 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
14741 such cases, the debugger would end up (for example) trying to fetch a
14742 `float' from a place which actually contains the first part of a
14743 `double'. That would lead to really incorrect and confusing
14744 output at debug-time.
14746 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
14747 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
14748 are a couple of exceptions however. On little-endian machines we can
14749 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
14750 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
14751 an integral type that is smaller than TREE_TYPE (decl). These cases arise
14752 when (on a little-endian machine) a non-prototyped function has a
14753 parameter declared to be of type `short' or `char'. In such cases,
14754 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
14755 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
14756 passed `int' value. If the debugger then uses that address to fetch
14757 a `short' or a `char' (on a little-endian machine) the result will be
14758 the correct data, so we allow for such exceptional cases below.
14760 Note that our goal here is to describe the place where the given formal
14761 parameter lives during most of the function's activation (i.e. between the
14762 end of the prologue and the start of the epilogue). We'll do that as best
14763 as we can. Note however that if the given formal parameter is modified
14764 sometime during the execution of the function, then a stack backtrace (at
14765 debug-time) will show the function as having been called with the *new*
14766 value rather than the value which was originally passed in. This happens
14767 rarely enough that it is not a major problem, but it *is* a problem, and
14768 I'd like to fix it.
14770 A future version of dwarf2out.c may generate two additional attributes for
14771 any given DW_TAG_formal_parameter DIE which will describe the "passed
14772 type" and the "passed location" for the given formal parameter in addition
14773 to the attributes we now generate to indicate the "declared type" and the
14774 "active location" for each parameter. This additional set of attributes
14775 could be used by debuggers for stack backtraces. Separately, note that
14776 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
14777 This happens (for example) for inlined-instances of inline function formal
14778 parameters which are never referenced. This really shouldn't be
14779 happening. All PARM_DECL nodes should get valid non-NULL
14780 DECL_INCOMING_RTL values. FIXME. */
14782 /* Use DECL_RTL as the "location" unless we find something better. */
14783 rtl
= DECL_RTL_IF_SET (decl
);
14785 /* When generating abstract instances, ignore everything except
14786 constants, symbols living in memory, and symbols living in
14787 fixed registers. */
14788 if (! reload_completed
)
14791 && (CONSTANT_P (rtl
)
14793 && CONSTANT_P (XEXP (rtl
, 0)))
14795 && TREE_CODE (decl
) == VAR_DECL
14796 && TREE_STATIC (decl
))))
14798 rtl
= targetm
.delegitimize_address (rtl
);
14803 else if (TREE_CODE (decl
) == PARM_DECL
)
14805 if (rtl
== NULL_RTX
14806 || is_pseudo_reg (rtl
)
14808 && is_pseudo_reg (XEXP (rtl
, 0))
14809 && DECL_INCOMING_RTL (decl
)
14810 && MEM_P (DECL_INCOMING_RTL (decl
))
14811 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
14813 tree declared_type
= TREE_TYPE (decl
);
14814 tree passed_type
= DECL_ARG_TYPE (decl
);
14815 enum machine_mode dmode
= TYPE_MODE (declared_type
);
14816 enum machine_mode pmode
= TYPE_MODE (passed_type
);
14818 /* This decl represents a formal parameter which was optimized out.
14819 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
14820 all cases where (rtl == NULL_RTX) just below. */
14821 if (dmode
== pmode
)
14822 rtl
= DECL_INCOMING_RTL (decl
);
14823 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
14824 && SCALAR_INT_MODE_P (dmode
)
14825 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
14826 && DECL_INCOMING_RTL (decl
))
14828 rtx inc
= DECL_INCOMING_RTL (decl
);
14831 else if (MEM_P (inc
))
14833 if (BYTES_BIG_ENDIAN
)
14834 rtl
= adjust_address_nv (inc
, dmode
,
14835 GET_MODE_SIZE (pmode
)
14836 - GET_MODE_SIZE (dmode
));
14843 /* If the parm was passed in registers, but lives on the stack, then
14844 make a big endian correction if the mode of the type of the
14845 parameter is not the same as the mode of the rtl. */
14846 /* ??? This is the same series of checks that are made in dbxout.c before
14847 we reach the big endian correction code there. It isn't clear if all
14848 of these checks are necessary here, but keeping them all is the safe
14850 else if (MEM_P (rtl
)
14851 && XEXP (rtl
, 0) != const0_rtx
14852 && ! CONSTANT_P (XEXP (rtl
, 0))
14853 /* Not passed in memory. */
14854 && !MEM_P (DECL_INCOMING_RTL (decl
))
14855 /* Not passed by invisible reference. */
14856 && (!REG_P (XEXP (rtl
, 0))
14857 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
14858 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
14859 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
14860 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
14863 /* Big endian correction check. */
14864 && BYTES_BIG_ENDIAN
14865 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
14866 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
14869 int offset
= (UNITS_PER_WORD
14870 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
14872 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
14873 plus_constant (XEXP (rtl
, 0), offset
));
14876 else if (TREE_CODE (decl
) == VAR_DECL
14879 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
14880 && BYTES_BIG_ENDIAN
)
14882 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
14883 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
14885 /* If a variable is declared "register" yet is smaller than
14886 a register, then if we store the variable to memory, it
14887 looks like we're storing a register-sized value, when in
14888 fact we are not. We need to adjust the offset of the
14889 storage location to reflect the actual value's bytes,
14890 else gdb will not be able to display it. */
14892 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
14893 plus_constant (XEXP (rtl
, 0), rsize
-dsize
));
14896 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
14897 and will have been substituted directly into all expressions that use it.
14898 C does not have such a concept, but C++ and other languages do. */
14899 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
14900 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
14903 rtl
= targetm
.delegitimize_address (rtl
);
14905 /* If we don't look past the constant pool, we risk emitting a
14906 reference to a constant pool entry that isn't referenced from
14907 code, and thus is not emitted. */
14909 rtl
= avoid_constant_pool_reference (rtl
);
14911 /* Try harder to get a rtl. If this symbol ends up not being emitted
14912 in the current CU, resolve_addr will remove the expression referencing
14914 if (rtl
== NULL_RTX
14915 && TREE_CODE (decl
) == VAR_DECL
14916 && !DECL_EXTERNAL (decl
)
14917 && TREE_STATIC (decl
)
14918 && DECL_NAME (decl
)
14919 && !DECL_HARD_REGISTER (decl
)
14920 && DECL_MODE (decl
) != VOIDmode
)
14922 rtl
= make_decl_rtl_for_debug (decl
);
14924 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
14925 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
14932 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
14933 returned. If so, the decl for the COMMON block is returned, and the
14934 value is the offset into the common block for the symbol. */
14937 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
14939 tree val_expr
, cvar
;
14940 enum machine_mode mode
;
14941 HOST_WIDE_INT bitsize
, bitpos
;
14943 int volatilep
= 0, unsignedp
= 0;
14945 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
14946 it does not have a value (the offset into the common area), or if it
14947 is thread local (as opposed to global) then it isn't common, and shouldn't
14948 be handled as such. */
14949 if (TREE_CODE (decl
) != VAR_DECL
14950 || !TREE_STATIC (decl
)
14951 || !DECL_HAS_VALUE_EXPR_P (decl
)
14955 val_expr
= DECL_VALUE_EXPR (decl
);
14956 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
14959 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
,
14960 &mode
, &unsignedp
, &volatilep
, true);
14962 if (cvar
== NULL_TREE
14963 || TREE_CODE (cvar
) != VAR_DECL
14964 || DECL_ARTIFICIAL (cvar
)
14965 || !TREE_PUBLIC (cvar
))
14969 if (offset
!= NULL
)
14971 if (!host_integerp (offset
, 0))
14973 *value
= tree_low_cst (offset
, 0);
14976 *value
+= bitpos
/ BITS_PER_UNIT
;
14981 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
14982 data attribute for a variable or a parameter. We generate the
14983 DW_AT_const_value attribute only in those cases where the given variable
14984 or parameter does not have a true "location" either in memory or in a
14985 register. This can happen (for example) when a constant is passed as an
14986 actual argument in a call to an inline function. (It's possible that
14987 these things can crop up in other ways also.) Note that one type of
14988 constant value which can be passed into an inlined function is a constant
14989 pointer. This can happen for example if an actual argument in an inlined
14990 function call evaluates to a compile-time constant address.
14992 CACHE_P is true if it is worth caching the location list for DECL,
14993 so that future calls can reuse it rather than regenerate it from scratch.
14994 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
14995 since we will need to refer to them each time the function is inlined. */
14998 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
,
14999 enum dwarf_attribute attr
)
15002 dw_loc_list_ref list
;
15003 var_loc_list
*loc_list
;
15004 cached_dw_loc_list
*cache
;
15007 if (TREE_CODE (decl
) == ERROR_MARK
)
15010 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
15011 || TREE_CODE (decl
) == RESULT_DECL
);
15013 /* Try to get some constant RTL for this decl, and use that as the value of
15016 rtl
= rtl_for_decl_location (decl
);
15017 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15018 && add_const_value_attribute (die
, rtl
))
15021 /* See if we have single element location list that is equivalent to
15022 a constant value. That way we are better to use add_const_value_attribute
15023 rather than expanding constant value equivalent. */
15024 loc_list
= lookup_decl_loc (decl
);
15027 && loc_list
->first
->next
== NULL
15028 && NOTE_P (loc_list
->first
->loc
)
15029 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
15030 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
15032 struct var_loc_node
*node
;
15034 node
= loc_list
->first
;
15035 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
15036 if (GET_CODE (rtl
) == EXPR_LIST
)
15037 rtl
= XEXP (rtl
, 0);
15038 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
15039 && add_const_value_attribute (die
, rtl
))
15042 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
15043 list several times. See if we've already cached the contents. */
15045 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
15049 cache
= (cached_dw_loc_list
*)
15050 htab_find_with_hash (cached_dw_loc_list_table
, decl
, DECL_UID (decl
));
15052 list
= cache
->loc_list
;
15056 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2);
15057 /* It is usually worth caching this result if the decl is from
15058 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
15059 if (cache_p
&& list
&& list
->dw_loc_next
)
15061 slot
= htab_find_slot_with_hash (cached_dw_loc_list_table
, decl
,
15062 DECL_UID (decl
), INSERT
);
15063 cache
= ggc_alloc_cleared_cached_dw_loc_list ();
15064 cache
->decl_id
= DECL_UID (decl
);
15065 cache
->loc_list
= list
;
15071 add_AT_location_description (die
, attr
, list
);
15074 /* None of that worked, so it must not really have a location;
15075 try adding a constant value attribute from the DECL_INITIAL. */
15076 return tree_add_const_value_attribute_for_decl (die
, decl
);
15079 /* Add VARIABLE and DIE into deferred locations list. */
15082 defer_location (tree variable
, dw_die_ref die
)
15084 deferred_locations entry
;
15085 entry
.variable
= variable
;
15087 VEC_safe_push (deferred_locations
, gc
, deferred_locations_list
, &entry
);
15090 /* Helper function for tree_add_const_value_attribute. Natively encode
15091 initializer INIT into an array. Return true if successful. */
15094 native_encode_initializer (tree init
, unsigned char *array
, int size
)
15098 if (init
== NULL_TREE
)
15102 switch (TREE_CODE (init
))
15105 type
= TREE_TYPE (init
);
15106 if (TREE_CODE (type
) == ARRAY_TYPE
)
15108 tree enttype
= TREE_TYPE (type
);
15109 enum machine_mode mode
= TYPE_MODE (enttype
);
15111 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
15113 if (int_size_in_bytes (type
) != size
)
15115 if (size
> TREE_STRING_LENGTH (init
))
15117 memcpy (array
, TREE_STRING_POINTER (init
),
15118 TREE_STRING_LENGTH (init
));
15119 memset (array
+ TREE_STRING_LENGTH (init
),
15120 '\0', size
- TREE_STRING_LENGTH (init
));
15123 memcpy (array
, TREE_STRING_POINTER (init
), size
);
15128 type
= TREE_TYPE (init
);
15129 if (int_size_in_bytes (type
) != size
)
15131 if (TREE_CODE (type
) == ARRAY_TYPE
)
15133 HOST_WIDE_INT min_index
;
15134 unsigned HOST_WIDE_INT cnt
;
15135 int curpos
= 0, fieldsize
;
15136 constructor_elt
*ce
;
15138 if (TYPE_DOMAIN (type
) == NULL_TREE
15139 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0))
15142 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
15143 if (fieldsize
<= 0)
15146 min_index
= tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0);
15147 memset (array
, '\0', size
);
15148 FOR_EACH_VEC_ELT (constructor_elt
, CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15150 tree val
= ce
->value
;
15151 tree index
= ce
->index
;
15153 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15154 pos
= (tree_low_cst (TREE_OPERAND (index
, 0), 0) - min_index
)
15157 pos
= (tree_low_cst (index
, 0) - min_index
) * fieldsize
;
15162 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
15165 curpos
= pos
+ fieldsize
;
15166 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
15168 int count
= tree_low_cst (TREE_OPERAND (index
, 1), 0)
15169 - tree_low_cst (TREE_OPERAND (index
, 0), 0);
15170 while (count
-- > 0)
15173 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
15174 curpos
+= fieldsize
;
15177 gcc_assert (curpos
<= size
);
15181 else if (TREE_CODE (type
) == RECORD_TYPE
15182 || TREE_CODE (type
) == UNION_TYPE
)
15184 tree field
= NULL_TREE
;
15185 unsigned HOST_WIDE_INT cnt
;
15186 constructor_elt
*ce
;
15188 if (int_size_in_bytes (type
) != size
)
15191 if (TREE_CODE (type
) == RECORD_TYPE
)
15192 field
= TYPE_FIELDS (type
);
15194 FOR_EACH_VEC_ELT (constructor_elt
, CONSTRUCTOR_ELTS (init
), cnt
, ce
)
15196 tree val
= ce
->value
;
15197 int pos
, fieldsize
;
15199 if (ce
->index
!= 0)
15205 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
15208 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
15209 && TYPE_DOMAIN (TREE_TYPE (field
))
15210 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
15212 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
15213 || !host_integerp (DECL_SIZE_UNIT (field
), 0))
15215 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 0);
15216 pos
= int_byte_position (field
);
15217 gcc_assert (pos
+ fieldsize
<= size
);
15219 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
15225 case VIEW_CONVERT_EXPR
:
15226 case NON_LVALUE_EXPR
:
15227 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
15229 return native_encode_expr (init
, array
, size
) == size
;
15233 /* Attach a DW_AT_const_value attribute to DIE. The value of the
15234 attribute is the const value T. */
15237 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
15240 tree type
= TREE_TYPE (t
);
15243 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
15247 gcc_assert (!DECL_P (init
));
15249 rtl
= rtl_for_decl_init (init
, type
);
15251 return add_const_value_attribute (die
, rtl
);
15252 /* If the host and target are sane, try harder. */
15253 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
15254 && initializer_constant_valid_p (init
, type
))
15256 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
15257 if (size
> 0 && (int) size
== size
)
15259 unsigned char *array
= (unsigned char *)
15260 ggc_alloc_cleared_atomic (size
);
15262 if (native_encode_initializer (init
, array
, size
))
15264 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
15272 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
15273 attribute is the const value of T, where T is an integral constant
15274 variable with static storage duration
15275 (so it can't be a PARM_DECL or a RESULT_DECL). */
15278 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
15282 || (TREE_CODE (decl
) != VAR_DECL
15283 && TREE_CODE (decl
) != CONST_DECL
)
15284 || (TREE_CODE (decl
) == VAR_DECL
15285 && !TREE_STATIC (decl
)))
15288 if (TREE_READONLY (decl
)
15289 && ! TREE_THIS_VOLATILE (decl
)
15290 && DECL_INITIAL (decl
))
15295 /* Don't add DW_AT_const_value if abstract origin already has one. */
15296 if (get_AT (var_die
, DW_AT_const_value
))
15299 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
15302 /* Convert the CFI instructions for the current function into a
15303 location list. This is used for DW_AT_frame_base when we targeting
15304 a dwarf2 consumer that does not support the dwarf3
15305 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
15308 static dw_loc_list_ref
15309 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
15313 dw_loc_list_ref list
, *list_tail
;
15315 dw_cfa_location last_cfa
, next_cfa
;
15316 const char *start_label
, *last_label
, *section
;
15317 dw_cfa_location remember
;
15320 gcc_assert (fde
!= NULL
);
15322 section
= secname_for_decl (current_function_decl
);
15326 memset (&next_cfa
, 0, sizeof (next_cfa
));
15327 next_cfa
.reg
= INVALID_REGNUM
;
15328 remember
= next_cfa
;
15330 start_label
= fde
->dw_fde_begin
;
15332 /* ??? Bald assumption that the CIE opcode list does not contain
15333 advance opcodes. */
15334 FOR_EACH_VEC_ELT (dw_cfi_ref
, cie_cfi_vec
, ix
, cfi
)
15335 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
15337 last_cfa
= next_cfa
;
15338 last_label
= start_label
;
15340 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
15342 /* If the first partition contained no CFI adjustments, the
15343 CIE opcodes apply to the whole first partition. */
15344 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15345 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
15346 list_tail
=&(*list_tail
)->dw_loc_next
;
15347 start_label
= last_label
= fde
->dw_fde_second_begin
;
15350 FOR_EACH_VEC_ELT (dw_cfi_ref
, fde
->dw_fde_cfi
, ix
, cfi
)
15352 switch (cfi
->dw_cfi_opc
)
15354 case DW_CFA_set_loc
:
15355 case DW_CFA_advance_loc1
:
15356 case DW_CFA_advance_loc2
:
15357 case DW_CFA_advance_loc4
:
15358 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
15360 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15361 start_label
, last_label
, section
);
15363 list_tail
= &(*list_tail
)->dw_loc_next
;
15364 last_cfa
= next_cfa
;
15365 start_label
= last_label
;
15367 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
15370 case DW_CFA_advance_loc
:
15371 /* The encoding is complex enough that we should never emit this. */
15372 gcc_unreachable ();
15375 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
15378 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
15380 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
15382 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15383 start_label
, last_label
, section
);
15385 list_tail
= &(*list_tail
)->dw_loc_next
;
15386 last_cfa
= next_cfa
;
15387 start_label
= last_label
;
15389 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15390 start_label
, fde
->dw_fde_end
, section
);
15391 list_tail
= &(*list_tail
)->dw_loc_next
;
15392 start_label
= last_label
= fde
->dw_fde_second_begin
;
15396 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
15398 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
15399 start_label
, last_label
, section
);
15400 list_tail
= &(*list_tail
)->dw_loc_next
;
15401 start_label
= last_label
;
15404 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
15406 fde
->dw_fde_second_begin
15407 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
15410 if (list
&& list
->dw_loc_next
)
15416 /* Compute a displacement from the "steady-state frame pointer" to the
15417 frame base (often the same as the CFA), and store it in
15418 frame_pointer_fb_offset. OFFSET is added to the displacement
15419 before the latter is negated. */
15422 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
15426 #ifdef FRAME_POINTER_CFA_OFFSET
15427 reg
= frame_pointer_rtx
;
15428 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
15430 reg
= arg_pointer_rtx
;
15431 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
15434 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
15435 if (GET_CODE (elim
) == PLUS
)
15437 offset
+= INTVAL (XEXP (elim
, 1));
15438 elim
= XEXP (elim
, 0);
15441 frame_pointer_fb_offset
= -offset
;
15443 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
15444 in which to eliminate. This is because it's stack pointer isn't
15445 directly accessible as a register within the ISA. To work around
15446 this, assume that while we cannot provide a proper value for
15447 frame_pointer_fb_offset, we won't need one either. */
15448 frame_pointer_fb_offset_valid
15449 = ((SUPPORTS_STACK_ALIGNMENT
15450 && (elim
== hard_frame_pointer_rtx
15451 || elim
== stack_pointer_rtx
))
15452 || elim
== (frame_pointer_needed
15453 ? hard_frame_pointer_rtx
15454 : stack_pointer_rtx
));
15457 /* Generate a DW_AT_name attribute given some string value to be included as
15458 the value of the attribute. */
15461 add_name_attribute (dw_die_ref die
, const char *name_string
)
15463 if (name_string
!= NULL
&& *name_string
!= 0)
15465 if (demangle_name_func
)
15466 name_string
= (*demangle_name_func
) (name_string
);
15468 add_AT_string (die
, DW_AT_name
, name_string
);
15472 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
15473 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
15474 of TYPE accordingly.
15476 ??? This is a temporary measure until after we're able to generate
15477 regular DWARF for the complex Ada type system. */
15480 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
15481 dw_die_ref context_die
)
15484 dw_die_ref dtype_die
;
15486 if (!lang_hooks
.types
.descriptive_type
)
15489 dtype
= lang_hooks
.types
.descriptive_type (type
);
15493 dtype_die
= lookup_type_die (dtype
);
15496 /* The descriptive type indirectly references TYPE if this is also the
15497 case for TYPE itself. Do not deal with the circularity here. */
15498 TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
)) = 1;
15499 gen_type_die (dtype
, context_die
);
15500 TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
)) = 0;
15501 dtype_die
= lookup_type_die (dtype
);
15502 gcc_assert (dtype_die
);
15505 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
15508 /* Generate a DW_AT_comp_dir attribute for DIE. */
15511 add_comp_dir_attribute (dw_die_ref die
)
15513 const char *wd
= get_src_pwd ();
15519 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
15523 wdlen
= strlen (wd
);
15524 wd1
= (char *) ggc_alloc_atomic (wdlen
+ 2);
15526 wd1
[wdlen
] = DIR_SEPARATOR
;
15527 wd1
[wdlen
+ 1] = 0;
15531 add_AT_string (die
, DW_AT_comp_dir
, remap_debug_filename (wd
));
15534 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
15538 lower_bound_default (void)
15540 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
15545 case DW_LANG_C_plus_plus
:
15547 case DW_LANG_ObjC_plus_plus
:
15550 case DW_LANG_Fortran77
:
15551 case DW_LANG_Fortran90
:
15552 case DW_LANG_Fortran95
:
15556 case DW_LANG_Python
:
15557 return dwarf_version
>= 4 ? 0 : -1;
15558 case DW_LANG_Ada95
:
15559 case DW_LANG_Ada83
:
15560 case DW_LANG_Cobol74
:
15561 case DW_LANG_Cobol85
:
15562 case DW_LANG_Pascal83
:
15563 case DW_LANG_Modula2
:
15565 return dwarf_version
>= 4 ? 1 : -1;
15571 /* Given a tree node describing an array bound (either lower or upper) output
15572 a representation for that bound. */
15575 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
15577 switch (TREE_CODE (bound
))
15582 /* All fixed-bounds are represented by INTEGER_CST nodes. */
15585 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (bound
));
15588 /* Use the default if possible. */
15589 if (bound_attr
== DW_AT_lower_bound
15590 && host_integerp (bound
, 0)
15591 && (dflt
= lower_bound_default ()) != -1
15592 && tree_low_cst (bound
, 0) == dflt
)
15595 /* Otherwise represent the bound as an unsigned value with the
15596 precision of its type. The precision and signedness of the
15597 type will be necessary to re-interpret it unambiguously. */
15598 else if (prec
< HOST_BITS_PER_WIDE_INT
)
15600 unsigned HOST_WIDE_INT mask
15601 = ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
15602 add_AT_unsigned (subrange_die
, bound_attr
,
15603 TREE_INT_CST_LOW (bound
) & mask
);
15605 else if (prec
== HOST_BITS_PER_WIDE_INT
15606 || TREE_INT_CST_HIGH (bound
) == 0)
15607 add_AT_unsigned (subrange_die
, bound_attr
,
15608 TREE_INT_CST_LOW (bound
));
15610 add_AT_double (subrange_die
, bound_attr
, TREE_INT_CST_HIGH (bound
),
15611 TREE_INT_CST_LOW (bound
));
15616 case VIEW_CONVERT_EXPR
:
15617 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
15627 dw_die_ref decl_die
= lookup_decl_die (bound
);
15629 /* ??? Can this happen, or should the variable have been bound
15630 first? Probably it can, since I imagine that we try to create
15631 the types of parameters in the order in which they exist in
15632 the list, and won't have created a forward reference to a
15633 later parameter. */
15634 if (decl_die
!= NULL
)
15636 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
15644 /* Otherwise try to create a stack operation procedure to
15645 evaluate the value of the array bound. */
15647 dw_die_ref ctx
, decl_die
;
15648 dw_loc_list_ref list
;
15650 list
= loc_list_from_tree (bound
, 2);
15651 if (list
== NULL
|| single_element_loc_list_p (list
))
15653 /* If DW_AT_*bound is not a reference nor constant, it is
15654 a DWARF expression rather than location description.
15655 For that loc_list_from_tree (bound, 0) is needed.
15656 If that fails to give a single element list,
15657 fall back to outputting this as a reference anyway. */
15658 dw_loc_list_ref list2
= loc_list_from_tree (bound
, 0);
15659 if (list2
&& single_element_loc_list_p (list2
))
15661 add_AT_loc (subrange_die
, bound_attr
, list2
->expr
);
15668 if (current_function_decl
== 0)
15669 ctx
= comp_unit_die ();
15671 ctx
= lookup_decl_die (current_function_decl
);
15673 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
15674 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
15675 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
15676 add_AT_location_description (decl_die
, DW_AT_location
, list
);
15677 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
15683 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
15684 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
15685 Note that the block of subscript information for an array type also
15686 includes information about the element type of the given array type. */
15689 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
15691 unsigned dimension_number
;
15693 dw_die_ref subrange_die
;
15695 for (dimension_number
= 0;
15696 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
15697 type
= TREE_TYPE (type
), dimension_number
++)
15699 tree domain
= TYPE_DOMAIN (type
);
15701 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
15704 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
15705 and (in GNU C only) variable bounds. Handle all three forms
15707 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
15710 /* We have an array type with specified bounds. */
15711 lower
= TYPE_MIN_VALUE (domain
);
15712 upper
= TYPE_MAX_VALUE (domain
);
15714 /* Define the index type. */
15715 if (TREE_TYPE (domain
))
15717 /* ??? This is probably an Ada unnamed subrange type. Ignore the
15718 TREE_TYPE field. We can't emit debug info for this
15719 because it is an unnamed integral type. */
15720 if (TREE_CODE (domain
) == INTEGER_TYPE
15721 && TYPE_NAME (domain
) == NULL_TREE
15722 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
15723 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
15726 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
15730 /* ??? If upper is NULL, the array has unspecified length,
15731 but it does have a lower bound. This happens with Fortran
15733 Since the debugger is definitely going to need to know N
15734 to produce useful results, go ahead and output the lower
15735 bound solo, and hope the debugger can cope. */
15737 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
15739 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
15742 /* Otherwise we have an array type with an unspecified length. The
15743 DWARF-2 spec does not say how to handle this; let's just leave out the
15749 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
15753 switch (TREE_CODE (tree_node
))
15758 case ENUMERAL_TYPE
:
15761 case QUAL_UNION_TYPE
:
15762 size
= int_size_in_bytes (tree_node
);
15765 /* For a data member of a struct or union, the DW_AT_byte_size is
15766 generally given as the number of bytes normally allocated for an
15767 object of the *declared* type of the member itself. This is true
15768 even for bit-fields. */
15769 size
= simple_type_size_in_bits (field_type (tree_node
)) / BITS_PER_UNIT
;
15772 gcc_unreachable ();
15775 /* Note that `size' might be -1 when we get to this point. If it is, that
15776 indicates that the byte size of the entity in question is variable. We
15777 have no good way of expressing this fact in Dwarf at the present time,
15778 so just let the -1 pass on through. */
15779 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
15782 /* For a FIELD_DECL node which represents a bit-field, output an attribute
15783 which specifies the distance in bits from the highest order bit of the
15784 "containing object" for the bit-field to the highest order bit of the
15787 For any given bit-field, the "containing object" is a hypothetical object
15788 (of some integral or enum type) within which the given bit-field lives. The
15789 type of this hypothetical "containing object" is always the same as the
15790 declared type of the individual bit-field itself. The determination of the
15791 exact location of the "containing object" for a bit-field is rather
15792 complicated. It's handled by the `field_byte_offset' function (above).
15794 Note that it is the size (in bytes) of the hypothetical "containing object"
15795 which will be given in the DW_AT_byte_size attribute for this bit-field.
15796 (See `byte_size_attribute' above). */
15799 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
15801 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
15802 tree type
= DECL_BIT_FIELD_TYPE (decl
);
15803 HOST_WIDE_INT bitpos_int
;
15804 HOST_WIDE_INT highest_order_object_bit_offset
;
15805 HOST_WIDE_INT highest_order_field_bit_offset
;
15806 HOST_WIDE_INT bit_offset
;
15808 /* Must be a field and a bit field. */
15809 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
15811 /* We can't yet handle bit-fields whose offsets are variable, so if we
15812 encounter such things, just return without generating any attribute
15813 whatsoever. Likewise for variable or too large size. */
15814 if (! host_integerp (bit_position (decl
), 0)
15815 || ! host_integerp (DECL_SIZE (decl
), 1))
15818 bitpos_int
= int_bit_position (decl
);
15820 /* Note that the bit offset is always the distance (in bits) from the
15821 highest-order bit of the "containing object" to the highest-order bit of
15822 the bit-field itself. Since the "high-order end" of any object or field
15823 is different on big-endian and little-endian machines, the computation
15824 below must take account of these differences. */
15825 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
15826 highest_order_field_bit_offset
= bitpos_int
;
15828 if (! BYTES_BIG_ENDIAN
)
15830 highest_order_field_bit_offset
+= tree_low_cst (DECL_SIZE (decl
), 0);
15831 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
15835 = (! BYTES_BIG_ENDIAN
15836 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
15837 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
15839 if (bit_offset
< 0)
15840 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
15842 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
15845 /* For a FIELD_DECL node which represents a bit field, output an attribute
15846 which specifies the length in bits of the given field. */
15849 add_bit_size_attribute (dw_die_ref die
, tree decl
)
15851 /* Must be a field and a bit field. */
15852 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
15853 && DECL_BIT_FIELD_TYPE (decl
));
15855 if (host_integerp (DECL_SIZE (decl
), 1))
15856 add_AT_unsigned (die
, DW_AT_bit_size
, tree_low_cst (DECL_SIZE (decl
), 1));
15859 /* If the compiled language is ANSI C, then add a 'prototyped'
15860 attribute, if arg types are given for the parameters of a function. */
15863 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
15865 if (get_AT_unsigned (comp_unit_die (), DW_AT_language
) == DW_LANG_C89
15866 && prototype_p (func_type
))
15867 add_AT_flag (die
, DW_AT_prototyped
, 1);
15870 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
15871 by looking in either the type declaration or object declaration
15874 static inline dw_die_ref
15875 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
15877 dw_die_ref origin_die
= NULL
;
15879 if (TREE_CODE (origin
) != FUNCTION_DECL
)
15881 /* We may have gotten separated from the block for the inlined
15882 function, if we're in an exception handler or some such; make
15883 sure that the abstract function has been written out.
15885 Doing this for nested functions is wrong, however; functions are
15886 distinct units, and our context might not even be inline. */
15890 fn
= TYPE_STUB_DECL (fn
);
15892 fn
= decl_function_context (fn
);
15894 dwarf2out_abstract_function (fn
);
15897 if (DECL_P (origin
))
15898 origin_die
= lookup_decl_die (origin
);
15899 else if (TYPE_P (origin
))
15900 origin_die
= lookup_type_die (origin
);
15902 /* XXX: Functions that are never lowered don't always have correct block
15903 trees (in the case of java, they simply have no block tree, in some other
15904 languages). For these functions, there is nothing we can really do to
15905 output correct debug info for inlined functions in all cases. Rather
15906 than die, we'll just produce deficient debug info now, in that we will
15907 have variables without a proper abstract origin. In the future, when all
15908 functions are lowered, we should re-add a gcc_assert (origin_die)
15912 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
15916 /* We do not currently support the pure_virtual attribute. */
15919 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
15921 if (DECL_VINDEX (func_decl
))
15923 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
15925 if (host_integerp (DECL_VINDEX (func_decl
), 0))
15926 add_AT_loc (die
, DW_AT_vtable_elem_location
,
15927 new_loc_descr (DW_OP_constu
,
15928 tree_low_cst (DECL_VINDEX (func_decl
), 0),
15931 /* GNU extension: Record what type this method came from originally. */
15932 if (debug_info_level
> DINFO_LEVEL_TERSE
15933 && DECL_CONTEXT (func_decl
))
15934 add_AT_die_ref (die
, DW_AT_containing_type
,
15935 lookup_type_die (DECL_CONTEXT (func_decl
)));
15939 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
15940 given decl. This used to be a vendor extension until after DWARF 4
15941 standardized it. */
15944 add_linkage_attr (dw_die_ref die
, tree decl
)
15946 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
15948 /* Mimic what assemble_name_raw does with a leading '*'. */
15949 if (name
[0] == '*')
15952 if (dwarf_version
>= 4)
15953 add_AT_string (die
, DW_AT_linkage_name
, name
);
15955 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
15958 /* Add source coordinate attributes for the given decl. */
15961 add_src_coords_attributes (dw_die_ref die
, tree decl
)
15963 expanded_location s
;
15965 if (DECL_SOURCE_LOCATION (decl
) == UNKNOWN_LOCATION
)
15967 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
15968 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
15969 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
15972 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
15975 add_linkage_name (dw_die_ref die
, tree decl
)
15977 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
15978 && TREE_PUBLIC (decl
)
15979 && !DECL_ABSTRACT (decl
)
15980 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
15981 && die
->die_tag
!= DW_TAG_member
)
15983 /* Defer until we have an assembler name set. */
15984 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
15986 limbo_die_node
*asm_name
;
15988 asm_name
= ggc_alloc_cleared_limbo_die_node ();
15989 asm_name
->die
= die
;
15990 asm_name
->created_for
= decl
;
15991 asm_name
->next
= deferred_asm_name
;
15992 deferred_asm_name
= asm_name
;
15994 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
15995 add_linkage_attr (die
, decl
);
15999 /* Add a DW_AT_name attribute and source coordinate attribute for the
16000 given decl, but only if it actually has a name. */
16003 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
16007 decl_name
= DECL_NAME (decl
);
16008 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
16010 const char *name
= dwarf2_name (decl
, 0);
16012 add_name_attribute (die
, name
);
16013 if (! DECL_ARTIFICIAL (decl
))
16014 add_src_coords_attributes (die
, decl
);
16016 add_linkage_name (die
, decl
);
16019 #ifdef VMS_DEBUGGING_INFO
16020 /* Get the function's name, as described by its RTL. This may be different
16021 from the DECL_NAME name used in the source file. */
16022 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
16024 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
16025 XEXP (DECL_RTL (decl
), 0));
16026 VEC_safe_push (rtx
, gc
, used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
16028 #endif /* VMS_DEBUGGING_INFO */
16031 #ifdef VMS_DEBUGGING_INFO
16032 /* Output the debug main pointer die for VMS */
16035 dwarf2out_vms_debug_main_pointer (void)
16037 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
16040 /* Allocate the VMS debug main subprogram die. */
16041 die
= ggc_alloc_cleared_die_node ();
16042 die
->die_tag
= DW_TAG_subprogram
;
16043 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
16044 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
16045 current_function_funcdef_no
);
16046 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
16048 /* Make it the first child of comp_unit_die (). */
16049 die
->die_parent
= comp_unit_die ();
16050 if (comp_unit_die ()->die_child
)
16052 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
16053 comp_unit_die ()->die_child
->die_sib
= die
;
16057 die
->die_sib
= die
;
16058 comp_unit_die ()->die_child
= die
;
16061 #endif /* VMS_DEBUGGING_INFO */
16063 /* Push a new declaration scope. */
16066 push_decl_scope (tree scope
)
16068 VEC_safe_push (tree
, gc
, decl_scope_table
, scope
);
16071 /* Pop a declaration scope. */
16074 pop_decl_scope (void)
16076 VEC_pop (tree
, decl_scope_table
);
16079 /* Return the DIE for the scope that immediately contains this type.
16080 Non-named types get global scope. Named types nested in other
16081 types get their containing scope if it's open, or global scope
16082 otherwise. All other types (i.e. function-local named types) get
16083 the current active scope. */
16086 scope_die_for (tree t
, dw_die_ref context_die
)
16088 dw_die_ref scope_die
= NULL
;
16089 tree containing_scope
;
16092 /* Non-types always go in the current scope. */
16093 gcc_assert (TYPE_P (t
));
16095 containing_scope
= TYPE_CONTEXT (t
);
16097 /* Use the containing namespace if it was passed in (for a declaration). */
16098 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
16100 if (context_die
== lookup_decl_die (containing_scope
))
16103 containing_scope
= NULL_TREE
;
16106 /* Ignore function type "scopes" from the C frontend. They mean that
16107 a tagged type is local to a parmlist of a function declarator, but
16108 that isn't useful to DWARF. */
16109 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
16110 containing_scope
= NULL_TREE
;
16112 if (SCOPE_FILE_SCOPE_P (containing_scope
))
16113 scope_die
= comp_unit_die ();
16114 else if (TYPE_P (containing_scope
))
16116 /* For types, we can just look up the appropriate DIE. But
16117 first we check to see if we're in the middle of emitting it
16118 so we know where the new DIE should go. */
16119 for (i
= VEC_length (tree
, decl_scope_table
) - 1; i
>= 0; --i
)
16120 if (VEC_index (tree
, decl_scope_table
, i
) == containing_scope
)
16125 gcc_assert (debug_info_level
<= DINFO_LEVEL_TERSE
16126 || TREE_ASM_WRITTEN (containing_scope
));
16127 /*We are not in the middle of emitting the type
16128 CONTAINING_SCOPE. Let's see if it's emitted already. */
16129 scope_die
= lookup_type_die (containing_scope
);
16131 /* If none of the current dies are suitable, we get file scope. */
16132 if (scope_die
== NULL
)
16133 scope_die
= comp_unit_die ();
16136 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
16139 scope_die
= context_die
;
16144 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
16147 local_scope_p (dw_die_ref context_die
)
16149 for (; context_die
; context_die
= context_die
->die_parent
)
16150 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
16151 || context_die
->die_tag
== DW_TAG_subprogram
)
16157 /* Returns nonzero if CONTEXT_DIE is a class. */
16160 class_scope_p (dw_die_ref context_die
)
16162 return (context_die
16163 && (context_die
->die_tag
== DW_TAG_structure_type
16164 || context_die
->die_tag
== DW_TAG_class_type
16165 || context_die
->die_tag
== DW_TAG_interface_type
16166 || context_die
->die_tag
== DW_TAG_union_type
));
16169 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
16170 whether or not to treat a DIE in this context as a declaration. */
16173 class_or_namespace_scope_p (dw_die_ref context_die
)
16175 return (class_scope_p (context_die
)
16176 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
16179 /* Many forms of DIEs require a "type description" attribute. This
16180 routine locates the proper "type descriptor" die for the type given
16181 by 'type', and adds a DW_AT_type attribute below the given die. */
16184 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
16185 int decl_volatile
, dw_die_ref context_die
)
16187 enum tree_code code
= TREE_CODE (type
);
16188 dw_die_ref type_die
= NULL
;
16190 /* ??? If this type is an unnamed subrange type of an integral, floating-point
16191 or fixed-point type, use the inner type. This is because we have no
16192 support for unnamed types in base_type_die. This can happen if this is
16193 an Ada subrange type. Correct solution is emit a subrange type die. */
16194 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
16195 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
16196 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
16198 if (code
== ERROR_MARK
16199 /* Handle a special case. For functions whose return type is void, we
16200 generate *no* type attribute. (Note that no object may have type
16201 `void', so this only applies to function return types). */
16202 || code
== VOID_TYPE
)
16205 type_die
= modified_type_die (type
,
16206 decl_const
|| TYPE_READONLY (type
),
16207 decl_volatile
|| TYPE_VOLATILE (type
),
16210 if (type_die
!= NULL
)
16211 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
16214 /* Given an object die, add the calling convention attribute for the
16215 function call type. */
16217 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
16219 enum dwarf_calling_convention value
= DW_CC_normal
;
16221 value
= ((enum dwarf_calling_convention
)
16222 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
16225 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
16227 /* DWARF 2 doesn't provide a way to identify a program's source-level
16228 entry point. DW_AT_calling_convention attributes are only meant
16229 to describe functions' calling conventions. However, lacking a
16230 better way to signal the Fortran main program, we used this for
16231 a long time, following existing custom. Now, DWARF 4 has
16232 DW_AT_main_subprogram, which we add below, but some tools still
16233 rely on the old way, which we thus keep. */
16234 value
= DW_CC_program
;
16236 if (dwarf_version
>= 4 || !dwarf_strict
)
16237 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
16240 /* Only add the attribute if the backend requests it, and
16241 is not DW_CC_normal. */
16242 if (value
&& (value
!= DW_CC_normal
))
16243 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
16246 /* Given a tree pointer to a struct, class, union, or enum type node, return
16247 a pointer to the (string) tag name for the given type, or zero if the type
16248 was declared without a tag. */
16250 static const char *
16251 type_tag (const_tree type
)
16253 const char *name
= 0;
16255 if (TYPE_NAME (type
) != 0)
16259 /* Find the IDENTIFIER_NODE for the type name. */
16260 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
16261 && !TYPE_NAMELESS (type
))
16262 t
= TYPE_NAME (type
);
16264 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
16265 a TYPE_DECL node, regardless of whether or not a `typedef' was
16267 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
16268 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
16270 /* We want to be extra verbose. Don't call dwarf_name if
16271 DECL_NAME isn't set. The default hook for decl_printable_name
16272 doesn't like that, and in this context it's correct to return
16273 0, instead of "<anonymous>" or the like. */
16274 if (DECL_NAME (TYPE_NAME (type
))
16275 && !DECL_NAMELESS (TYPE_NAME (type
)))
16276 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
16279 /* Now get the name as a string, or invent one. */
16280 if (!name
&& t
!= 0)
16281 name
= IDENTIFIER_POINTER (t
);
16284 return (name
== 0 || *name
== '\0') ? 0 : name
;
16287 /* Return the type associated with a data member, make a special check
16288 for bit field types. */
16291 member_declared_type (const_tree member
)
16293 return (DECL_BIT_FIELD_TYPE (member
)
16294 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
16297 /* Get the decl's label, as described by its RTL. This may be different
16298 from the DECL_NAME name used in the source file. */
16301 static const char *
16302 decl_start_label (tree decl
)
16305 const char *fnname
;
16307 x
= DECL_RTL (decl
);
16308 gcc_assert (MEM_P (x
));
16311 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
16313 fnname
= XSTR (x
, 0);
16318 /* These routines generate the internal representation of the DIE's for
16319 the compilation unit. Debugging information is collected by walking
16320 the declaration trees passed in from dwarf2out_decl(). */
16323 gen_array_type_die (tree type
, dw_die_ref context_die
)
16325 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
16326 dw_die_ref array_die
;
16328 /* GNU compilers represent multidimensional array types as sequences of one
16329 dimensional array types whose element types are themselves array types.
16330 We sometimes squish that down to a single array_type DIE with multiple
16331 subscripts in the Dwarf debugging info. The draft Dwarf specification
16332 say that we are allowed to do this kind of compression in C, because
16333 there is no difference between an array of arrays and a multidimensional
16334 array. We don't do this for Ada to remain as close as possible to the
16335 actual representation, which is especially important against the language
16336 flexibilty wrt arrays of variable size. */
16338 bool collapse_nested_arrays
= !is_ada ();
16341 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
16342 DW_TAG_string_type doesn't have DW_AT_type attribute). */
16343 if (TYPE_STRING_FLAG (type
)
16344 && TREE_CODE (type
) == ARRAY_TYPE
16346 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
16348 HOST_WIDE_INT size
;
16350 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
16351 add_name_attribute (array_die
, type_tag (type
));
16352 equate_type_number_to_die (type
, array_die
);
16353 size
= int_size_in_bytes (type
);
16355 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
16356 else if (TYPE_DOMAIN (type
) != NULL_TREE
16357 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
16358 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
16360 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
16361 dw_loc_list_ref loc
= loc_list_from_tree (szdecl
, 2);
16363 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
16364 if (loc
&& size
> 0)
16366 add_AT_location_description (array_die
, DW_AT_string_length
, loc
);
16367 if (size
!= DWARF2_ADDR_SIZE
)
16368 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
16374 /* ??? The SGI dwarf reader fails for array of array of enum types
16375 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
16376 array type comes before the outer array type. We thus call gen_type_die
16377 before we new_die and must prevent nested array types collapsing for this
16380 #ifdef MIPS_DEBUGGING_INFO
16381 gen_type_die (TREE_TYPE (type
), context_die
);
16382 collapse_nested_arrays
= false;
16385 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
16386 add_name_attribute (array_die
, type_tag (type
));
16387 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
16388 if (TYPE_ARTIFICIAL (type
))
16389 add_AT_flag (array_die
, DW_AT_artificial
, 1);
16390 equate_type_number_to_die (type
, array_die
);
16392 if (TREE_CODE (type
) == VECTOR_TYPE
)
16393 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
16395 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
16397 && TREE_CODE (type
) == ARRAY_TYPE
16398 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
16399 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
16400 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
16403 /* We default the array ordering. SDB will probably do
16404 the right things even if DW_AT_ordering is not present. It's not even
16405 an issue until we start to get into multidimensional arrays anyway. If
16406 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
16407 then we'll have to put the DW_AT_ordering attribute back in. (But if
16408 and when we find out that we need to put these in, we will only do so
16409 for multidimensional arrays. */
16410 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
16413 #ifdef MIPS_DEBUGGING_INFO
16414 /* The SGI compilers handle arrays of unknown bound by setting
16415 AT_declaration and not emitting any subrange DIEs. */
16416 if (TREE_CODE (type
) == ARRAY_TYPE
16417 && ! TYPE_DOMAIN (type
))
16418 add_AT_flag (array_die
, DW_AT_declaration
, 1);
16421 if (TREE_CODE (type
) == VECTOR_TYPE
)
16423 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
16424 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
16425 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
);
16426 add_bound_info (subrange_die
, DW_AT_upper_bound
,
16427 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
16430 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
16432 /* Add representation of the type of the elements of this array type and
16433 emit the corresponding DIE if we haven't done it already. */
16434 element_type
= TREE_TYPE (type
);
16435 if (collapse_nested_arrays
)
16436 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
16438 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
16440 element_type
= TREE_TYPE (element_type
);
16443 #ifndef MIPS_DEBUGGING_INFO
16444 gen_type_die (element_type
, context_die
);
16447 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
16449 if (get_AT (array_die
, DW_AT_name
))
16450 add_pubtype (type
, array_die
);
16453 static dw_loc_descr_ref
16454 descr_info_loc (tree val
, tree base_decl
)
16456 HOST_WIDE_INT size
;
16457 dw_loc_descr_ref loc
, loc2
;
16458 enum dwarf_location_atom op
;
16460 if (val
== base_decl
)
16461 return new_loc_descr (DW_OP_push_object_address
, 0, 0);
16463 switch (TREE_CODE (val
))
16466 return descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
16468 return loc_descriptor_from_tree (val
, 0);
16470 if (host_integerp (val
, 0))
16471 return int_loc_descriptor (tree_low_cst (val
, 0));
16474 size
= int_size_in_bytes (TREE_TYPE (val
));
16477 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
16480 if (size
== DWARF2_ADDR_SIZE
)
16481 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref
, 0, 0));
16483 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref_size
, size
, 0));
16485 case POINTER_PLUS_EXPR
:
16487 if (host_integerp (TREE_OPERAND (val
, 1), 1)
16488 && (unsigned HOST_WIDE_INT
) tree_low_cst (TREE_OPERAND (val
, 1), 1)
16491 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
16494 loc_descr_plus_const (&loc
, tree_low_cst (TREE_OPERAND (val
, 1), 0));
16500 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
16503 loc2
= descr_info_loc (TREE_OPERAND (val
, 1), base_decl
);
16506 add_loc_descr (&loc
, loc2
);
16507 add_loc_descr (&loc2
, new_loc_descr (op
, 0, 0));
16529 add_descr_info_field (dw_die_ref die
, enum dwarf_attribute attr
,
16530 tree val
, tree base_decl
)
16532 dw_loc_descr_ref loc
;
16534 if (host_integerp (val
, 0))
16536 add_AT_unsigned (die
, attr
, tree_low_cst (val
, 0));
16540 loc
= descr_info_loc (val
, base_decl
);
16544 add_AT_loc (die
, attr
, loc
);
16547 /* This routine generates DIE for array with hidden descriptor, details
16548 are filled into *info by a langhook. */
16551 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
16552 dw_die_ref context_die
)
16554 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
16555 dw_die_ref array_die
;
16558 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
16559 add_name_attribute (array_die
, type_tag (type
));
16560 equate_type_number_to_die (type
, array_die
);
16562 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
16564 && info
->ndimensions
>= 2)
16565 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
16567 if (info
->data_location
)
16568 add_descr_info_field (array_die
, DW_AT_data_location
, info
->data_location
,
16570 if (info
->associated
)
16571 add_descr_info_field (array_die
, DW_AT_associated
, info
->associated
,
16573 if (info
->allocated
)
16574 add_descr_info_field (array_die
, DW_AT_allocated
, info
->allocated
,
16577 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
16579 dw_die_ref subrange_die
16580 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
16582 if (info
->dimen
[dim
].lower_bound
)
16584 /* If it is the default value, omit it. */
16587 if (host_integerp (info
->dimen
[dim
].lower_bound
, 0)
16588 && (dflt
= lower_bound_default ()) != -1
16589 && tree_low_cst (info
->dimen
[dim
].lower_bound
, 0) == dflt
)
16592 add_descr_info_field (subrange_die
, DW_AT_lower_bound
,
16593 info
->dimen
[dim
].lower_bound
,
16596 if (info
->dimen
[dim
].upper_bound
)
16597 add_descr_info_field (subrange_die
, DW_AT_upper_bound
,
16598 info
->dimen
[dim
].upper_bound
,
16600 if (info
->dimen
[dim
].stride
)
16601 add_descr_info_field (subrange_die
, DW_AT_byte_stride
,
16602 info
->dimen
[dim
].stride
,
16606 gen_type_die (info
->element_type
, context_die
);
16607 add_type_attribute (array_die
, info
->element_type
, 0, 0, context_die
);
16609 if (get_AT (array_die
, DW_AT_name
))
16610 add_pubtype (type
, array_die
);
16615 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
16617 tree origin
= decl_ultimate_origin (decl
);
16618 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
16620 if (origin
!= NULL
)
16621 add_abstract_origin_attribute (decl_die
, origin
);
16624 add_name_and_src_coords_attributes (decl_die
, decl
);
16625 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
16626 0, 0, context_die
);
16629 if (DECL_ABSTRACT (decl
))
16630 equate_decl_number_to_die (decl
, decl_die
);
16632 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
16636 /* Walk through the list of incomplete types again, trying once more to
16637 emit full debugging info for them. */
16640 retry_incomplete_types (void)
16644 for (i
= VEC_length (tree
, incomplete_types
) - 1; i
>= 0; i
--)
16645 if (should_emit_struct_debug (VEC_index (tree
, incomplete_types
, i
),
16646 DINFO_USAGE_DIR_USE
))
16647 gen_type_die (VEC_index (tree
, incomplete_types
, i
), comp_unit_die ());
16650 /* Determine what tag to use for a record type. */
16652 static enum dwarf_tag
16653 record_type_tag (tree type
)
16655 if (! lang_hooks
.types
.classify_record
)
16656 return DW_TAG_structure_type
;
16658 switch (lang_hooks
.types
.classify_record (type
))
16660 case RECORD_IS_STRUCT
:
16661 return DW_TAG_structure_type
;
16663 case RECORD_IS_CLASS
:
16664 return DW_TAG_class_type
;
16666 case RECORD_IS_INTERFACE
:
16667 if (dwarf_version
>= 3 || !dwarf_strict
)
16668 return DW_TAG_interface_type
;
16669 return DW_TAG_structure_type
;
16672 gcc_unreachable ();
16676 /* Generate a DIE to represent an enumeration type. Note that these DIEs
16677 include all of the information about the enumeration values also. Each
16678 enumerated type name/value is listed as a child of the enumerated type
16682 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
16684 dw_die_ref type_die
= lookup_type_die (type
);
16686 if (type_die
== NULL
)
16688 type_die
= new_die (DW_TAG_enumeration_type
,
16689 scope_die_for (type
, context_die
), type
);
16690 equate_type_number_to_die (type
, type_die
);
16691 add_name_attribute (type_die
, type_tag (type
));
16692 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
16693 if (TYPE_ARTIFICIAL (type
))
16694 add_AT_flag (type_die
, DW_AT_artificial
, 1);
16695 if (dwarf_version
>= 4 || !dwarf_strict
)
16697 if (ENUM_IS_SCOPED (type
))
16698 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
16699 if (ENUM_IS_OPAQUE (type
))
16700 add_AT_flag (type_die
, DW_AT_declaration
, 1);
16703 else if (! TYPE_SIZE (type
))
16706 remove_AT (type_die
, DW_AT_declaration
);
16708 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
16709 given enum type is incomplete, do not generate the DW_AT_byte_size
16710 attribute or the DW_AT_element_list attribute. */
16711 if (TYPE_SIZE (type
))
16715 TREE_ASM_WRITTEN (type
) = 1;
16716 add_byte_size_attribute (type_die
, type
);
16717 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
16719 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
16720 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
16723 /* If the first reference to this type was as the return type of an
16724 inline function, then it may not have a parent. Fix this now. */
16725 if (type_die
->die_parent
== NULL
)
16726 add_child_die (scope_die_for (type
, context_die
), type_die
);
16728 for (link
= TYPE_VALUES (type
);
16729 link
!= NULL
; link
= TREE_CHAIN (link
))
16731 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
16732 tree value
= TREE_VALUE (link
);
16734 add_name_attribute (enum_die
,
16735 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
16737 if (TREE_CODE (value
) == CONST_DECL
)
16738 value
= DECL_INITIAL (value
);
16740 if (host_integerp (value
, TYPE_UNSIGNED (TREE_TYPE (value
))))
16741 /* DWARF2 does not provide a way of indicating whether or
16742 not enumeration constants are signed or unsigned. GDB
16743 always assumes the values are signed, so we output all
16744 values as if they were signed. That means that
16745 enumeration constants with very large unsigned values
16746 will appear to have negative values in the debugger. */
16747 add_AT_int (enum_die
, DW_AT_const_value
,
16748 tree_low_cst (value
, tree_int_cst_sgn (value
) > 0));
16752 add_AT_flag (type_die
, DW_AT_declaration
, 1);
16754 if (get_AT (type_die
, DW_AT_name
))
16755 add_pubtype (type
, type_die
);
16760 /* Generate a DIE to represent either a real live formal parameter decl or to
16761 represent just the type of some formal parameter position in some function
16764 Note that this routine is a bit unusual because its argument may be a
16765 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
16766 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
16767 node. If it's the former then this function is being called to output a
16768 DIE to represent a formal parameter object (or some inlining thereof). If
16769 it's the latter, then this function is only being called to output a
16770 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
16771 argument type of some subprogram type.
16772 If EMIT_NAME_P is true, name and source coordinate attributes
16776 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
16777 dw_die_ref context_die
)
16779 tree node_or_origin
= node
? node
: origin
;
16780 tree ultimate_origin
;
16781 dw_die_ref parm_die
16782 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
16784 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
16786 case tcc_declaration
:
16787 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
16788 if (node
|| ultimate_origin
)
16789 origin
= ultimate_origin
;
16790 if (origin
!= NULL
)
16791 add_abstract_origin_attribute (parm_die
, origin
);
16792 else if (emit_name_p
)
16793 add_name_and_src_coords_attributes (parm_die
, node
);
16795 || (! DECL_ABSTRACT (node_or_origin
)
16796 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
16797 decl_function_context
16798 (node_or_origin
))))
16800 tree type
= TREE_TYPE (node_or_origin
);
16801 if (decl_by_reference_p (node_or_origin
))
16802 add_type_attribute (parm_die
, TREE_TYPE (type
), 0, 0,
16805 add_type_attribute (parm_die
, type
,
16806 TREE_READONLY (node_or_origin
),
16807 TREE_THIS_VOLATILE (node_or_origin
),
16810 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
16811 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
16813 if (node
&& node
!= origin
)
16814 equate_decl_number_to_die (node
, parm_die
);
16815 if (! DECL_ABSTRACT (node_or_origin
))
16816 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
16817 node
== NULL
, DW_AT_location
);
16822 /* We were called with some kind of a ..._TYPE node. */
16823 add_type_attribute (parm_die
, node_or_origin
, 0, 0, context_die
);
16827 gcc_unreachable ();
16833 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
16834 children DW_TAG_formal_parameter DIEs representing the arguments of the
16837 PARM_PACK must be a function parameter pack.
16838 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
16839 must point to the subsequent arguments of the function PACK_ARG belongs to.
16840 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
16841 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
16842 following the last one for which a DIE was generated. */
16845 gen_formal_parameter_pack_die (tree parm_pack
,
16847 dw_die_ref subr_die
,
16851 dw_die_ref parm_pack_die
;
16853 gcc_assert (parm_pack
16854 && lang_hooks
.function_parameter_pack_p (parm_pack
)
16857 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
16858 add_src_coords_attributes (parm_pack_die
, parm_pack
);
16860 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
16862 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
16865 gen_formal_parameter_die (arg
, NULL
,
16866 false /* Don't emit name attribute. */,
16871 return parm_pack_die
;
16874 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
16875 at the end of an (ANSI prototyped) formal parameters list. */
16878 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
16880 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
16883 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
16884 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
16885 parameters as specified in some function type specification (except for
16886 those which appear as part of a function *definition*). */
16889 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
16892 tree formal_type
= NULL
;
16893 tree first_parm_type
;
16896 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
16898 arg
= DECL_ARGUMENTS (function_or_method_type
);
16899 function_or_method_type
= TREE_TYPE (function_or_method_type
);
16904 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
16906 /* Make our first pass over the list of formal parameter types and output a
16907 DW_TAG_formal_parameter DIE for each one. */
16908 for (link
= first_parm_type
; link
; )
16910 dw_die_ref parm_die
;
16912 formal_type
= TREE_VALUE (link
);
16913 if (formal_type
== void_type_node
)
16916 /* Output a (nameless) DIE to represent the formal parameter itself. */
16917 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
16918 true /* Emit name attribute. */,
16920 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
16921 && link
== first_parm_type
)
16923 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
16924 if (dwarf_version
>= 3 || !dwarf_strict
)
16925 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
16927 else if (arg
&& DECL_ARTIFICIAL (arg
))
16928 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
16930 link
= TREE_CHAIN (link
);
16932 arg
= DECL_CHAIN (arg
);
16935 /* If this function type has an ellipsis, add a
16936 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
16937 if (formal_type
!= void_type_node
)
16938 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
16940 /* Make our second (and final) pass over the list of formal parameter types
16941 and output DIEs to represent those types (as necessary). */
16942 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
16943 link
&& TREE_VALUE (link
);
16944 link
= TREE_CHAIN (link
))
16945 gen_type_die (TREE_VALUE (link
), context_die
);
16948 /* We want to generate the DIE for TYPE so that we can generate the
16949 die for MEMBER, which has been defined; we will need to refer back
16950 to the member declaration nested within TYPE. If we're trying to
16951 generate minimal debug info for TYPE, processing TYPE won't do the
16952 trick; we need to attach the member declaration by hand. */
16955 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
16957 gen_type_die (type
, context_die
);
16959 /* If we're trying to avoid duplicate debug info, we may not have
16960 emitted the member decl for this function. Emit it now. */
16961 if (TYPE_STUB_DECL (type
)
16962 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
16963 && ! lookup_decl_die (member
))
16965 dw_die_ref type_die
;
16966 gcc_assert (!decl_ultimate_origin (member
));
16968 push_decl_scope (type
);
16969 type_die
= lookup_type_die_strip_naming_typedef (type
);
16970 if (TREE_CODE (member
) == FUNCTION_DECL
)
16971 gen_subprogram_die (member
, type_die
);
16972 else if (TREE_CODE (member
) == FIELD_DECL
)
16974 /* Ignore the nameless fields that are used to skip bits but handle
16975 C++ anonymous unions and structs. */
16976 if (DECL_NAME (member
) != NULL_TREE
16977 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
16978 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
16980 gen_type_die (member_declared_type (member
), type_die
);
16981 gen_field_die (member
, type_die
);
16985 gen_variable_die (member
, NULL_TREE
, type_die
);
16991 /* Generate the DWARF2 info for the "abstract" instance of a function which we
16992 may later generate inlined and/or out-of-line instances of. */
16995 dwarf2out_abstract_function (tree decl
)
16997 dw_die_ref old_die
;
17001 htab_t old_decl_loc_table
;
17002 htab_t old_cached_dw_loc_list_table
;
17003 int old_call_site_count
, old_tail_call_site_count
;
17004 struct call_arg_loc_node
*old_call_arg_locations
;
17006 /* Make sure we have the actual abstract inline, not a clone. */
17007 decl
= DECL_ORIGIN (decl
);
17009 old_die
= lookup_decl_die (decl
);
17010 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
17011 /* We've already generated the abstract instance. */
17014 /* We can be called while recursively when seeing block defining inlined subroutine
17015 DIE. Be sure to not clobber the outer location table nor use it or we would
17016 get locations in abstract instantces. */
17017 old_decl_loc_table
= decl_loc_table
;
17018 decl_loc_table
= NULL
;
17019 old_cached_dw_loc_list_table
= cached_dw_loc_list_table
;
17020 cached_dw_loc_list_table
= NULL
;
17021 old_call_arg_locations
= call_arg_locations
;
17022 call_arg_locations
= NULL
;
17023 old_call_site_count
= call_site_count
;
17024 call_site_count
= -1;
17025 old_tail_call_site_count
= tail_call_site_count
;
17026 tail_call_site_count
= -1;
17028 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
17029 we don't get confused by DECL_ABSTRACT. */
17030 if (debug_info_level
> DINFO_LEVEL_TERSE
)
17032 context
= decl_class_context (decl
);
17034 gen_type_die_for_member
17035 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die ());
17038 /* Pretend we've just finished compiling this function. */
17039 save_fn
= current_function_decl
;
17040 current_function_decl
= decl
;
17041 push_cfun (DECL_STRUCT_FUNCTION (decl
));
17043 was_abstract
= DECL_ABSTRACT (decl
);
17044 set_decl_abstract_flags (decl
, 1);
17045 dwarf2out_decl (decl
);
17046 if (! was_abstract
)
17047 set_decl_abstract_flags (decl
, 0);
17049 current_function_decl
= save_fn
;
17050 decl_loc_table
= old_decl_loc_table
;
17051 cached_dw_loc_list_table
= old_cached_dw_loc_list_table
;
17052 call_arg_locations
= old_call_arg_locations
;
17053 call_site_count
= old_call_site_count
;
17054 tail_call_site_count
= old_tail_call_site_count
;
17058 /* Helper function of premark_used_types() which gets called through
17061 Marks the DIE of a given type in *SLOT as perennial, so it never gets
17062 marked as unused by prune_unused_types. */
17065 premark_used_types_helper (void **slot
, void *data ATTRIBUTE_UNUSED
)
17070 type
= (tree
) *slot
;
17071 die
= lookup_type_die (type
);
17073 die
->die_perennial_p
= 1;
17077 /* Helper function of premark_types_used_by_global_vars which gets called
17078 through htab_traverse.
17080 Marks the DIE of a given type in *SLOT as perennial, so it never gets
17081 marked as unused by prune_unused_types. The DIE of the type is marked
17082 only if the global variable using the type will actually be emitted. */
17085 premark_types_used_by_global_vars_helper (void **slot
,
17086 void *data ATTRIBUTE_UNUSED
)
17088 struct types_used_by_vars_entry
*entry
;
17091 entry
= (struct types_used_by_vars_entry
*) *slot
;
17092 gcc_assert (entry
->type
!= NULL
17093 && entry
->var_decl
!= NULL
);
17094 die
= lookup_type_die (entry
->type
);
17097 /* Ask cgraph if the global variable really is to be emitted.
17098 If yes, then we'll keep the DIE of ENTRY->TYPE. */
17099 struct varpool_node
*node
= varpool_get_node (entry
->var_decl
);
17100 if (node
&& node
->needed
)
17102 die
->die_perennial_p
= 1;
17103 /* Keep the parent DIEs as well. */
17104 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
17105 die
->die_perennial_p
= 1;
17111 /* Mark all members of used_types_hash as perennial. */
17114 premark_used_types (void)
17116 if (cfun
&& cfun
->used_types_hash
)
17117 htab_traverse (cfun
->used_types_hash
, premark_used_types_helper
, NULL
);
17120 /* Mark all members of types_used_by_vars_entry as perennial. */
17123 premark_types_used_by_global_vars (void)
17125 if (types_used_by_vars_hash
)
17126 htab_traverse (types_used_by_vars_hash
,
17127 premark_types_used_by_global_vars_helper
, NULL
);
17130 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
17131 for CA_LOC call arg loc node. */
17134 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
17135 struct call_arg_loc_node
*ca_loc
)
17137 dw_die_ref stmt_die
= NULL
, die
;
17138 tree block
= ca_loc
->block
;
17141 && block
!= DECL_INITIAL (decl
)
17142 && TREE_CODE (block
) == BLOCK
)
17144 if (VEC_length (dw_die_ref
, block_map
) > BLOCK_NUMBER (block
))
17145 stmt_die
= VEC_index (dw_die_ref
, block_map
, BLOCK_NUMBER (block
));
17148 block
= BLOCK_SUPERCONTEXT (block
);
17150 if (stmt_die
== NULL
)
17151 stmt_die
= subr_die
;
17152 die
= new_die (DW_TAG_GNU_call_site
, stmt_die
, NULL_TREE
);
17153 add_AT_lbl_id (die
, DW_AT_low_pc
, ca_loc
->label
);
17154 if (ca_loc
->tail_call_p
)
17155 add_AT_flag (die
, DW_AT_GNU_tail_call
, 1);
17156 if (ca_loc
->symbol_ref
)
17158 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
17160 add_AT_die_ref (die
, DW_AT_abstract_origin
, tdie
);
17162 add_AT_addr (die
, DW_AT_abstract_origin
, ca_loc
->symbol_ref
);
17167 /* Generate a DIE to represent a declared function (either file-scope or
17171 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
17173 tree origin
= decl_ultimate_origin (decl
);
17174 dw_die_ref subr_die
;
17176 dw_die_ref old_die
= lookup_decl_die (decl
);
17177 int declaration
= (current_function_decl
!= decl
17178 || class_or_namespace_scope_p (context_die
));
17180 premark_used_types ();
17182 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
17183 started to generate the abstract instance of an inline, decided to output
17184 its containing class, and proceeded to emit the declaration of the inline
17185 from the member list for the class. If so, DECLARATION takes priority;
17186 we'll get back to the abstract instance when done with the class. */
17188 /* The class-scope declaration DIE must be the primary DIE. */
17189 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
17192 gcc_assert (!old_die
);
17195 /* Now that the C++ front end lazily declares artificial member fns, we
17196 might need to retrofit the declaration into its class. */
17197 if (!declaration
&& !origin
&& !old_die
17198 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
17199 && !class_or_namespace_scope_p (context_die
)
17200 && debug_info_level
> DINFO_LEVEL_TERSE
)
17201 old_die
= force_decl_die (decl
);
17203 if (origin
!= NULL
)
17205 gcc_assert (!declaration
|| local_scope_p (context_die
));
17207 /* Fixup die_parent for the abstract instance of a nested
17208 inline function. */
17209 if (old_die
&& old_die
->die_parent
== NULL
)
17210 add_child_die (context_die
, old_die
);
17212 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
17213 add_abstract_origin_attribute (subr_die
, origin
);
17214 /* This is where the actual code for a cloned function is.
17215 Let's emit linkage name attribute for it. This helps
17216 debuggers to e.g, set breakpoints into
17217 constructors/destructors when the user asks "break
17219 add_linkage_name (subr_die
, decl
);
17223 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
17224 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
17226 if (!get_AT_flag (old_die
, DW_AT_declaration
)
17227 /* We can have a normal definition following an inline one in the
17228 case of redefinition of GNU C extern inlines.
17229 It seems reasonable to use AT_specification in this case. */
17230 && !get_AT (old_die
, DW_AT_inline
))
17232 /* Detect and ignore this case, where we are trying to output
17233 something we have already output. */
17237 /* If the definition comes from the same place as the declaration,
17238 maybe use the old DIE. We always want the DIE for this function
17239 that has the *_pc attributes to be under comp_unit_die so the
17240 debugger can find it. We also need to do this for abstract
17241 instances of inlines, since the spec requires the out-of-line copy
17242 to have the same parent. For local class methods, this doesn't
17243 apply; we just use the old DIE. */
17244 if ((is_cu_die (old_die
->die_parent
) || context_die
== NULL
)
17245 && (DECL_ARTIFICIAL (decl
)
17246 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
17247 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
17248 == (unsigned) s
.line
))))
17250 subr_die
= old_die
;
17252 /* Clear out the declaration attribute and the formal parameters.
17253 Do not remove all children, because it is possible that this
17254 declaration die was forced using force_decl_die(). In such
17255 cases die that forced declaration die (e.g. TAG_imported_module)
17256 is one of the children that we do not want to remove. */
17257 remove_AT (subr_die
, DW_AT_declaration
);
17258 remove_AT (subr_die
, DW_AT_object_pointer
);
17259 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
17263 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
17264 add_AT_specification (subr_die
, old_die
);
17265 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
17266 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
17267 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
17268 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
17273 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
17275 if (TREE_PUBLIC (decl
))
17276 add_AT_flag (subr_die
, DW_AT_external
, 1);
17278 add_name_and_src_coords_attributes (subr_die
, decl
);
17279 if (debug_info_level
> DINFO_LEVEL_TERSE
)
17281 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
17282 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
17283 0, 0, context_die
);
17286 add_pure_or_virtual_attribute (subr_die
, decl
);
17287 if (DECL_ARTIFICIAL (decl
))
17288 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
17290 add_accessibility_attribute (subr_die
, decl
);
17295 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
17297 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
17299 /* If this is an explicit function declaration then generate
17300 a DW_AT_explicit attribute. */
17301 if (lang_hooks
.decls
.function_decl_explicit_p (decl
)
17302 && (dwarf_version
>= 3 || !dwarf_strict
))
17303 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
17305 /* The first time we see a member function, it is in the context of
17306 the class to which it belongs. We make sure of this by emitting
17307 the class first. The next time is the definition, which is
17308 handled above. The two may come from the same source text.
17310 Note that force_decl_die() forces function declaration die. It is
17311 later reused to represent definition. */
17312 equate_decl_number_to_die (decl
, subr_die
);
17315 else if (DECL_ABSTRACT (decl
))
17317 if (DECL_DECLARED_INLINE_P (decl
))
17319 if (cgraph_function_possibly_inlined_p (decl
))
17320 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
17322 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
17326 if (cgraph_function_possibly_inlined_p (decl
))
17327 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
17329 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
17332 if (DECL_DECLARED_INLINE_P (decl
)
17333 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
17334 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
17336 equate_decl_number_to_die (decl
, subr_die
);
17338 else if (!DECL_EXTERNAL (decl
))
17340 HOST_WIDE_INT cfa_fb_offset
;
17342 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
17343 equate_decl_number_to_die (decl
, subr_die
);
17345 if (!flag_reorder_blocks_and_partition
)
17347 dw_fde_ref fde
= cfun
->fde
;
17348 if (fde
->dw_fde_begin
)
17350 /* We have already generated the labels. */
17351 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, fde
->dw_fde_begin
);
17352 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, fde
->dw_fde_end
);
17356 /* Create start/end labels and add the range. */
17357 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
17358 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_BEGIN_LABEL
,
17359 current_function_funcdef_no
);
17360 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label_id
);
17361 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
17362 current_function_funcdef_no
);
17363 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label_id
);
17366 #if VMS_DEBUGGING_INFO
17367 /* HP OpenVMS Industry Standard 64: DWARF Extensions
17368 Section 2.3 Prologue and Epilogue Attributes:
17369 When a breakpoint is set on entry to a function, it is generally
17370 desirable for execution to be suspended, not on the very first
17371 instruction of the function, but rather at a point after the
17372 function's frame has been set up, after any language defined local
17373 declaration processing has been completed, and before execution of
17374 the first statement of the function begins. Debuggers generally
17375 cannot properly determine where this point is. Similarly for a
17376 breakpoint set on exit from a function. The prologue and epilogue
17377 attributes allow a compiler to communicate the location(s) to use. */
17380 if (fde
->dw_fde_vms_end_prologue
)
17381 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
17382 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
17384 if (fde
->dw_fde_vms_begin_epilogue
)
17385 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
17386 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
17390 add_pubname (decl
, subr_die
);
17394 /* Generate pubnames entries for the split function code ranges. */
17395 dw_fde_ref fde
= cfun
->fde
;
17397 if (fde
->dw_fde_second_begin
)
17399 if (dwarf_version
>= 3 || !dwarf_strict
)
17401 /* We should use ranges for non-contiguous code section
17402 addresses. Use the actual code range for the initial
17403 section, since the HOT/COLD labels might precede an
17404 alignment offset. */
17405 bool range_list_added
= false;
17406 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
17407 fde
->dw_fde_end
, &range_list_added
);
17408 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
17409 fde
->dw_fde_second_end
,
17410 &range_list_added
);
17411 add_pubname (decl
, subr_die
);
17412 if (range_list_added
)
17417 /* There is no real support in DW2 for this .. so we make
17418 a work-around. First, emit the pub name for the segment
17419 containing the function label. Then make and emit a
17420 simplified subprogram DIE for the second segment with the
17421 name pre-fixed by __hot/cold_sect_of_. We use the same
17422 linkage name for the second die so that gdb will find both
17423 sections when given "b foo". */
17424 const char *name
= NULL
;
17425 tree decl_name
= DECL_NAME (decl
);
17426 dw_die_ref seg_die
;
17428 /* Do the 'primary' section. */
17429 add_AT_lbl_id (subr_die
, DW_AT_low_pc
,
17430 fde
->dw_fde_begin
);
17431 add_AT_lbl_id (subr_die
, DW_AT_high_pc
,
17434 add_pubname (decl
, subr_die
);
17436 /* Build a minimal DIE for the secondary section. */
17437 seg_die
= new_die (DW_TAG_subprogram
,
17438 subr_die
->die_parent
, decl
);
17440 if (TREE_PUBLIC (decl
))
17441 add_AT_flag (seg_die
, DW_AT_external
, 1);
17443 if (decl_name
!= NULL
17444 && IDENTIFIER_POINTER (decl_name
) != NULL
)
17446 name
= dwarf2_name (decl
, 1);
17447 if (! DECL_ARTIFICIAL (decl
))
17448 add_src_coords_attributes (seg_die
, decl
);
17450 add_linkage_name (seg_die
, decl
);
17452 gcc_assert (name
!= NULL
);
17453 add_pure_or_virtual_attribute (seg_die
, decl
);
17454 if (DECL_ARTIFICIAL (decl
))
17455 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
17457 name
= concat ("__second_sect_of_", name
, NULL
);
17458 add_AT_lbl_id (seg_die
, DW_AT_low_pc
,
17459 fde
->dw_fde_second_begin
);
17460 add_AT_lbl_id (seg_die
, DW_AT_high_pc
,
17461 fde
->dw_fde_second_end
);
17462 add_name_attribute (seg_die
, name
);
17463 add_pubname_string (name
, seg_die
);
17468 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, fde
->dw_fde_begin
);
17469 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, fde
->dw_fde_end
);
17470 add_pubname (decl
, subr_die
);
17474 #ifdef MIPS_DEBUGGING_INFO
17475 /* Add a reference to the FDE for this routine. */
17476 add_AT_fde_ref (subr_die
, DW_AT_MIPS_fde
, cfun
->fde
->fde_index
);
17479 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
17481 /* We define the "frame base" as the function's CFA. This is more
17482 convenient for several reasons: (1) It's stable across the prologue
17483 and epilogue, which makes it better than just a frame pointer,
17484 (2) With dwarf3, there exists a one-byte encoding that allows us
17485 to reference the .debug_frame data by proxy, but failing that,
17486 (3) We can at least reuse the code inspection and interpretation
17487 code that determines the CFA position at various points in the
17489 if (dwarf_version
>= 3)
17491 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
17492 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
17496 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
17497 if (list
->dw_loc_next
)
17498 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
17500 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
17503 /* Compute a displacement from the "steady-state frame pointer" to
17504 the CFA. The former is what all stack slots and argument slots
17505 will reference in the rtl; the later is what we've told the
17506 debugger about. We'll need to adjust all frame_base references
17507 by this displacement. */
17508 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
17510 if (cfun
->static_chain_decl
)
17511 add_AT_location_description (subr_die
, DW_AT_static_link
,
17512 loc_list_from_tree (cfun
->static_chain_decl
, 2));
17515 /* Generate child dies for template paramaters. */
17516 if (debug_info_level
> DINFO_LEVEL_TERSE
)
17517 gen_generic_params_dies (decl
);
17519 /* Now output descriptions of the arguments for this function. This gets
17520 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
17521 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
17522 `...' at the end of the formal parameter list. In order to find out if
17523 there was a trailing ellipsis or not, we must instead look at the type
17524 associated with the FUNCTION_DECL. This will be a node of type
17525 FUNCTION_TYPE. If the chain of type nodes hanging off of this
17526 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
17527 an ellipsis at the end. */
17529 /* In the case where we are describing a mere function declaration, all we
17530 need to do here (and all we *can* do here) is to describe the *types* of
17531 its formal parameters. */
17532 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
17534 else if (declaration
)
17535 gen_formal_types_die (decl
, subr_die
);
17538 /* Generate DIEs to represent all known formal parameters. */
17539 tree parm
= DECL_ARGUMENTS (decl
);
17540 tree generic_decl
= lang_hooks
.decls
.get_generic_function_decl (decl
);
17541 tree generic_decl_parm
= generic_decl
17542 ? DECL_ARGUMENTS (generic_decl
)
17545 /* Now we want to walk the list of parameters of the function and
17546 emit their relevant DIEs.
17548 We consider the case of DECL being an instance of a generic function
17549 as well as it being a normal function.
17551 If DECL is an instance of a generic function we walk the
17552 parameters of the generic function declaration _and_ the parameters of
17553 DECL itself. This is useful because we want to emit specific DIEs for
17554 function parameter packs and those are declared as part of the
17555 generic function declaration. In that particular case,
17556 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
17557 That DIE has children DIEs representing the set of arguments
17558 of the pack. Note that the set of pack arguments can be empty.
17559 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
17562 Otherwise, we just consider the parameters of DECL. */
17563 while (generic_decl_parm
|| parm
)
17565 if (generic_decl_parm
17566 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
17567 gen_formal_parameter_pack_die (generic_decl_parm
,
17572 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, subr_die
);
17574 if (parm
== DECL_ARGUMENTS (decl
)
17575 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
17577 && (dwarf_version
>= 3 || !dwarf_strict
))
17578 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
17580 parm
= DECL_CHAIN (parm
);
17583 if (generic_decl_parm
)
17584 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
17587 /* Decide whether we need an unspecified_parameters DIE at the end.
17588 There are 2 more cases to do this for: 1) the ansi ... declaration -
17589 this is detectable when the end of the arg list is not a
17590 void_type_node 2) an unprototyped function declaration (not a
17591 definition). This just means that we have no info about the
17592 parameters at all. */
17593 if (prototype_p (TREE_TYPE (decl
)))
17595 /* This is the prototyped case, check for.... */
17596 if (stdarg_p (TREE_TYPE (decl
)))
17597 gen_unspecified_parameters_die (decl
, subr_die
);
17599 else if (DECL_INITIAL (decl
) == NULL_TREE
)
17600 gen_unspecified_parameters_die (decl
, subr_die
);
17603 /* Output Dwarf info for all of the stuff within the body of the function
17604 (if it has one - it may be just a declaration). */
17605 outer_scope
= DECL_INITIAL (decl
);
17607 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
17608 a function. This BLOCK actually represents the outermost binding contour
17609 for the function, i.e. the contour in which the function's formal
17610 parameters and labels get declared. Curiously, it appears that the front
17611 end doesn't actually put the PARM_DECL nodes for the current function onto
17612 the BLOCK_VARS list for this outer scope, but are strung off of the
17613 DECL_ARGUMENTS list for the function instead.
17615 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
17616 the LABEL_DECL nodes for the function however, and we output DWARF info
17617 for those in decls_for_scope. Just within the `outer_scope' there will be
17618 a BLOCK node representing the function's outermost pair of curly braces,
17619 and any blocks used for the base and member initializers of a C++
17620 constructor function. */
17621 if (! declaration
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
17623 int call_site_note_count
= 0;
17624 int tail_call_site_note_count
= 0;
17626 /* Emit a DW_TAG_variable DIE for a named return value. */
17627 if (DECL_NAME (DECL_RESULT (decl
)))
17628 gen_decl_die (DECL_RESULT (decl
), NULL
, subr_die
);
17630 current_function_has_inlines
= 0;
17631 decls_for_scope (outer_scope
, subr_die
, 0);
17633 if (call_arg_locations
&& !dwarf_strict
)
17635 struct call_arg_loc_node
*ca_loc
;
17636 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
17638 dw_die_ref die
= NULL
;
17639 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
17642 for (arg
= NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
);
17643 arg
; arg
= next_arg
)
17645 dw_loc_descr_ref reg
, val
;
17646 enum machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
17647 dw_die_ref cdie
, tdie
= NULL
;
17649 next_arg
= XEXP (arg
, 1);
17650 if (REG_P (XEXP (XEXP (arg
, 0), 0))
17652 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
17653 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
17654 && REGNO (XEXP (XEXP (arg
, 0), 0))
17655 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
17656 next_arg
= XEXP (next_arg
, 1);
17657 if (mode
== VOIDmode
)
17659 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
17660 if (mode
== VOIDmode
)
17661 mode
= GET_MODE (XEXP (arg
, 0));
17663 if (mode
== VOIDmode
|| mode
== BLKmode
)
17665 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
17667 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
17668 tloc
= XEXP (XEXP (arg
, 0), 1);
17671 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
17672 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
17674 gcc_assert (ca_loc
->symbol_ref
== NULL_RTX
);
17675 tlocc
= XEXP (XEXP (arg
, 0), 1);
17679 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
17680 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
17681 VAR_INIT_STATUS_INITIALIZED
);
17682 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
17684 rtx mem
= XEXP (XEXP (arg
, 0), 0);
17685 reg
= mem_loc_descriptor (XEXP (mem
, 0),
17686 get_address_mode (mem
),
17688 VAR_INIT_STATUS_INITIALIZED
);
17690 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
17691 == DEBUG_PARAMETER_REF
)
17694 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
17695 tdie
= lookup_decl_die (tdecl
);
17702 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
17703 != DEBUG_PARAMETER_REF
)
17705 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
17707 VAR_INIT_STATUS_INITIALIZED
);
17711 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
17712 cdie
= new_die (DW_TAG_GNU_call_site_parameter
, die
,
17715 add_AT_loc (cdie
, DW_AT_location
, reg
);
17716 else if (tdie
!= NULL
)
17717 add_AT_die_ref (cdie
, DW_AT_abstract_origin
, tdie
);
17718 add_AT_loc (cdie
, DW_AT_GNU_call_site_value
, val
);
17719 if (next_arg
!= XEXP (arg
, 1))
17721 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
17722 if (mode
== VOIDmode
)
17723 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
17724 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
17727 VAR_INIT_STATUS_INITIALIZED
);
17729 add_AT_loc (cdie
, DW_AT_GNU_call_site_data_value
, val
);
17733 && (ca_loc
->symbol_ref
|| tloc
))
17734 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
17735 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
17737 dw_loc_descr_ref tval
= NULL
;
17739 if (tloc
!= NULL_RTX
)
17740 tval
= mem_loc_descriptor (tloc
,
17741 GET_MODE (tloc
) == VOIDmode
17742 ? Pmode
: GET_MODE (tloc
),
17744 VAR_INIT_STATUS_INITIALIZED
);
17746 add_AT_loc (die
, DW_AT_GNU_call_site_target
, tval
);
17747 else if (tlocc
!= NULL_RTX
)
17749 tval
= mem_loc_descriptor (tlocc
,
17750 GET_MODE (tlocc
) == VOIDmode
17751 ? Pmode
: GET_MODE (tlocc
),
17753 VAR_INIT_STATUS_INITIALIZED
);
17755 add_AT_loc (die
, DW_AT_GNU_call_site_target_clobbered
,
17761 call_site_note_count
++;
17762 if (ca_loc
->tail_call_p
)
17763 tail_call_site_note_count
++;
17767 call_arg_locations
= NULL
;
17768 call_arg_loc_last
= NULL
;
17769 if (tail_call_site_count
>= 0
17770 && tail_call_site_count
== tail_call_site_note_count
17773 if (call_site_count
>= 0
17774 && call_site_count
== call_site_note_count
)
17775 add_AT_flag (subr_die
, DW_AT_GNU_all_call_sites
, 1);
17777 add_AT_flag (subr_die
, DW_AT_GNU_all_tail_call_sites
, 1);
17779 call_site_count
= -1;
17780 tail_call_site_count
= -1;
17782 /* Add the calling convention attribute if requested. */
17783 add_calling_convention_attribute (subr_die
, decl
);
17787 /* Returns a hash value for X (which really is a die_struct). */
17790 common_block_die_table_hash (const void *x
)
17792 const_dw_die_ref d
= (const_dw_die_ref
) x
;
17793 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
17796 /* Return nonzero if decl_id and die_parent of die_struct X is the same
17797 as decl_id and die_parent of die_struct Y. */
17800 common_block_die_table_eq (const void *x
, const void *y
)
17802 const_dw_die_ref d
= (const_dw_die_ref
) x
;
17803 const_dw_die_ref e
= (const_dw_die_ref
) y
;
17804 return d
->decl_id
== e
->decl_id
&& d
->die_parent
== e
->die_parent
;
17807 /* Generate a DIE to represent a declared data object.
17808 Either DECL or ORIGIN must be non-null. */
17811 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
17815 tree decl_or_origin
= decl
? decl
: origin
;
17816 tree ultimate_origin
;
17817 dw_die_ref var_die
;
17818 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
17819 dw_die_ref origin_die
;
17820 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
17821 || class_or_namespace_scope_p (context_die
));
17822 bool specialization_p
= false;
17824 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
17825 if (decl
|| ultimate_origin
)
17826 origin
= ultimate_origin
;
17827 com_decl
= fortran_common (decl_or_origin
, &off
);
17829 /* Symbol in common gets emitted as a child of the common block, in the form
17830 of a data member. */
17833 dw_die_ref com_die
;
17834 dw_loc_list_ref loc
;
17835 die_node com_die_arg
;
17837 var_die
= lookup_decl_die (decl_or_origin
);
17840 if (get_AT (var_die
, DW_AT_location
) == NULL
)
17842 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2);
17847 /* Optimize the common case. */
17848 if (single_element_loc_list_p (loc
)
17849 && loc
->expr
->dw_loc_opc
== DW_OP_addr
17850 && loc
->expr
->dw_loc_next
== NULL
17851 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
17853 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
17854 = plus_constant (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
, off
);
17856 loc_list_plus_const (loc
, off
);
17858 add_AT_location_description (var_die
, DW_AT_location
, loc
);
17859 remove_AT (var_die
, DW_AT_declaration
);
17865 if (common_block_die_table
== NULL
)
17866 common_block_die_table
17867 = htab_create_ggc (10, common_block_die_table_hash
,
17868 common_block_die_table_eq
, NULL
);
17870 com_die_arg
.decl_id
= DECL_UID (com_decl
);
17871 com_die_arg
.die_parent
= context_die
;
17872 com_die
= (dw_die_ref
) htab_find (common_block_die_table
, &com_die_arg
);
17873 loc
= loc_list_from_tree (com_decl
, 2);
17874 if (com_die
== NULL
)
17877 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
17880 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
17881 add_name_and_src_coords_attributes (com_die
, com_decl
);
17884 add_AT_location_description (com_die
, DW_AT_location
, loc
);
17885 /* Avoid sharing the same loc descriptor between
17886 DW_TAG_common_block and DW_TAG_variable. */
17887 loc
= loc_list_from_tree (com_decl
, 2);
17889 else if (DECL_EXTERNAL (decl
))
17890 add_AT_flag (com_die
, DW_AT_declaration
, 1);
17891 add_pubname_string (cnam
, com_die
); /* ??? needed? */
17892 com_die
->decl_id
= DECL_UID (com_decl
);
17893 slot
= htab_find_slot (common_block_die_table
, com_die
, INSERT
);
17894 *slot
= (void *) com_die
;
17896 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
17898 add_AT_location_description (com_die
, DW_AT_location
, loc
);
17899 loc
= loc_list_from_tree (com_decl
, 2);
17900 remove_AT (com_die
, DW_AT_declaration
);
17902 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
17903 add_name_and_src_coords_attributes (var_die
, decl
);
17904 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
17905 TREE_THIS_VOLATILE (decl
), context_die
);
17906 add_AT_flag (var_die
, DW_AT_external
, 1);
17911 /* Optimize the common case. */
17912 if (single_element_loc_list_p (loc
)
17913 && loc
->expr
->dw_loc_opc
== DW_OP_addr
17914 && loc
->expr
->dw_loc_next
== NULL
17915 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
17916 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
17917 = plus_constant (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
, off
);
17919 loc_list_plus_const (loc
, off
);
17921 add_AT_location_description (var_die
, DW_AT_location
, loc
);
17923 else if (DECL_EXTERNAL (decl
))
17924 add_AT_flag (var_die
, DW_AT_declaration
, 1);
17925 equate_decl_number_to_die (decl
, var_die
);
17929 /* If the compiler emitted a definition for the DECL declaration
17930 and if we already emitted a DIE for it, don't emit a second
17931 DIE for it again. Allow re-declarations of DECLs that are
17932 inside functions, though. */
17933 if (old_die
&& declaration
&& !local_scope_p (context_die
))
17936 /* For static data members, the declaration in the class is supposed
17937 to have DW_TAG_member tag; the specification should still be
17938 DW_TAG_variable referencing the DW_TAG_member DIE. */
17939 if (declaration
&& class_scope_p (context_die
))
17940 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
17942 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
17945 if (origin
!= NULL
)
17946 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
17948 /* Loop unrolling can create multiple blocks that refer to the same
17949 static variable, so we must test for the DW_AT_declaration flag.
17951 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
17952 copy decls and set the DECL_ABSTRACT flag on them instead of
17955 ??? Duplicated blocks have been rewritten to use .debug_ranges.
17957 ??? The declare_in_namespace support causes us to get two DIEs for one
17958 variable, both of which are declarations. We want to avoid considering
17959 one to be a specification, so we must test that this DIE is not a
17961 else if (old_die
&& TREE_STATIC (decl
) && ! declaration
17962 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
17964 /* This is a definition of a C++ class level static. */
17965 add_AT_specification (var_die
, old_die
);
17966 specialization_p
= true;
17967 if (DECL_NAME (decl
))
17969 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
17970 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
17972 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
17973 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
17975 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
17976 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
17978 if (old_die
->die_tag
== DW_TAG_member
)
17979 add_linkage_name (var_die
, decl
);
17983 add_name_and_src_coords_attributes (var_die
, decl
);
17985 if ((origin
== NULL
&& !specialization_p
)
17987 && !DECL_ABSTRACT (decl_or_origin
)
17988 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
17989 decl_function_context
17990 (decl_or_origin
))))
17992 tree type
= TREE_TYPE (decl_or_origin
);
17994 if (decl_by_reference_p (decl_or_origin
))
17995 add_type_attribute (var_die
, TREE_TYPE (type
), 0, 0, context_die
);
17997 add_type_attribute (var_die
, type
, TREE_READONLY (decl_or_origin
),
17998 TREE_THIS_VOLATILE (decl_or_origin
), context_die
);
18001 if (origin
== NULL
&& !specialization_p
)
18003 if (TREE_PUBLIC (decl
))
18004 add_AT_flag (var_die
, DW_AT_external
, 1);
18006 if (DECL_ARTIFICIAL (decl
))
18007 add_AT_flag (var_die
, DW_AT_artificial
, 1);
18009 add_accessibility_attribute (var_die
, decl
);
18013 add_AT_flag (var_die
, DW_AT_declaration
, 1);
18015 if (decl
&& (DECL_ABSTRACT (decl
) || declaration
|| old_die
== NULL
))
18016 equate_decl_number_to_die (decl
, var_die
);
18019 && (! DECL_ABSTRACT (decl_or_origin
)
18020 /* Local static vars are shared between all clones/inlines,
18021 so emit DW_AT_location on the abstract DIE if DECL_RTL is
18023 || (TREE_CODE (decl_or_origin
) == VAR_DECL
18024 && TREE_STATIC (decl_or_origin
)
18025 && DECL_RTL_SET_P (decl_or_origin
)))
18026 /* When abstract origin already has DW_AT_location attribute, no need
18027 to add it again. */
18028 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
18030 if (TREE_CODE (decl_or_origin
) == VAR_DECL
&& TREE_STATIC (decl_or_origin
)
18031 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin
)))
18032 defer_location (decl_or_origin
, var_die
);
18034 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
18035 decl
== NULL
, DW_AT_location
);
18036 add_pubname (decl_or_origin
, var_die
);
18039 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
18042 /* Generate a DIE to represent a named constant. */
18045 gen_const_die (tree decl
, dw_die_ref context_die
)
18047 dw_die_ref const_die
;
18048 tree type
= TREE_TYPE (decl
);
18050 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
18051 add_name_and_src_coords_attributes (const_die
, decl
);
18052 add_type_attribute (const_die
, type
, 1, 0, context_die
);
18053 if (TREE_PUBLIC (decl
))
18054 add_AT_flag (const_die
, DW_AT_external
, 1);
18055 if (DECL_ARTIFICIAL (decl
))
18056 add_AT_flag (const_die
, DW_AT_artificial
, 1);
18057 tree_add_const_value_attribute_for_decl (const_die
, decl
);
18060 /* Generate a DIE to represent a label identifier. */
18063 gen_label_die (tree decl
, dw_die_ref context_die
)
18065 tree origin
= decl_ultimate_origin (decl
);
18066 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
18068 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
18070 if (origin
!= NULL
)
18071 add_abstract_origin_attribute (lbl_die
, origin
);
18073 add_name_and_src_coords_attributes (lbl_die
, decl
);
18075 if (DECL_ABSTRACT (decl
))
18076 equate_decl_number_to_die (decl
, lbl_die
);
18079 insn
= DECL_RTL_IF_SET (decl
);
18081 /* Deleted labels are programmer specified labels which have been
18082 eliminated because of various optimizations. We still emit them
18083 here so that it is possible to put breakpoints on them. */
18087 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
18089 /* When optimization is enabled (via -O) some parts of the compiler
18090 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
18091 represent source-level labels which were explicitly declared by
18092 the user. This really shouldn't be happening though, so catch
18093 it if it ever does happen. */
18094 gcc_assert (!INSN_DELETED_P (insn
));
18096 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
18097 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
18101 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
18102 && CODE_LABEL_NUMBER (insn
) != -1)
18104 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
18105 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
18110 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
18111 attributes to the DIE for a block STMT, to describe where the inlined
18112 function was called from. This is similar to add_src_coords_attributes. */
18115 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
18117 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
18119 if (dwarf_version
>= 3 || !dwarf_strict
)
18121 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
18122 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
18127 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
18128 Add low_pc and high_pc attributes to the DIE for a block STMT. */
18131 add_high_low_attributes (tree stmt
, dw_die_ref die
)
18133 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
18135 if (BLOCK_FRAGMENT_CHAIN (stmt
)
18136 && (dwarf_version
>= 3 || !dwarf_strict
))
18140 if (inlined_function_outer_scope_p (stmt
))
18142 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
18143 BLOCK_NUMBER (stmt
));
18144 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
18147 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
));
18149 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
18152 add_ranges (chain
);
18153 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
18160 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
18161 BLOCK_NUMBER (stmt
));
18162 add_AT_lbl_id (die
, DW_AT_low_pc
, label
);
18163 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
18164 BLOCK_NUMBER (stmt
));
18165 add_AT_lbl_id (die
, DW_AT_high_pc
, label
);
18169 /* Generate a DIE for a lexical block. */
18172 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
18174 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
18176 if (call_arg_locations
)
18178 if (VEC_length (dw_die_ref
, block_map
) <= BLOCK_NUMBER (stmt
))
18179 VEC_safe_grow_cleared (dw_die_ref
, heap
, block_map
,
18180 BLOCK_NUMBER (stmt
) + 1);
18181 VEC_replace (dw_die_ref
, block_map
, BLOCK_NUMBER (stmt
), stmt_die
);
18184 if (! BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
18185 add_high_low_attributes (stmt
, stmt_die
);
18187 decls_for_scope (stmt
, stmt_die
, depth
);
18190 /* Generate a DIE for an inlined subprogram. */
18193 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
18197 /* The instance of function that is effectively being inlined shall not
18199 gcc_assert (! BLOCK_ABSTRACT (stmt
));
18201 decl
= block_ultimate_origin (stmt
);
18203 /* Emit info for the abstract instance first, if we haven't yet. We
18204 must emit this even if the block is abstract, otherwise when we
18205 emit the block below (or elsewhere), we may end up trying to emit
18206 a die whose origin die hasn't been emitted, and crashing. */
18207 dwarf2out_abstract_function (decl
);
18209 if (! BLOCK_ABSTRACT (stmt
))
18211 dw_die_ref subr_die
18212 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
18214 if (call_arg_locations
)
18216 if (VEC_length (dw_die_ref
, block_map
) <= BLOCK_NUMBER (stmt
))
18217 VEC_safe_grow_cleared (dw_die_ref
, heap
, block_map
,
18218 BLOCK_NUMBER (stmt
) + 1);
18219 VEC_replace (dw_die_ref
, block_map
, BLOCK_NUMBER (stmt
), subr_die
);
18221 add_abstract_origin_attribute (subr_die
, decl
);
18222 if (TREE_ASM_WRITTEN (stmt
))
18223 add_high_low_attributes (stmt
, subr_die
);
18224 add_call_src_coords_attributes (stmt
, subr_die
);
18226 decls_for_scope (stmt
, subr_die
, depth
);
18227 current_function_has_inlines
= 1;
18231 /* Generate a DIE for a field in a record, or structure. */
18234 gen_field_die (tree decl
, dw_die_ref context_die
)
18236 dw_die_ref decl_die
;
18238 if (TREE_TYPE (decl
) == error_mark_node
)
18241 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
18242 add_name_and_src_coords_attributes (decl_die
, decl
);
18243 add_type_attribute (decl_die
, member_declared_type (decl
),
18244 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
18247 if (DECL_BIT_FIELD_TYPE (decl
))
18249 add_byte_size_attribute (decl_die
, decl
);
18250 add_bit_size_attribute (decl_die
, decl
);
18251 add_bit_offset_attribute (decl_die
, decl
);
18254 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
18255 add_data_member_location_attribute (decl_die
, decl
);
18257 if (DECL_ARTIFICIAL (decl
))
18258 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
18260 add_accessibility_attribute (decl_die
, decl
);
18262 /* Equate decl number to die, so that we can look up this decl later on. */
18263 equate_decl_number_to_die (decl
, decl_die
);
18267 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
18268 Use modified_type_die instead.
18269 We keep this code here just in case these types of DIEs may be needed to
18270 represent certain things in other languages (e.g. Pascal) someday. */
18273 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
18276 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
18278 equate_type_number_to_die (type
, ptr_die
);
18279 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
18280 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
18283 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
18284 Use modified_type_die instead.
18285 We keep this code here just in case these types of DIEs may be needed to
18286 represent certain things in other languages (e.g. Pascal) someday. */
18289 gen_reference_type_die (tree type
, dw_die_ref context_die
)
18291 dw_die_ref ref_die
, scope_die
= scope_die_for (type
, context_die
);
18293 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
18294 ref_die
= new_die (DW_TAG_rvalue_reference_type
, scope_die
, type
);
18296 ref_die
= new_die (DW_TAG_reference_type
, scope_die
, type
);
18298 equate_type_number_to_die (type
, ref_die
);
18299 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
18300 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
18304 /* Generate a DIE for a pointer to a member type. */
18307 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
18310 = new_die (DW_TAG_ptr_to_member_type
,
18311 scope_die_for (type
, context_die
), type
);
18313 equate_type_number_to_die (type
, ptr_die
);
18314 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
18315 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
18316 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
18319 typedef const char *dchar_p
; /* For DEF_VEC_P. */
18320 DEF_VEC_P(dchar_p
);
18321 DEF_VEC_ALLOC_P(dchar_p
,heap
);
18323 static char *producer_string
;
18325 /* Return a heap allocated producer string including command line options
18326 if -grecord-gcc-switches. */
18329 gen_producer_string (void)
18332 VEC(dchar_p
, heap
) *switches
= NULL
;
18333 const char *language_string
= lang_hooks
.name
;
18334 char *producer
, *tail
;
18336 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
18337 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
18339 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
18340 switch (save_decoded_options
[j
].opt_index
)
18347 case OPT_auxbase_strip
:
18356 case OPT_SPECIAL_unknown
:
18357 case OPT_SPECIAL_ignore
:
18358 case OPT_SPECIAL_program_name
:
18359 case OPT_SPECIAL_input_file
:
18360 case OPT_grecord_gcc_switches
:
18361 case OPT_gno_record_gcc_switches
:
18362 case OPT__output_pch_
:
18363 case OPT_fdiagnostics_show_location_
:
18364 case OPT_fdiagnostics_show_option
:
18365 case OPT_fverbose_asm
:
18367 case OPT__sysroot_
:
18369 case OPT_nostdinc__
:
18370 /* Ignore these. */
18373 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
18375 switch (save_decoded_options
[j
].canonical_option
[0][1])
18382 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
18389 VEC_safe_push (dchar_p
, heap
, switches
,
18390 save_decoded_options
[j
].orig_option_with_args_text
);
18391 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
18395 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
18397 sprintf (tail
, "%s %s", language_string
, version_string
);
18400 if (!dwarf_record_gcc_switches
)
18402 #ifdef MIPS_DEBUGGING_INFO
18403 /* The MIPS/SGI compilers place the 'cc' command line options in the
18404 producer string. The SGI debugger looks for -g, -g1, -g2, or -g3;
18405 if they do not appear in the producer string, the debugger reaches
18406 the conclusion that the object file is stripped and has no debugging
18407 information. To get the MIPS/SGI debugger to believe that there is
18408 debugging information in the object file, we add a -g to the producer
18410 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18412 memcpy (tail
, " -g", 3);
18418 FOR_EACH_VEC_ELT (dchar_p
, switches
, j
, p
)
18422 memcpy (tail
+ 1, p
, len
);
18427 VEC_free (dchar_p
, heap
, switches
);
18431 /* Generate the DIE for the compilation unit. */
18434 gen_compile_unit_die (const char *filename
)
18437 const char *language_string
= lang_hooks
.name
;
18440 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
18444 add_name_attribute (die
, filename
);
18445 /* Don't add cwd for <built-in>. */
18446 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
18447 add_comp_dir_attribute (die
);
18450 if (producer_string
== NULL
)
18451 producer_string
= gen_producer_string ();
18452 add_AT_string (die
, DW_AT_producer
, producer_string
);
18454 /* If our producer is LTO try to figure out a common language to use
18455 from the global list of translation units. */
18456 if (strcmp (language_string
, "GNU GIMPLE") == 0)
18460 const char *common_lang
= NULL
;
18462 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
18464 if (!TRANSLATION_UNIT_LANGUAGE (t
))
18467 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
18468 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
18470 else if (strncmp (common_lang
, "GNU C", 5) == 0
18471 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
18472 /* Mixing C and C++ is ok, use C++ in that case. */
18473 common_lang
= "GNU C++";
18476 /* Fall back to C. */
18477 common_lang
= NULL
;
18483 language_string
= common_lang
;
18486 language
= DW_LANG_C89
;
18487 if (strcmp (language_string
, "GNU C++") == 0)
18488 language
= DW_LANG_C_plus_plus
;
18489 else if (strcmp (language_string
, "GNU F77") == 0)
18490 language
= DW_LANG_Fortran77
;
18491 else if (strcmp (language_string
, "GNU Pascal") == 0)
18492 language
= DW_LANG_Pascal83
;
18493 else if (dwarf_version
>= 3 || !dwarf_strict
)
18495 if (strcmp (language_string
, "GNU Ada") == 0)
18496 language
= DW_LANG_Ada95
;
18497 else if (strcmp (language_string
, "GNU Fortran") == 0)
18498 language
= DW_LANG_Fortran95
;
18499 else if (strcmp (language_string
, "GNU Java") == 0)
18500 language
= DW_LANG_Java
;
18501 else if (strcmp (language_string
, "GNU Objective-C") == 0)
18502 language
= DW_LANG_ObjC
;
18503 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
18504 language
= DW_LANG_ObjC_plus_plus
;
18505 else if (dwarf_version
>= 5 || !dwarf_strict
)
18507 if (strcmp (language_string
, "GNU Go") == 0)
18508 language
= DW_LANG_Go
;
18512 add_AT_unsigned (die
, DW_AT_language
, language
);
18516 case DW_LANG_Fortran77
:
18517 case DW_LANG_Fortran90
:
18518 case DW_LANG_Fortran95
:
18519 /* Fortran has case insensitive identifiers and the front-end
18520 lowercases everything. */
18521 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
18524 /* The default DW_ID_case_sensitive doesn't need to be specified. */
18530 /* Generate the DIE for a base class. */
18533 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
18535 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
18537 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
18538 add_data_member_location_attribute (die
, binfo
);
18540 if (BINFO_VIRTUAL_P (binfo
))
18541 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
18543 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
18544 children, otherwise the default is DW_ACCESS_public. In DWARF2
18545 the default has always been DW_ACCESS_private. */
18546 if (access
== access_public_node
)
18548 if (dwarf_version
== 2
18549 || context_die
->die_tag
== DW_TAG_class_type
)
18550 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
18552 else if (access
== access_protected_node
)
18553 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
18554 else if (dwarf_version
> 2
18555 && context_die
->die_tag
!= DW_TAG_class_type
)
18556 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
18559 /* Generate a DIE for a class member. */
18562 gen_member_die (tree type
, dw_die_ref context_die
)
18565 tree binfo
= TYPE_BINFO (type
);
18568 /* If this is not an incomplete type, output descriptions of each of its
18569 members. Note that as we output the DIEs necessary to represent the
18570 members of this record or union type, we will also be trying to output
18571 DIEs to represent the *types* of those members. However the `type'
18572 function (above) will specifically avoid generating type DIEs for member
18573 types *within* the list of member DIEs for this (containing) type except
18574 for those types (of members) which are explicitly marked as also being
18575 members of this (containing) type themselves. The g++ front- end can
18576 force any given type to be treated as a member of some other (containing)
18577 type by setting the TYPE_CONTEXT of the given (member) type to point to
18578 the TREE node representing the appropriate (containing) type. */
18580 /* First output info about the base classes. */
18583 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
18587 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
18588 gen_inheritance_die (base
,
18589 (accesses
? VEC_index (tree
, accesses
, i
)
18590 : access_public_node
), context_die
);
18593 /* Now output info about the data members and type members. */
18594 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
18596 /* If we thought we were generating minimal debug info for TYPE
18597 and then changed our minds, some of the member declarations
18598 may have already been defined. Don't define them again, but
18599 do put them in the right order. */
18601 child
= lookup_decl_die (member
);
18603 splice_child_die (context_die
, child
);
18605 gen_decl_die (member
, NULL
, context_die
);
18608 /* Now output info about the function members (if any). */
18609 for (member
= TYPE_METHODS (type
); member
; member
= DECL_CHAIN (member
))
18611 /* Don't include clones in the member list. */
18612 if (DECL_ABSTRACT_ORIGIN (member
))
18615 child
= lookup_decl_die (member
);
18617 splice_child_die (context_die
, child
);
18619 gen_decl_die (member
, NULL
, context_die
);
18623 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
18624 is set, we pretend that the type was never defined, so we only get the
18625 member DIEs needed by later specification DIEs. */
18628 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
18629 enum debug_info_usage usage
)
18631 dw_die_ref type_die
= lookup_type_die (type
);
18632 dw_die_ref scope_die
= 0;
18634 int complete
= (TYPE_SIZE (type
)
18635 && (! TYPE_STUB_DECL (type
)
18636 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
18637 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
18638 complete
= complete
&& should_emit_struct_debug (type
, usage
);
18640 if (type_die
&& ! complete
)
18643 if (TYPE_CONTEXT (type
) != NULL_TREE
18644 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
18645 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
18648 scope_die
= scope_die_for (type
, context_die
);
18650 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
18651 /* First occurrence of type or toplevel definition of nested class. */
18653 dw_die_ref old_die
= type_die
;
18655 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
18656 ? record_type_tag (type
) : DW_TAG_union_type
,
18658 equate_type_number_to_die (type
, type_die
);
18660 add_AT_specification (type_die
, old_die
);
18663 add_name_attribute (type_die
, type_tag (type
));
18664 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
18665 if (TYPE_ARTIFICIAL (type
))
18666 add_AT_flag (type_die
, DW_AT_artificial
, 1);
18670 remove_AT (type_die
, DW_AT_declaration
);
18672 /* Generate child dies for template paramaters. */
18673 if (debug_info_level
> DINFO_LEVEL_TERSE
18674 && COMPLETE_TYPE_P (type
))
18675 schedule_generic_params_dies_gen (type
);
18677 /* If this type has been completed, then give it a byte_size attribute and
18678 then give a list of members. */
18679 if (complete
&& !ns_decl
)
18681 /* Prevent infinite recursion in cases where the type of some member of
18682 this type is expressed in terms of this type itself. */
18683 TREE_ASM_WRITTEN (type
) = 1;
18684 add_byte_size_attribute (type_die
, type
);
18685 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
18687 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
18688 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
18691 /* If the first reference to this type was as the return type of an
18692 inline function, then it may not have a parent. Fix this now. */
18693 if (type_die
->die_parent
== NULL
)
18694 add_child_die (scope_die
, type_die
);
18696 push_decl_scope (type
);
18697 gen_member_die (type
, type_die
);
18700 /* GNU extension: Record what type our vtable lives in. */
18701 if (TYPE_VFIELD (type
))
18703 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
18705 gen_type_die (vtype
, context_die
);
18706 add_AT_die_ref (type_die
, DW_AT_containing_type
,
18707 lookup_type_die (vtype
));
18712 add_AT_flag (type_die
, DW_AT_declaration
, 1);
18714 /* We don't need to do this for function-local types. */
18715 if (TYPE_STUB_DECL (type
)
18716 && ! decl_function_context (TYPE_STUB_DECL (type
)))
18717 VEC_safe_push (tree
, gc
, incomplete_types
, type
);
18720 if (get_AT (type_die
, DW_AT_name
))
18721 add_pubtype (type
, type_die
);
18724 /* Generate a DIE for a subroutine _type_. */
18727 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
18729 tree return_type
= TREE_TYPE (type
);
18730 dw_die_ref subr_die
18731 = new_die (DW_TAG_subroutine_type
,
18732 scope_die_for (type
, context_die
), type
);
18734 equate_type_number_to_die (type
, subr_die
);
18735 add_prototyped_attribute (subr_die
, type
);
18736 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
18737 gen_formal_types_die (type
, subr_die
);
18739 if (get_AT (subr_die
, DW_AT_name
))
18740 add_pubtype (type
, subr_die
);
18743 /* Generate a DIE for a type definition. */
18746 gen_typedef_die (tree decl
, dw_die_ref context_die
)
18748 dw_die_ref type_die
;
18751 if (TREE_ASM_WRITTEN (decl
))
18754 TREE_ASM_WRITTEN (decl
) = 1;
18755 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
18756 origin
= decl_ultimate_origin (decl
);
18757 if (origin
!= NULL
)
18758 add_abstract_origin_attribute (type_die
, origin
);
18763 add_name_and_src_coords_attributes (type_die
, decl
);
18764 if (DECL_ORIGINAL_TYPE (decl
))
18766 type
= DECL_ORIGINAL_TYPE (decl
);
18768 gcc_assert (type
!= TREE_TYPE (decl
));
18769 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
18773 type
= TREE_TYPE (decl
);
18775 if (is_naming_typedef_decl (TYPE_NAME (type
)))
18777 /* Here, we are in the case of decl being a typedef naming
18778 an anonymous type, e.g:
18779 typedef struct {...} foo;
18780 In that case TREE_TYPE (decl) is not a typedef variant
18781 type and TYPE_NAME of the anonymous type is set to the
18782 TYPE_DECL of the typedef. This construct is emitted by
18785 TYPE is the anonymous struct named by the typedef
18786 DECL. As we need the DW_AT_type attribute of the
18787 DW_TAG_typedef to point to the DIE of TYPE, let's
18788 generate that DIE right away. add_type_attribute
18789 called below will then pick (via lookup_type_die) that
18790 anonymous struct DIE. */
18791 if (!TREE_ASM_WRITTEN (type
))
18792 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
18794 /* This is a GNU Extension. We are adding a
18795 DW_AT_linkage_name attribute to the DIE of the
18796 anonymous struct TYPE. The value of that attribute
18797 is the name of the typedef decl naming the anonymous
18798 struct. This greatly eases the work of consumers of
18799 this debug info. */
18800 add_linkage_attr (lookup_type_die (type
), decl
);
18804 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
18805 TREE_THIS_VOLATILE (decl
), context_die
);
18807 if (is_naming_typedef_decl (decl
))
18808 /* We want that all subsequent calls to lookup_type_die with
18809 TYPE in argument yield the DW_TAG_typedef we have just
18811 equate_type_number_to_die (type
, type_die
);
18813 add_accessibility_attribute (type_die
, decl
);
18816 if (DECL_ABSTRACT (decl
))
18817 equate_decl_number_to_die (decl
, type_die
);
18819 if (get_AT (type_die
, DW_AT_name
))
18820 add_pubtype (decl
, type_die
);
18823 /* Generate a DIE for a struct, class, enum or union type. */
18826 gen_tagged_type_die (tree type
,
18827 dw_die_ref context_die
,
18828 enum debug_info_usage usage
)
18832 if (type
== NULL_TREE
18833 || !is_tagged_type (type
))
18836 /* If this is a nested type whose containing class hasn't been written
18837 out yet, writing it out will cover this one, too. This does not apply
18838 to instantiations of member class templates; they need to be added to
18839 the containing class as they are generated. FIXME: This hurts the
18840 idea of combining type decls from multiple TUs, since we can't predict
18841 what set of template instantiations we'll get. */
18842 if (TYPE_CONTEXT (type
)
18843 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
18844 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
18846 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
18848 if (TREE_ASM_WRITTEN (type
))
18851 /* If that failed, attach ourselves to the stub. */
18852 push_decl_scope (TYPE_CONTEXT (type
));
18853 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
18856 else if (TYPE_CONTEXT (type
) != NULL_TREE
18857 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
18859 /* If this type is local to a function that hasn't been written
18860 out yet, use a NULL context for now; it will be fixed up in
18861 decls_for_scope. */
18862 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
18863 /* A declaration DIE doesn't count; nested types need to go in the
18865 if (context_die
&& is_declaration_die (context_die
))
18866 context_die
= NULL
;
18871 context_die
= declare_in_namespace (type
, context_die
);
18875 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
18877 /* This might have been written out by the call to
18878 declare_in_namespace. */
18879 if (!TREE_ASM_WRITTEN (type
))
18880 gen_enumeration_type_die (type
, context_die
);
18883 gen_struct_or_union_type_die (type
, context_die
, usage
);
18888 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
18889 it up if it is ever completed. gen_*_type_die will set it for us
18890 when appropriate. */
18893 /* Generate a type description DIE. */
18896 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
18897 enum debug_info_usage usage
)
18899 struct array_descr_info info
;
18901 if (type
== NULL_TREE
|| type
== error_mark_node
)
18904 if (TYPE_NAME (type
) != NULL_TREE
18905 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
18906 && is_redundant_typedef (TYPE_NAME (type
))
18907 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
18908 /* The DECL of this type is a typedef we don't want to emit debug
18909 info for but we want debug info for its underlying typedef.
18910 This can happen for e.g, the injected-class-name of a C++
18912 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
18914 /* If TYPE is a typedef type variant, let's generate debug info
18915 for the parent typedef which TYPE is a type of. */
18916 if (typedef_variant_p (type
))
18918 if (TREE_ASM_WRITTEN (type
))
18921 /* Prevent broken recursion; we can't hand off to the same type. */
18922 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
18924 /* Use the DIE of the containing namespace as the parent DIE of
18925 the type description DIE we want to generate. */
18926 if (DECL_FILE_SCOPE_P (TYPE_NAME (type
))
18927 || (DECL_CONTEXT (TYPE_NAME (type
))
18928 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
))
18929 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
18931 TREE_ASM_WRITTEN (type
) = 1;
18933 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
18937 /* If type is an anonymous tagged type named by a typedef, let's
18938 generate debug info for the typedef. */
18939 if (is_naming_typedef_decl (TYPE_NAME (type
)))
18941 /* Use the DIE of the containing namespace as the parent DIE of
18942 the type description DIE we want to generate. */
18943 if (DECL_CONTEXT (TYPE_NAME (type
))
18944 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
18945 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
18947 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
18951 /* If this is an array type with hidden descriptor, handle it first. */
18952 if (!TREE_ASM_WRITTEN (type
)
18953 && lang_hooks
.types
.get_array_descr_info
18954 && lang_hooks
.types
.get_array_descr_info (type
, &info
)
18955 && (dwarf_version
>= 3 || !dwarf_strict
))
18957 gen_descr_array_type_die (type
, &info
, context_die
);
18958 TREE_ASM_WRITTEN (type
) = 1;
18962 /* We are going to output a DIE to represent the unqualified version
18963 of this type (i.e. without any const or volatile qualifiers) so
18964 get the main variant (i.e. the unqualified version) of this type
18965 now. (Vectors are special because the debugging info is in the
18966 cloned type itself). */
18967 if (TREE_CODE (type
) != VECTOR_TYPE
)
18968 type
= type_main_variant (type
);
18970 if (TREE_ASM_WRITTEN (type
))
18973 switch (TREE_CODE (type
))
18979 case REFERENCE_TYPE
:
18980 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
18981 ensures that the gen_type_die recursion will terminate even if the
18982 type is recursive. Recursive types are possible in Ada. */
18983 /* ??? We could perhaps do this for all types before the switch
18985 TREE_ASM_WRITTEN (type
) = 1;
18987 /* For these types, all that is required is that we output a DIE (or a
18988 set of DIEs) to represent the "basis" type. */
18989 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
18990 DINFO_USAGE_IND_USE
);
18994 /* This code is used for C++ pointer-to-data-member types.
18995 Output a description of the relevant class type. */
18996 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
18997 DINFO_USAGE_IND_USE
);
18999 /* Output a description of the type of the object pointed to. */
19000 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19001 DINFO_USAGE_IND_USE
);
19003 /* Now output a DIE to represent this pointer-to-data-member type
19005 gen_ptr_to_mbr_type_die (type
, context_die
);
19008 case FUNCTION_TYPE
:
19009 /* Force out return type (in case it wasn't forced out already). */
19010 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19011 DINFO_USAGE_DIR_USE
);
19012 gen_subroutine_type_die (type
, context_die
);
19016 /* Force out return type (in case it wasn't forced out already). */
19017 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19018 DINFO_USAGE_DIR_USE
);
19019 gen_subroutine_type_die (type
, context_die
);
19023 gen_array_type_die (type
, context_die
);
19027 gen_array_type_die (type
, context_die
);
19030 case ENUMERAL_TYPE
:
19033 case QUAL_UNION_TYPE
:
19034 gen_tagged_type_die (type
, context_die
, usage
);
19040 case FIXED_POINT_TYPE
:
19043 /* No DIEs needed for fundamental types. */
19048 /* Just use DW_TAG_unspecified_type. */
19050 dw_die_ref type_die
= lookup_type_die (type
);
19051 if (type_die
== NULL
)
19053 tree name
= TYPE_NAME (type
);
19054 if (TREE_CODE (name
) == TYPE_DECL
)
19055 name
= DECL_NAME (name
);
19056 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (), type
);
19057 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
19058 equate_type_number_to_die (type
, type_die
);
19064 gcc_unreachable ();
19067 TREE_ASM_WRITTEN (type
) = 1;
19071 gen_type_die (tree type
, dw_die_ref context_die
)
19073 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
19076 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
19077 things which are local to the given block. */
19080 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19082 int must_output_die
= 0;
19085 /* Ignore blocks that are NULL. */
19086 if (stmt
== NULL_TREE
)
19089 inlined_func
= inlined_function_outer_scope_p (stmt
);
19091 /* If the block is one fragment of a non-contiguous block, do not
19092 process the variables, since they will have been done by the
19093 origin block. Do process subblocks. */
19094 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
19098 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
19099 gen_block_die (sub
, context_die
, depth
+ 1);
19104 /* Determine if we need to output any Dwarf DIEs at all to represent this
19107 /* The outer scopes for inlinings *must* always be represented. We
19108 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
19109 must_output_die
= 1;
19112 /* Determine if this block directly contains any "significant"
19113 local declarations which we will need to output DIEs for. */
19114 if (debug_info_level
> DINFO_LEVEL_TERSE
)
19115 /* We are not in terse mode so *any* local declaration counts
19116 as being a "significant" one. */
19117 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
19118 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
19119 && (TREE_USED (stmt
)
19120 || TREE_ASM_WRITTEN (stmt
)
19121 || BLOCK_ABSTRACT (stmt
)));
19122 else if ((TREE_USED (stmt
)
19123 || TREE_ASM_WRITTEN (stmt
)
19124 || BLOCK_ABSTRACT (stmt
))
19125 && !dwarf2out_ignore_block (stmt
))
19126 must_output_die
= 1;
19129 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
19130 DIE for any block which contains no significant local declarations at
19131 all. Rather, in such cases we just call `decls_for_scope' so that any
19132 needed Dwarf info for any sub-blocks will get properly generated. Note
19133 that in terse mode, our definition of what constitutes a "significant"
19134 local declaration gets restricted to include only inlined function
19135 instances and local (nested) function definitions. */
19136 if (must_output_die
)
19140 /* If STMT block is abstract, that means we have been called
19141 indirectly from dwarf2out_abstract_function.
19142 That function rightfully marks the descendent blocks (of
19143 the abstract function it is dealing with) as being abstract,
19144 precisely to prevent us from emitting any
19145 DW_TAG_inlined_subroutine DIE as a descendent
19146 of an abstract function instance. So in that case, we should
19147 not call gen_inlined_subroutine_die.
19149 Later though, when cgraph asks dwarf2out to emit info
19150 for the concrete instance of the function decl into which
19151 the concrete instance of STMT got inlined, the later will lead
19152 to the generation of a DW_TAG_inlined_subroutine DIE. */
19153 if (! BLOCK_ABSTRACT (stmt
))
19154 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
19157 gen_lexical_block_die (stmt
, context_die
, depth
);
19160 decls_for_scope (stmt
, context_die
, depth
);
19163 /* Process variable DECL (or variable with origin ORIGIN) within
19164 block STMT and add it to CONTEXT_DIE. */
19166 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
19169 tree decl_or_origin
= decl
? decl
: origin
;
19171 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
19172 die
= lookup_decl_die (decl_or_origin
);
19173 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
19174 && TYPE_DECL_IS_STUB (decl_or_origin
))
19175 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
19179 if (die
!= NULL
&& die
->die_parent
== NULL
)
19180 add_child_die (context_die
, die
);
19181 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
19182 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
19183 stmt
, context_die
);
19185 gen_decl_die (decl
, origin
, context_die
);
19188 /* Generate all of the decls declared within a given scope and (recursively)
19189 all of its sub-blocks. */
19192 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
19198 /* Ignore NULL blocks. */
19199 if (stmt
== NULL_TREE
)
19202 /* Output the DIEs to represent all of the data objects and typedefs
19203 declared directly within this block but not within any nested
19204 sub-blocks. Also, nested function and tag DIEs have been
19205 generated with a parent of NULL; fix that up now. */
19206 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
19207 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
19208 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
19209 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
19212 /* If we're at -g1, we're not interested in subblocks. */
19213 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19216 /* Output the DIEs to represent all sub-blocks (and the items declared
19217 therein) of this block. */
19218 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
19220 subblocks
= BLOCK_CHAIN (subblocks
))
19221 gen_block_die (subblocks
, context_die
, depth
+ 1);
19224 /* Is this a typedef we can avoid emitting? */
19227 is_redundant_typedef (const_tree decl
)
19229 if (TYPE_DECL_IS_STUB (decl
))
19232 if (DECL_ARTIFICIAL (decl
)
19233 && DECL_CONTEXT (decl
)
19234 && is_tagged_type (DECL_CONTEXT (decl
))
19235 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
19236 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
19237 /* Also ignore the artificial member typedef for the class name. */
19243 /* Return TRUE if TYPE is a typedef that names a type for linkage
19244 purposes. This kind of typedefs is produced by the C++ FE for
19247 typedef struct {...} foo;
19249 In that case, there is no typedef variant type produced for foo.
19250 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
19254 is_naming_typedef_decl (const_tree decl
)
19256 if (decl
== NULL_TREE
19257 || TREE_CODE (decl
) != TYPE_DECL
19258 || !is_tagged_type (TREE_TYPE (decl
))
19259 || DECL_IS_BUILTIN (decl
)
19260 || is_redundant_typedef (decl
)
19261 /* It looks like Ada produces TYPE_DECLs that are very similar
19262 to C++ naming typedefs but that have different
19263 semantics. Let's be specific to c++ for now. */
19267 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
19268 && TYPE_NAME (TREE_TYPE (decl
)) == decl
19269 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
19270 != TYPE_NAME (TREE_TYPE (decl
))));
19273 /* Returns the DIE for a context. */
19275 static inline dw_die_ref
19276 get_context_die (tree context
)
19280 /* Find die that represents this context. */
19281 if (TYPE_P (context
))
19283 context
= TYPE_MAIN_VARIANT (context
);
19284 return strip_naming_typedef (context
, force_type_die (context
));
19287 return force_decl_die (context
);
19289 return comp_unit_die ();
19292 /* Returns the DIE for decl. A DIE will always be returned. */
19295 force_decl_die (tree decl
)
19297 dw_die_ref decl_die
;
19298 unsigned saved_external_flag
;
19299 tree save_fn
= NULL_TREE
;
19300 decl_die
= lookup_decl_die (decl
);
19303 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
19305 decl_die
= lookup_decl_die (decl
);
19309 switch (TREE_CODE (decl
))
19311 case FUNCTION_DECL
:
19312 /* Clear current_function_decl, so that gen_subprogram_die thinks
19313 that this is a declaration. At this point, we just want to force
19314 declaration die. */
19315 save_fn
= current_function_decl
;
19316 current_function_decl
= NULL_TREE
;
19317 gen_subprogram_die (decl
, context_die
);
19318 current_function_decl
= save_fn
;
19322 /* Set external flag to force declaration die. Restore it after
19323 gen_decl_die() call. */
19324 saved_external_flag
= DECL_EXTERNAL (decl
);
19325 DECL_EXTERNAL (decl
) = 1;
19326 gen_decl_die (decl
, NULL
, context_die
);
19327 DECL_EXTERNAL (decl
) = saved_external_flag
;
19330 case NAMESPACE_DECL
:
19331 if (dwarf_version
>= 3 || !dwarf_strict
)
19332 dwarf2out_decl (decl
);
19334 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
19335 decl_die
= comp_unit_die ();
19338 case TRANSLATION_UNIT_DECL
:
19339 decl_die
= comp_unit_die ();
19343 gcc_unreachable ();
19346 /* We should be able to find the DIE now. */
19348 decl_die
= lookup_decl_die (decl
);
19349 gcc_assert (decl_die
);
19355 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
19356 always returned. */
19359 force_type_die (tree type
)
19361 dw_die_ref type_die
;
19363 type_die
= lookup_type_die (type
);
19366 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
19368 type_die
= modified_type_die (type
, TYPE_READONLY (type
),
19369 TYPE_VOLATILE (type
), context_die
);
19370 gcc_assert (type_die
);
19375 /* Force out any required namespaces to be able to output DECL,
19376 and return the new context_die for it, if it's changed. */
19379 setup_namespace_context (tree thing
, dw_die_ref context_die
)
19381 tree context
= (DECL_P (thing
)
19382 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
19383 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
19384 /* Force out the namespace. */
19385 context_die
= force_decl_die (context
);
19387 return context_die
;
19390 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
19391 type) within its namespace, if appropriate.
19393 For compatibility with older debuggers, namespace DIEs only contain
19394 declarations; all definitions are emitted at CU scope. */
19397 declare_in_namespace (tree thing
, dw_die_ref context_die
)
19399 dw_die_ref ns_context
;
19401 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19402 return context_die
;
19404 /* If this decl is from an inlined function, then don't try to emit it in its
19405 namespace, as we will get confused. It would have already been emitted
19406 when the abstract instance of the inline function was emitted anyways. */
19407 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
19408 return context_die
;
19410 ns_context
= setup_namespace_context (thing
, context_die
);
19412 if (ns_context
!= context_die
)
19416 if (DECL_P (thing
))
19417 gen_decl_die (thing
, NULL
, ns_context
);
19419 gen_type_die (thing
, ns_context
);
19421 return context_die
;
19424 /* Generate a DIE for a namespace or namespace alias. */
19427 gen_namespace_die (tree decl
, dw_die_ref context_die
)
19429 dw_die_ref namespace_die
;
19431 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
19432 they are an alias of. */
19433 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
19435 /* Output a real namespace or module. */
19436 context_die
= setup_namespace_context (decl
, comp_unit_die ());
19437 namespace_die
= new_die (is_fortran ()
19438 ? DW_TAG_module
: DW_TAG_namespace
,
19439 context_die
, decl
);
19440 /* For Fortran modules defined in different CU don't add src coords. */
19441 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
19443 const char *name
= dwarf2_name (decl
, 0);
19445 add_name_attribute (namespace_die
, name
);
19448 add_name_and_src_coords_attributes (namespace_die
, decl
);
19449 if (DECL_EXTERNAL (decl
))
19450 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
19451 equate_decl_number_to_die (decl
, namespace_die
);
19455 /* Output a namespace alias. */
19457 /* Force out the namespace we are an alias of, if necessary. */
19458 dw_die_ref origin_die
19459 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
19461 if (DECL_FILE_SCOPE_P (decl
)
19462 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
19463 context_die
= setup_namespace_context (decl
, comp_unit_die ());
19464 /* Now create the namespace alias DIE. */
19465 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
19466 add_name_and_src_coords_attributes (namespace_die
, decl
);
19467 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
19468 equate_decl_number_to_die (decl
, namespace_die
);
19472 /* Generate Dwarf debug information for a decl described by DECL.
19473 The return value is currently only meaningful for PARM_DECLs,
19474 for all other decls it returns NULL. */
19477 gen_decl_die (tree decl
, tree origin
, dw_die_ref context_die
)
19479 tree decl_or_origin
= decl
? decl
: origin
;
19480 tree class_origin
= NULL
, ultimate_origin
;
19482 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
19485 switch (TREE_CODE (decl_or_origin
))
19491 if (!is_fortran () && !is_ada ())
19493 /* The individual enumerators of an enum type get output when we output
19494 the Dwarf representation of the relevant enum type itself. */
19498 /* Emit its type. */
19499 gen_type_die (TREE_TYPE (decl
), context_die
);
19501 /* And its containing namespace. */
19502 context_die
= declare_in_namespace (decl
, context_die
);
19504 gen_const_die (decl
, context_die
);
19507 case FUNCTION_DECL
:
19508 /* Don't output any DIEs to represent mere function declarations,
19509 unless they are class members or explicit block externs. */
19510 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
19511 && DECL_FILE_SCOPE_P (decl_or_origin
)
19512 && (current_function_decl
== NULL_TREE
19513 || DECL_ARTIFICIAL (decl_or_origin
)))
19518 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
19519 on local redeclarations of global functions. That seems broken. */
19520 if (current_function_decl
!= decl
)
19521 /* This is only a declaration. */;
19524 /* If we're emitting a clone, emit info for the abstract instance. */
19525 if (origin
|| DECL_ORIGIN (decl
) != decl
)
19526 dwarf2out_abstract_function (origin
19527 ? DECL_ORIGIN (origin
)
19528 : DECL_ABSTRACT_ORIGIN (decl
));
19530 /* If we're emitting an out-of-line copy of an inline function,
19531 emit info for the abstract instance and set up to refer to it. */
19532 else if (cgraph_function_possibly_inlined_p (decl
)
19533 && ! DECL_ABSTRACT (decl
)
19534 && ! class_or_namespace_scope_p (context_die
)
19535 /* dwarf2out_abstract_function won't emit a die if this is just
19536 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
19537 that case, because that works only if we have a die. */
19538 && DECL_INITIAL (decl
) != NULL_TREE
)
19540 dwarf2out_abstract_function (decl
);
19541 set_decl_origin_self (decl
);
19544 /* Otherwise we're emitting the primary DIE for this decl. */
19545 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
19547 /* Before we describe the FUNCTION_DECL itself, make sure that we
19548 have its containing type. */
19550 origin
= decl_class_context (decl
);
19551 if (origin
!= NULL_TREE
)
19552 gen_type_die (origin
, context_die
);
19554 /* And its return type. */
19555 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
19557 /* And its virtual context. */
19558 if (DECL_VINDEX (decl
) != NULL_TREE
)
19559 gen_type_die (DECL_CONTEXT (decl
), context_die
);
19561 /* Make sure we have a member DIE for decl. */
19562 if (origin
!= NULL_TREE
)
19563 gen_type_die_for_member (origin
, decl
, context_die
);
19565 /* And its containing namespace. */
19566 context_die
= declare_in_namespace (decl
, context_die
);
19569 /* Now output a DIE to represent the function itself. */
19571 gen_subprogram_die (decl
, context_die
);
19575 /* If we are in terse mode, don't generate any DIEs to represent any
19576 actual typedefs. */
19577 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19580 /* In the special case of a TYPE_DECL node representing the declaration
19581 of some type tag, if the given TYPE_DECL is marked as having been
19582 instantiated from some other (original) TYPE_DECL node (e.g. one which
19583 was generated within the original definition of an inline function) we
19584 used to generate a special (abbreviated) DW_TAG_structure_type,
19585 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
19586 should be actually referencing those DIEs, as variable DIEs with that
19587 type would be emitted already in the abstract origin, so it was always
19588 removed during unused type prunning. Don't add anything in this
19590 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
19593 if (is_redundant_typedef (decl
))
19594 gen_type_die (TREE_TYPE (decl
), context_die
);
19596 /* Output a DIE to represent the typedef itself. */
19597 gen_typedef_die (decl
, context_die
);
19601 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
19602 gen_label_die (decl
, context_die
);
19607 /* If we are in terse mode, don't generate any DIEs to represent any
19608 variable declarations or definitions. */
19609 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19612 /* Output any DIEs that are needed to specify the type of this data
19614 if (decl_by_reference_p (decl_or_origin
))
19615 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
19617 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
19619 /* And its containing type. */
19620 class_origin
= decl_class_context (decl_or_origin
);
19621 if (class_origin
!= NULL_TREE
)
19622 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
19624 /* And its containing namespace. */
19625 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
19627 /* Now output the DIE to represent the data object itself. This gets
19628 complicated because of the possibility that the VAR_DECL really
19629 represents an inlined instance of a formal parameter for an inline
19631 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
19632 if (ultimate_origin
!= NULL_TREE
19633 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
19634 gen_formal_parameter_die (decl
, origin
,
19635 true /* Emit name attribute. */,
19638 gen_variable_die (decl
, origin
, context_die
);
19642 /* Ignore the nameless fields that are used to skip bits but handle C++
19643 anonymous unions and structs. */
19644 if (DECL_NAME (decl
) != NULL_TREE
19645 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
19646 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
19648 gen_type_die (member_declared_type (decl
), context_die
);
19649 gen_field_die (decl
, context_die
);
19654 if (DECL_BY_REFERENCE (decl_or_origin
))
19655 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
19657 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
19658 return gen_formal_parameter_die (decl
, origin
,
19659 true /* Emit name attribute. */,
19662 case NAMESPACE_DECL
:
19663 case IMPORTED_DECL
:
19664 if (dwarf_version
>= 3 || !dwarf_strict
)
19665 gen_namespace_die (decl
, context_die
);
19669 /* Probably some frontend-internal decl. Assume we don't care. */
19670 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
19677 /* Output debug information for global decl DECL. Called from toplev.c after
19678 compilation proper has finished. */
19681 dwarf2out_global_decl (tree decl
)
19683 /* Output DWARF2 information for file-scope tentative data object
19684 declarations, file-scope (extern) function declarations (which
19685 had no corresponding body) and file-scope tagged type declarations
19686 and definitions which have not yet been forced out. */
19687 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
19688 dwarf2out_decl (decl
);
19691 /* Output debug information for type decl DECL. Called from toplev.c
19692 and from language front ends (to record built-in types). */
19694 dwarf2out_type_decl (tree decl
, int local
)
19697 dwarf2out_decl (decl
);
19700 /* Output debug information for imported module or decl DECL.
19701 NAME is non-NULL name in the lexical block if the decl has been renamed.
19702 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
19703 that DECL belongs to.
19704 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
19706 dwarf2out_imported_module_or_decl_1 (tree decl
,
19708 tree lexical_block
,
19709 dw_die_ref lexical_block_die
)
19711 expanded_location xloc
;
19712 dw_die_ref imported_die
= NULL
;
19713 dw_die_ref at_import_die
;
19715 if (TREE_CODE (decl
) == IMPORTED_DECL
)
19717 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
19718 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
19722 xloc
= expand_location (input_location
);
19724 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
19726 at_import_die
= force_type_die (TREE_TYPE (decl
));
19727 /* For namespace N { typedef void T; } using N::T; base_type_die
19728 returns NULL, but DW_TAG_imported_declaration requires
19729 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
19730 if (!at_import_die
)
19732 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
19733 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
19734 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
19735 gcc_assert (at_import_die
);
19740 at_import_die
= lookup_decl_die (decl
);
19741 if (!at_import_die
)
19743 /* If we're trying to avoid duplicate debug info, we may not have
19744 emitted the member decl for this field. Emit it now. */
19745 if (TREE_CODE (decl
) == FIELD_DECL
)
19747 tree type
= DECL_CONTEXT (decl
);
19749 if (TYPE_CONTEXT (type
)
19750 && TYPE_P (TYPE_CONTEXT (type
))
19751 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
19752 DINFO_USAGE_DIR_USE
))
19754 gen_type_die_for_member (type
, decl
,
19755 get_context_die (TYPE_CONTEXT (type
)));
19757 at_import_die
= force_decl_die (decl
);
19761 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
19763 if (dwarf_version
>= 3 || !dwarf_strict
)
19764 imported_die
= new_die (DW_TAG_imported_module
,
19771 imported_die
= new_die (DW_TAG_imported_declaration
,
19775 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
19776 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
19778 add_AT_string (imported_die
, DW_AT_name
,
19779 IDENTIFIER_POINTER (name
));
19780 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
19783 /* Output debug information for imported module or decl DECL.
19784 NAME is non-NULL name in context if the decl has been renamed.
19785 CHILD is true if decl is one of the renamed decls as part of
19786 importing whole module. */
19789 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
19792 /* dw_die_ref at_import_die; */
19793 dw_die_ref scope_die
;
19795 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19800 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
19801 We need decl DIE for reference and scope die. First, get DIE for the decl
19804 /* Get the scope die for decl context. Use comp_unit_die for global module
19805 or decl. If die is not found for non globals, force new die. */
19807 && TYPE_P (context
)
19808 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
19811 if (!(dwarf_version
>= 3 || !dwarf_strict
))
19814 scope_die
= get_context_die (context
);
19818 gcc_assert (scope_die
->die_child
);
19819 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
19820 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
19821 scope_die
= scope_die
->die_child
;
19824 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
19825 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
19829 /* Write the debugging output for DECL. */
19832 dwarf2out_decl (tree decl
)
19834 dw_die_ref context_die
= comp_unit_die ();
19836 switch (TREE_CODE (decl
))
19841 case FUNCTION_DECL
:
19842 /* What we would really like to do here is to filter out all mere
19843 file-scope declarations of file-scope functions which are never
19844 referenced later within this translation unit (and keep all of ones
19845 that *are* referenced later on) but we aren't clairvoyant, so we have
19846 no idea which functions will be referenced in the future (i.e. later
19847 on within the current translation unit). So here we just ignore all
19848 file-scope function declarations which are not also definitions. If
19849 and when the debugger needs to know something about these functions,
19850 it will have to hunt around and find the DWARF information associated
19851 with the definition of the function.
19853 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
19854 nodes represent definitions and which ones represent mere
19855 declarations. We have to check DECL_INITIAL instead. That's because
19856 the C front-end supports some weird semantics for "extern inline"
19857 function definitions. These can get inlined within the current
19858 translation unit (and thus, we need to generate Dwarf info for their
19859 abstract instances so that the Dwarf info for the concrete inlined
19860 instances can have something to refer to) but the compiler never
19861 generates any out-of-lines instances of such things (despite the fact
19862 that they *are* definitions).
19864 The important point is that the C front-end marks these "extern
19865 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
19866 them anyway. Note that the C++ front-end also plays some similar games
19867 for inline function definitions appearing within include files which
19868 also contain `#pragma interface' pragmas. */
19869 if (DECL_INITIAL (decl
) == NULL_TREE
)
19872 /* If we're a nested function, initially use a parent of NULL; if we're
19873 a plain function, this will be fixed up in decls_for_scope. If
19874 we're a method, it will be ignored, since we already have a DIE. */
19875 if (decl_function_context (decl
)
19876 /* But if we're in terse mode, we don't care about scope. */
19877 && debug_info_level
> DINFO_LEVEL_TERSE
)
19878 context_die
= NULL
;
19882 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
19883 declaration and if the declaration was never even referenced from
19884 within this entire compilation unit. We suppress these DIEs in
19885 order to save space in the .debug section (by eliminating entries
19886 which are probably useless). Note that we must not suppress
19887 block-local extern declarations (whether used or not) because that
19888 would screw-up the debugger's name lookup mechanism and cause it to
19889 miss things which really ought to be in scope at a given point. */
19890 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
19893 /* For local statics lookup proper context die. */
19894 if (TREE_STATIC (decl
) && decl_function_context (decl
))
19895 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
19897 /* If we are in terse mode, don't generate any DIEs to represent any
19898 variable declarations or definitions. */
19899 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19904 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19906 if (!is_fortran () && !is_ada ())
19908 if (TREE_STATIC (decl
) && decl_function_context (decl
))
19909 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
19912 case NAMESPACE_DECL
:
19913 case IMPORTED_DECL
:
19914 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19916 if (lookup_decl_die (decl
) != NULL
)
19921 /* Don't emit stubs for types unless they are needed by other DIEs. */
19922 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
19925 /* Don't bother trying to generate any DIEs to represent any of the
19926 normal built-in types for the language we are compiling. */
19927 if (DECL_IS_BUILTIN (decl
))
19930 /* If we are in terse mode, don't generate any DIEs for types. */
19931 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
19934 /* If we're a function-scope tag, initially use a parent of NULL;
19935 this will be fixed up in decls_for_scope. */
19936 if (decl_function_context (decl
))
19937 context_die
= NULL
;
19945 gen_decl_die (decl
, NULL
, context_die
);
19948 /* Write the debugging output for DECL. */
19951 dwarf2out_function_decl (tree decl
)
19953 dwarf2out_decl (decl
);
19954 call_arg_locations
= NULL
;
19955 call_arg_loc_last
= NULL
;
19956 call_site_count
= -1;
19957 tail_call_site_count
= -1;
19958 VEC_free (dw_die_ref
, heap
, block_map
);
19959 htab_empty (decl_loc_table
);
19960 htab_empty (cached_dw_loc_list_table
);
19963 /* Output a marker (i.e. a label) for the beginning of the generated code for
19964 a lexical block. */
19967 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
19968 unsigned int blocknum
)
19970 switch_to_section (current_function_section ());
19971 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
19974 /* Output a marker (i.e. a label) for the end of the generated code for a
19978 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
19980 switch_to_section (current_function_section ());
19981 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
19984 /* Returns nonzero if it is appropriate not to emit any debugging
19985 information for BLOCK, because it doesn't contain any instructions.
19987 Don't allow this for blocks with nested functions or local classes
19988 as we would end up with orphans, and in the presence of scheduling
19989 we may end up calling them anyway. */
19992 dwarf2out_ignore_block (const_tree block
)
19997 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
19998 if (TREE_CODE (decl
) == FUNCTION_DECL
19999 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
20001 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
20003 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
20004 if (TREE_CODE (decl
) == FUNCTION_DECL
20005 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
20012 /* Hash table routines for file_hash. */
20015 file_table_eq (const void *p1_p
, const void *p2_p
)
20017 const struct dwarf_file_data
*const p1
=
20018 (const struct dwarf_file_data
*) p1_p
;
20019 const char *const p2
= (const char *) p2_p
;
20020 return filename_cmp (p1
->filename
, p2
) == 0;
20024 file_table_hash (const void *p_p
)
20026 const struct dwarf_file_data
*const p
= (const struct dwarf_file_data
*) p_p
;
20027 return htab_hash_string (p
->filename
);
20030 /* Lookup FILE_NAME (in the list of filenames that we know about here in
20031 dwarf2out.c) and return its "index". The index of each (known) filename is
20032 just a unique number which is associated with only that one filename. We
20033 need such numbers for the sake of generating labels (in the .debug_sfnames
20034 section) and references to those files numbers (in the .debug_srcinfo
20035 and.debug_macinfo sections). If the filename given as an argument is not
20036 found in our current list, add it to the list and assign it the next
20037 available unique index number. In order to speed up searches, we remember
20038 the index of the filename was looked up last. This handles the majority of
20041 static struct dwarf_file_data
*
20042 lookup_filename (const char *file_name
)
20045 struct dwarf_file_data
* created
;
20047 /* Check to see if the file name that was searched on the previous
20048 call matches this file name. If so, return the index. */
20049 if (file_table_last_lookup
20050 && (file_name
== file_table_last_lookup
->filename
20051 || filename_cmp (file_table_last_lookup
->filename
, file_name
) == 0))
20052 return file_table_last_lookup
;
20054 /* Didn't match the previous lookup, search the table. */
20055 slot
= htab_find_slot_with_hash (file_table
, file_name
,
20056 htab_hash_string (file_name
), INSERT
);
20058 return (struct dwarf_file_data
*) *slot
;
20060 created
= ggc_alloc_dwarf_file_data ();
20061 created
->filename
= file_name
;
20062 created
->emitted_number
= 0;
20067 /* If the assembler will construct the file table, then translate the compiler
20068 internal file table number into the assembler file table number, and emit
20069 a .file directive if we haven't already emitted one yet. The file table
20070 numbers are different because we prune debug info for unused variables and
20071 types, which may include filenames. */
20074 maybe_emit_file (struct dwarf_file_data
* fd
)
20076 if (! fd
->emitted_number
)
20078 if (last_emitted_file
)
20079 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
20081 fd
->emitted_number
= 1;
20082 last_emitted_file
= fd
;
20084 if (DWARF2_ASM_LINE_DEBUG_INFO
)
20086 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
20087 output_quoted_string (asm_out_file
,
20088 remap_debug_filename (fd
->filename
));
20089 fputc ('\n', asm_out_file
);
20093 return fd
->emitted_number
;
20096 /* Schedule generation of a DW_AT_const_value attribute to DIE.
20097 That generation should happen after function debug info has been
20098 generated. The value of the attribute is the constant value of ARG. */
20101 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
20103 die_arg_entry entry
;
20108 if (!tmpl_value_parm_die_table
)
20109 tmpl_value_parm_die_table
20110 = VEC_alloc (die_arg_entry
, gc
, 32);
20114 VEC_safe_push (die_arg_entry
, gc
,
20115 tmpl_value_parm_die_table
,
20119 /* Return TRUE if T is an instance of generic type, FALSE
20123 generic_type_p (tree t
)
20125 if (t
== NULL_TREE
|| !TYPE_P (t
))
20127 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
20130 /* Schedule the generation of the generic parameter dies for the
20131 instance of generic type T. The proper generation itself is later
20132 done by gen_scheduled_generic_parms_dies. */
20135 schedule_generic_params_dies_gen (tree t
)
20137 if (!generic_type_p (t
))
20140 if (generic_type_instances
== NULL
)
20141 generic_type_instances
= VEC_alloc (tree
, gc
, 256);
20143 VEC_safe_push (tree
, gc
, generic_type_instances
, t
);
20146 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
20147 by append_entry_to_tmpl_value_parm_die_table. This function must
20148 be called after function DIEs have been generated. */
20151 gen_remaining_tmpl_value_param_die_attribute (void)
20153 if (tmpl_value_parm_die_table
)
20158 FOR_EACH_VEC_ELT (die_arg_entry
, tmpl_value_parm_die_table
, i
, e
)
20159 tree_add_const_value_attribute (e
->die
, e
->arg
);
20163 /* Generate generic parameters DIEs for instances of generic types
20164 that have been previously scheduled by
20165 schedule_generic_params_dies_gen. This function must be called
20166 after all the types of the CU have been laid out. */
20169 gen_scheduled_generic_parms_dies (void)
20174 if (generic_type_instances
== NULL
)
20177 FOR_EACH_VEC_ELT (tree
, generic_type_instances
, i
, t
)
20178 gen_generic_params_dies (t
);
20182 /* Replace DW_AT_name for the decl with name. */
20185 dwarf2out_set_name (tree decl
, tree name
)
20191 die
= TYPE_SYMTAB_DIE (decl
);
20195 dname
= dwarf2_name (name
, 0);
20199 attr
= get_AT (die
, DW_AT_name
);
20202 struct indirect_string_node
*node
;
20204 node
= find_AT_string (dname
);
20205 /* replace the string. */
20206 attr
->dw_attr_val
.v
.val_str
= node
;
20210 add_name_attribute (die
, dname
);
20213 /* Called by the final INSN scan whenever we see a var location. We
20214 use it to drop labels in the right places, and throw the location in
20215 our lookup table. */
20218 dwarf2out_var_location (rtx loc_note
)
20220 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
20221 struct var_loc_node
*newloc
;
20222 rtx next_real
, next_note
;
20223 static const char *last_label
;
20224 static const char *last_postcall_label
;
20225 static bool last_in_cold_section_p
;
20226 static rtx expected_next_loc_note
;
20230 if (!NOTE_P (loc_note
))
20232 if (CALL_P (loc_note
))
20235 if (SIBLING_CALL_P (loc_note
))
20236 tail_call_site_count
++;
20241 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
20242 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
20245 /* Optimize processing a large consecutive sequence of location
20246 notes so we don't spend too much time in next_real_insn. If the
20247 next insn is another location note, remember the next_real_insn
20248 calculation for next time. */
20249 next_real
= cached_next_real_insn
;
20252 if (expected_next_loc_note
!= loc_note
)
20253 next_real
= NULL_RTX
;
20256 next_note
= NEXT_INSN (loc_note
);
20258 || INSN_DELETED_P (next_note
)
20259 || GET_CODE (next_note
) != NOTE
20260 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
20261 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
20262 next_note
= NULL_RTX
;
20265 next_real
= next_real_insn (loc_note
);
20269 expected_next_loc_note
= next_note
;
20270 cached_next_real_insn
= next_real
;
20273 cached_next_real_insn
= NULL_RTX
;
20275 /* If there are no instructions which would be affected by this note,
20276 don't do anything. */
20278 && next_real
== NULL_RTX
20279 && !NOTE_DURING_CALL_P (loc_note
))
20282 if (next_real
== NULL_RTX
)
20283 next_real
= get_last_insn ();
20285 /* If there were any real insns between note we processed last time
20286 and this note (or if it is the first note), clear
20287 last_{,postcall_}label so that they are not reused this time. */
20288 if (last_var_location_insn
== NULL_RTX
20289 || last_var_location_insn
!= next_real
20290 || last_in_cold_section_p
!= in_cold_section_p
)
20293 last_postcall_label
= NULL
;
20298 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
20299 newloc
= add_var_loc_to_decl (decl
, loc_note
,
20300 NOTE_DURING_CALL_P (loc_note
)
20301 ? last_postcall_label
: last_label
);
20302 if (newloc
== NULL
)
20311 /* If there were no real insns between note we processed last time
20312 and this note, use the label we emitted last time. Otherwise
20313 create a new label and emit it. */
20314 if (last_label
== NULL
)
20316 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
20317 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
20319 last_label
= ggc_strdup (loclabel
);
20324 struct call_arg_loc_node
*ca_loc
20325 = ggc_alloc_cleared_call_arg_loc_node ();
20326 rtx prev
= prev_real_insn (loc_note
), x
;
20327 ca_loc
->call_arg_loc_note
= loc_note
;
20328 ca_loc
->next
= NULL
;
20329 ca_loc
->label
= last_label
;
20332 || (NONJUMP_INSN_P (prev
)
20333 && GET_CODE (PATTERN (prev
)) == SEQUENCE
20334 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
20335 if (!CALL_P (prev
))
20336 prev
= XVECEXP (PATTERN (prev
), 0, 0);
20337 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
20338 x
= PATTERN (prev
);
20339 if (GET_CODE (x
) == PARALLEL
)
20340 x
= XVECEXP (x
, 0, 0);
20341 if (GET_CODE (x
) == SET
)
20343 if (GET_CODE (x
) == CALL
&& MEM_P (XEXP (x
, 0)))
20345 x
= XEXP (XEXP (x
, 0), 0);
20346 if (GET_CODE (x
) == SYMBOL_REF
20347 && SYMBOL_REF_DECL (x
)
20348 && TREE_CODE (SYMBOL_REF_DECL (x
)) == FUNCTION_DECL
)
20349 ca_loc
->symbol_ref
= x
;
20351 ca_loc
->block
= insn_scope (prev
);
20352 if (call_arg_locations
)
20353 call_arg_loc_last
->next
= ca_loc
;
20355 call_arg_locations
= ca_loc
;
20356 call_arg_loc_last
= ca_loc
;
20358 else if (!NOTE_DURING_CALL_P (loc_note
))
20359 newloc
->label
= last_label
;
20362 if (!last_postcall_label
)
20364 sprintf (loclabel
, "%s-1", last_label
);
20365 last_postcall_label
= ggc_strdup (loclabel
);
20367 newloc
->label
= last_postcall_label
;
20370 last_var_location_insn
= next_real
;
20371 last_in_cold_section_p
= in_cold_section_p
;
20374 /* Note in one location list that text section has changed. */
20377 var_location_switch_text_section_1 (void **slot
, void *data ATTRIBUTE_UNUSED
)
20379 var_loc_list
*list
= (var_loc_list
*) *slot
;
20381 list
->last_before_switch
20382 = list
->last
->next
? list
->last
->next
: list
->last
;
20386 /* Note in all location lists that text section has changed. */
20389 var_location_switch_text_section (void)
20391 if (decl_loc_table
== NULL
)
20394 htab_traverse (decl_loc_table
, var_location_switch_text_section_1
, NULL
);
20397 /* Create a new line number table. */
20399 static dw_line_info_table
*
20400 new_line_info_table (void)
20402 dw_line_info_table
*table
;
20404 table
= ggc_alloc_cleared_dw_line_info_table_struct ();
20405 table
->file_num
= 1;
20406 table
->line_num
= 1;
20407 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
20412 /* Lookup the "current" table into which we emit line info, so
20413 that we don't have to do it for every source line. */
20416 set_cur_line_info_table (section
*sec
)
20418 dw_line_info_table
*table
;
20420 if (sec
== text_section
)
20421 table
= text_section_line_info
;
20422 else if (sec
== cold_text_section
)
20424 table
= cold_text_section_line_info
;
20427 cold_text_section_line_info
= table
= new_line_info_table ();
20428 table
->end_label
= cold_end_label
;
20433 const char *end_label
;
20435 if (flag_reorder_blocks_and_partition
)
20437 if (in_cold_section_p
)
20438 end_label
= crtl
->subsections
.cold_section_end_label
;
20440 end_label
= crtl
->subsections
.hot_section_end_label
;
20444 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
20445 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
20446 current_function_funcdef_no
);
20447 end_label
= ggc_strdup (label
);
20450 table
= new_line_info_table ();
20451 table
->end_label
= end_label
;
20453 VEC_safe_push (dw_line_info_table_p
, gc
, separate_line_info
, table
);
20456 if (DWARF2_ASM_LINE_DEBUG_INFO
)
20457 table
->is_stmt
= (cur_line_info_table
20458 ? cur_line_info_table
->is_stmt
20459 : DWARF_LINE_DEFAULT_IS_STMT_START
);
20460 cur_line_info_table
= table
;
20464 /* We need to reset the locations at the beginning of each
20465 function. We can't do this in the end_function hook, because the
20466 declarations that use the locations won't have been output when
20467 that hook is called. Also compute have_multiple_function_sections here. */
20470 dwarf2out_begin_function (tree fun
)
20472 section
*sec
= function_section (fun
);
20474 if (sec
!= text_section
)
20475 have_multiple_function_sections
= true;
20477 if (flag_reorder_blocks_and_partition
&& !cold_text_section
)
20479 gcc_assert (current_function_decl
== fun
);
20480 cold_text_section
= unlikely_text_section ();
20481 switch_to_section (cold_text_section
);
20482 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
20483 switch_to_section (sec
);
20486 dwarf2out_note_section_used ();
20487 call_site_count
= 0;
20488 tail_call_site_count
= 0;
20490 set_cur_line_info_table (sec
);
20493 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
20496 push_dw_line_info_entry (dw_line_info_table
*table
,
20497 enum dw_line_info_opcode opcode
, unsigned int val
)
20499 dw_line_info_entry e
;
20502 VEC_safe_push (dw_line_info_entry
, gc
, table
->entries
, &e
);
20505 /* Output a label to mark the beginning of a source code line entry
20506 and record information relating to this source line, in
20507 'line_info_table' for later output of the .debug_line section. */
20508 /* ??? The discriminator parameter ought to be unsigned. */
20511 dwarf2out_source_line (unsigned int line
, const char *filename
,
20512 int discriminator
, bool is_stmt
)
20514 unsigned int file_num
;
20515 dw_line_info_table
*table
;
20517 if (debug_info_level
< DINFO_LEVEL_NORMAL
|| line
== 0)
20520 /* The discriminator column was added in dwarf4. Simplify the below
20521 by simply removing it if we're not supposed to output it. */
20522 if (dwarf_version
< 4 && dwarf_strict
)
20525 table
= cur_line_info_table
;
20526 file_num
= maybe_emit_file (lookup_filename (filename
));
20528 /* ??? TODO: Elide duplicate line number entries. Traditionally,
20529 the debugger has used the second (possibly duplicate) line number
20530 at the beginning of the function to mark the end of the prologue.
20531 We could eliminate any other duplicates within the function. For
20532 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
20533 that second line number entry. */
20534 /* Recall that this end-of-prologue indication is *not* the same thing
20535 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
20536 to which the hook corresponds, follows the last insn that was
20537 emitted by gen_prologue. What we need is to preceed the first insn
20538 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
20539 insn that corresponds to something the user wrote. These may be
20540 very different locations once scheduling is enabled. */
20542 if (0 && file_num
== table
->file_num
20543 && line
== table
->line_num
20544 && discriminator
== table
->discrim_num
20545 && is_stmt
== table
->is_stmt
)
20548 switch_to_section (current_function_section ());
20550 /* If requested, emit something human-readable. */
20551 if (flag_debug_asm
)
20552 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
, filename
, line
);
20554 if (DWARF2_ASM_LINE_DEBUG_INFO
)
20556 /* Emit the .loc directive understood by GNU as. */
20557 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
20558 file_num, line, is_stmt, discriminator */
20559 fputs ("\t.loc ", asm_out_file
);
20560 fprint_ul (asm_out_file
, file_num
);
20561 putc (' ', asm_out_file
);
20562 fprint_ul (asm_out_file
, line
);
20563 putc (' ', asm_out_file
);
20564 putc ('0', asm_out_file
);
20566 if (is_stmt
!= table
->is_stmt
)
20568 fputs (" is_stmt ", asm_out_file
);
20569 putc (is_stmt
? '1' : '0', asm_out_file
);
20571 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
20573 gcc_assert (discriminator
> 0);
20574 fputs (" discriminator ", asm_out_file
);
20575 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
20577 putc ('\n', asm_out_file
);
20581 unsigned int label_num
= ++line_info_label_num
;
20583 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
20585 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
20586 if (file_num
!= table
->file_num
)
20587 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
20588 if (discriminator
!= table
->discrim_num
)
20589 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
20590 if (is_stmt
!= table
->is_stmt
)
20591 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
20592 push_dw_line_info_entry (table
, LI_set_line
, line
);
20595 table
->file_num
= file_num
;
20596 table
->line_num
= line
;
20597 table
->discrim_num
= discriminator
;
20598 table
->is_stmt
= is_stmt
;
20599 table
->in_use
= true;
20602 /* Record the beginning of a new source file. */
20605 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
20607 if (flag_eliminate_dwarf2_dups
&& ! use_debug_types
)
20609 /* Record the beginning of the file for break_out_includes. */
20610 dw_die_ref bincl_die
;
20612 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die (), NULL
);
20613 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
20616 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
20619 e
.code
= DW_MACINFO_start_file
;
20621 e
.info
= ggc_strdup (filename
);
20622 VEC_safe_push (macinfo_entry
, gc
, macinfo_table
, &e
);
20626 /* Record the end of a source file. */
20629 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
20631 if (flag_eliminate_dwarf2_dups
&& ! use_debug_types
)
20632 /* Record the end of the file for break_out_includes. */
20633 new_die (DW_TAG_GNU_EINCL
, comp_unit_die (), NULL
);
20635 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
20638 e
.code
= DW_MACINFO_end_file
;
20641 VEC_safe_push (macinfo_entry
, gc
, macinfo_table
, &e
);
20645 /* Called from debug_define in toplev.c. The `buffer' parameter contains
20646 the tail part of the directive line, i.e. the part which is past the
20647 initial whitespace, #, whitespace, directive-name, whitespace part. */
20650 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
20651 const char *buffer ATTRIBUTE_UNUSED
)
20653 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
20656 /* Insert a dummy first entry to be able to optimize the whole
20657 predefined macro block using DW_MACRO_GNU_transparent_include. */
20658 if (VEC_empty (macinfo_entry
, macinfo_table
) && lineno
== 0)
20663 VEC_safe_push (macinfo_entry
, gc
, macinfo_table
, &e
);
20665 e
.code
= DW_MACINFO_define
;
20667 e
.info
= ggc_strdup (buffer
);
20668 VEC_safe_push (macinfo_entry
, gc
, macinfo_table
, &e
);
20672 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
20673 the tail part of the directive line, i.e. the part which is past the
20674 initial whitespace, #, whitespace, directive-name, whitespace part. */
20677 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
20678 const char *buffer ATTRIBUTE_UNUSED
)
20680 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
20683 /* Insert a dummy first entry to be able to optimize the whole
20684 predefined macro block using DW_MACRO_GNU_transparent_include. */
20685 if (VEC_empty (macinfo_entry
, macinfo_table
) && lineno
== 0)
20690 VEC_safe_push (macinfo_entry
, gc
, macinfo_table
, &e
);
20692 e
.code
= DW_MACINFO_undef
;
20694 e
.info
= ggc_strdup (buffer
);
20695 VEC_safe_push (macinfo_entry
, gc
, macinfo_table
, &e
);
20699 /* Routines to manipulate hash table of CUs. */
20702 htab_macinfo_hash (const void *of
)
20704 const macinfo_entry
*const entry
=
20705 (const macinfo_entry
*) of
;
20707 return htab_hash_string (entry
->info
);
20711 htab_macinfo_eq (const void *of1
, const void *of2
)
20713 const macinfo_entry
*const entry1
= (const macinfo_entry
*) of1
;
20714 const macinfo_entry
*const entry2
= (const macinfo_entry
*) of2
;
20716 return !strcmp (entry1
->info
, entry2
->info
);
20719 /* Output a single .debug_macinfo entry. */
20722 output_macinfo_op (macinfo_entry
*ref
)
20726 struct indirect_string_node
*node
;
20727 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
20728 struct dwarf_file_data
*fd
;
20732 case DW_MACINFO_start_file
:
20733 fd
= lookup_filename (ref
->info
);
20734 file_num
= maybe_emit_file (fd
);
20735 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
20736 dw2_asm_output_data_uleb128 (ref
->lineno
,
20737 "Included from line number %lu",
20738 (unsigned long) ref
->lineno
);
20739 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
20741 case DW_MACINFO_end_file
:
20742 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
20744 case DW_MACINFO_define
:
20745 case DW_MACINFO_undef
:
20746 len
= strlen (ref
->info
) + 1;
20748 && len
> DWARF_OFFSET_SIZE
20749 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
20750 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
20752 ref
->code
= ref
->code
== DW_MACINFO_define
20753 ? DW_MACRO_GNU_define_indirect
20754 : DW_MACRO_GNU_undef_indirect
;
20755 output_macinfo_op (ref
);
20758 dw2_asm_output_data (1, ref
->code
,
20759 ref
->code
== DW_MACINFO_define
20760 ? "Define macro" : "Undefine macro");
20761 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
20762 (unsigned long) ref
->lineno
);
20763 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
20765 case DW_MACRO_GNU_define_indirect
:
20766 case DW_MACRO_GNU_undef_indirect
:
20767 node
= find_AT_string (ref
->info
);
20768 if (node
->form
!= DW_FORM_strp
)
20771 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
20772 ++dw2_string_counter
;
20773 node
->label
= xstrdup (label
);
20774 node
->form
= DW_FORM_strp
;
20776 dw2_asm_output_data (1, ref
->code
,
20777 ref
->code
== DW_MACRO_GNU_define_indirect
20778 ? "Define macro indirect"
20779 : "Undefine macro indirect");
20780 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
20781 (unsigned long) ref
->lineno
);
20782 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
20783 debug_str_section
, "The macro: \"%s\"",
20786 case DW_MACRO_GNU_transparent_include
:
20787 dw2_asm_output_data (1, ref
->code
, "Transparent include");
20788 ASM_GENERATE_INTERNAL_LABEL (label
,
20789 DEBUG_MACRO_SECTION_LABEL
, ref
->lineno
);
20790 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
20793 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
20794 ASM_COMMENT_START
, (unsigned long) ref
->code
);
20799 /* Attempt to make a sequence of define/undef macinfo ops shareable with
20800 other compilation unit .debug_macinfo sections. IDX is the first
20801 index of a define/undef, return the number of ops that should be
20802 emitted in a comdat .debug_macinfo section and emit
20803 a DW_MACRO_GNU_transparent_include entry referencing it.
20804 If the define/undef entry should be emitted normally, return 0. */
20807 optimize_macinfo_range (unsigned int idx
, VEC (macinfo_entry
, gc
) *files
,
20808 htab_t
*macinfo_htab
)
20810 macinfo_entry
*first
, *second
, *cur
, *inc
;
20811 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
20812 unsigned char checksum
[16];
20813 struct md5_ctx ctx
;
20814 char *grp_name
, *tail
;
20816 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
20819 first
= VEC_index (macinfo_entry
, macinfo_table
, idx
);
20820 second
= VEC_index (macinfo_entry
, macinfo_table
, idx
+ 1);
20822 /* Optimize only if there are at least two consecutive define/undef ops,
20823 and either all of them are before first DW_MACINFO_start_file
20824 with lineno 0 (i.e. predefined macro block), or all of them are
20825 in some included header file. */
20826 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
20828 if (VEC_empty (macinfo_entry
, files
))
20830 if (first
->lineno
!= 0 || second
->lineno
!= 0)
20833 else if (first
->lineno
== 0)
20836 /* Find the last define/undef entry that can be grouped together
20837 with first and at the same time compute md5 checksum of their
20838 codes, linenumbers and strings. */
20839 md5_init_ctx (&ctx
);
20840 for (i
= idx
; VEC_iterate (macinfo_entry
, macinfo_table
, i
, cur
); i
++)
20841 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
20843 else if (first
->lineno
== 0 && cur
->lineno
!= 0)
20847 unsigned char code
= cur
->code
;
20848 md5_process_bytes (&code
, 1, &ctx
);
20849 checksum_uleb128 (cur
->lineno
, &ctx
);
20850 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
20852 md5_finish_ctx (&ctx
, checksum
);
20855 /* From the containing include filename (if any) pick up just
20856 usable characters from its basename. */
20857 if (first
->lineno
== 0)
20860 base
= lbasename (VEC_last (macinfo_entry
, files
)->info
);
20861 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
20862 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
20863 encoded_filename_len
++;
20864 /* Count . at the end. */
20865 if (encoded_filename_len
)
20866 encoded_filename_len
++;
20868 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
20869 linebuf_len
= strlen (linebuf
);
20871 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
20872 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
20874 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
20875 tail
= grp_name
+ 4;
20876 if (encoded_filename_len
)
20878 for (i
= 0; base
[i
]; i
++)
20879 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
20883 memcpy (tail
, linebuf
, linebuf_len
);
20884 tail
+= linebuf_len
;
20886 for (i
= 0; i
< 16; i
++)
20887 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
20889 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
20890 in the empty vector entry before the first define/undef. */
20891 inc
= VEC_index (macinfo_entry
, macinfo_table
, idx
- 1);
20892 inc
->code
= DW_MACRO_GNU_transparent_include
;
20894 inc
->info
= ggc_strdup (grp_name
);
20895 if (*macinfo_htab
== NULL
)
20896 *macinfo_htab
= htab_create (10, htab_macinfo_hash
, htab_macinfo_eq
, NULL
);
20897 /* Avoid emitting duplicates. */
20898 slot
= htab_find_slot (*macinfo_htab
, inc
, INSERT
);
20903 /* If such an entry has been used before, just emit
20904 a DW_MACRO_GNU_transparent_include op. */
20905 inc
= (macinfo_entry
*) *slot
;
20906 output_macinfo_op (inc
);
20907 /* And clear all macinfo_entry in the range to avoid emitting them
20908 in the second pass. */
20910 VEC_iterate (macinfo_entry
, macinfo_table
, i
, cur
)
20911 && i
< idx
+ count
;
20921 inc
->lineno
= htab_elements (*macinfo_htab
);
20922 output_macinfo_op (inc
);
20927 /* Output macinfo section(s). */
20930 output_macinfo (void)
20933 unsigned long length
= VEC_length (macinfo_entry
, macinfo_table
);
20934 macinfo_entry
*ref
;
20935 VEC (macinfo_entry
, gc
) *files
= NULL
;
20936 htab_t macinfo_htab
= NULL
;
20941 /* output_macinfo* uses these interchangeably. */
20942 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_GNU_define
20943 && (int) DW_MACINFO_undef
== (int) DW_MACRO_GNU_undef
20944 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_GNU_start_file
20945 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_GNU_end_file
);
20947 /* For .debug_macro emit the section header. */
20950 dw2_asm_output_data (2, 4, "DWARF macro version number");
20951 if (DWARF_OFFSET_SIZE
== 8)
20952 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
20954 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
20955 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_line_section_label
,
20956 debug_line_section
, NULL
);
20959 /* In the first loop, it emits the primary .debug_macinfo section
20960 and after each emitted op the macinfo_entry is cleared.
20961 If a longer range of define/undef ops can be optimized using
20962 DW_MACRO_GNU_transparent_include, the
20963 DW_MACRO_GNU_transparent_include op is emitted and kept in
20964 the vector before the first define/undef in the range and the
20965 whole range of define/undef ops is not emitted and kept. */
20966 for (i
= 0; VEC_iterate (macinfo_entry
, macinfo_table
, i
, ref
); i
++)
20970 case DW_MACINFO_start_file
:
20971 VEC_safe_push (macinfo_entry
, gc
, files
, ref
);
20973 case DW_MACINFO_end_file
:
20974 if (!VEC_empty (macinfo_entry
, files
))
20975 VEC_pop (macinfo_entry
, files
);
20977 case DW_MACINFO_define
:
20978 case DW_MACINFO_undef
:
20980 && HAVE_COMDAT_GROUP
20981 && VEC_length (macinfo_entry
, files
) != 1
20984 && VEC_index (macinfo_entry
, macinfo_table
, i
- 1)->code
== 0)
20986 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
20995 /* A dummy entry may be inserted at the beginning to be able
20996 to optimize the whole block of predefined macros. */
21002 output_macinfo_op (ref
);
21007 if (macinfo_htab
== NULL
)
21010 htab_delete (macinfo_htab
);
21012 /* If any DW_MACRO_GNU_transparent_include were used, on those
21013 DW_MACRO_GNU_transparent_include entries terminate the
21014 current chain and switch to a new comdat .debug_macinfo
21015 section and emit the define/undef entries within it. */
21016 for (i
= 0; VEC_iterate (macinfo_entry
, macinfo_table
, i
, ref
); i
++)
21021 case DW_MACRO_GNU_transparent_include
:
21023 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21024 tree comdat_key
= get_identifier (ref
->info
);
21025 /* Terminate the previous .debug_macinfo section. */
21026 dw2_asm_output_data (1, 0, "End compilation unit");
21027 targetm
.asm_out
.named_section (DEBUG_MACRO_SECTION
,
21029 | SECTION_LINKONCE
,
21031 ASM_GENERATE_INTERNAL_LABEL (label
,
21032 DEBUG_MACRO_SECTION_LABEL
,
21034 ASM_OUTPUT_LABEL (asm_out_file
, label
);
21037 dw2_asm_output_data (2, 4, "DWARF macro version number");
21038 if (DWARF_OFFSET_SIZE
== 8)
21039 dw2_asm_output_data (1, 1, "Flags: 64-bit");
21041 dw2_asm_output_data (1, 0, "Flags: 32-bit");
21044 case DW_MACINFO_define
:
21045 case DW_MACINFO_undef
:
21046 output_macinfo_op (ref
);
21051 gcc_unreachable ();
21055 /* Set up for Dwarf output at the start of compilation. */
21058 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
21060 /* Allocate the file_table. */
21061 file_table
= htab_create_ggc (50, file_table_hash
,
21062 file_table_eq
, NULL
);
21064 /* Allocate the decl_die_table. */
21065 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
21066 decl_die_table_eq
, NULL
);
21068 /* Allocate the decl_loc_table. */
21069 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
21070 decl_loc_table_eq
, NULL
);
21072 /* Allocate the cached_dw_loc_list_table. */
21073 cached_dw_loc_list_table
21074 = htab_create_ggc (10, cached_dw_loc_list_table_hash
,
21075 cached_dw_loc_list_table_eq
, NULL
);
21077 /* Allocate the initial hunk of the decl_scope_table. */
21078 decl_scope_table
= VEC_alloc (tree
, gc
, 256);
21080 /* Allocate the initial hunk of the abbrev_die_table. */
21081 abbrev_die_table
= ggc_alloc_cleared_vec_dw_die_ref
21082 (ABBREV_DIE_TABLE_INCREMENT
);
21083 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
21084 /* Zero-th entry is allocated, but unused. */
21085 abbrev_die_table_in_use
= 1;
21087 /* Allocate the pubtypes and pubnames vectors. */
21088 pubname_table
= VEC_alloc (pubname_entry
, gc
, 32);
21089 pubtype_table
= VEC_alloc (pubname_entry
, gc
, 32);
21091 incomplete_types
= VEC_alloc (tree
, gc
, 64);
21093 used_rtx_array
= VEC_alloc (rtx
, gc
, 32);
21095 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
21096 SECTION_DEBUG
, NULL
);
21097 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
21098 SECTION_DEBUG
, NULL
);
21099 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
21100 SECTION_DEBUG
, NULL
);
21101 debug_macinfo_section
= get_section (dwarf_strict
21102 ? DEBUG_MACINFO_SECTION
21103 : DEBUG_MACRO_SECTION
,
21104 SECTION_DEBUG
, NULL
);
21105 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
21106 SECTION_DEBUG
, NULL
);
21107 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
21108 SECTION_DEBUG
, NULL
);
21109 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
21110 SECTION_DEBUG
, NULL
);
21111 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
21112 SECTION_DEBUG
, NULL
);
21113 debug_str_section
= get_section (DEBUG_STR_SECTION
,
21114 DEBUG_STR_SECTION_FLAGS
, NULL
);
21115 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
21116 SECTION_DEBUG
, NULL
);
21117 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
21118 SECTION_DEBUG
, NULL
);
21120 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
21121 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
21122 DEBUG_ABBREV_SECTION_LABEL
, 0);
21123 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
21124 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
21125 COLD_TEXT_SECTION_LABEL
, 0);
21126 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
21128 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
21129 DEBUG_INFO_SECTION_LABEL
, 0);
21130 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
21131 DEBUG_LINE_SECTION_LABEL
, 0);
21132 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
21133 DEBUG_RANGES_SECTION_LABEL
, 0);
21134 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
21136 ? DEBUG_MACINFO_SECTION_LABEL
21137 : DEBUG_MACRO_SECTION_LABEL
, 0);
21139 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21140 macinfo_table
= VEC_alloc (macinfo_entry
, gc
, 64);
21142 switch_to_section (text_section
);
21143 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
21145 /* Make sure the line number table for .text always exists. */
21146 text_section_line_info
= new_line_info_table ();
21147 text_section_line_info
->end_label
= text_end_label
;
21150 /* Called before cgraph_optimize starts outputtting functions, variables
21151 and toplevel asms into assembly. */
21154 dwarf2out_assembly_start (void)
21156 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
21157 && dwarf2out_do_cfi_asm ()
21158 && (!(flag_unwind_tables
|| flag_exceptions
)
21159 || targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
))
21160 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
21163 /* A helper function for dwarf2out_finish called through
21164 htab_traverse. Emit one queued .debug_str string. */
21167 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
21169 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
21171 if (node
->form
== DW_FORM_strp
)
21173 switch_to_section (debug_str_section
);
21174 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
21175 assemble_string (node
->str
, strlen (node
->str
) + 1);
21181 #if ENABLE_ASSERT_CHECKING
21182 /* Verify that all marks are clear. */
21185 verify_marks_clear (dw_die_ref die
)
21189 gcc_assert (! die
->die_mark
);
21190 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
21192 #endif /* ENABLE_ASSERT_CHECKING */
21194 /* Clear the marks for a die and its children.
21195 Be cool if the mark isn't set. */
21198 prune_unmark_dies (dw_die_ref die
)
21204 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
21207 /* Given DIE that we're marking as used, find any other dies
21208 it references as attributes and mark them as used. */
21211 prune_unused_types_walk_attribs (dw_die_ref die
)
21216 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
21218 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
21220 /* A reference to another DIE.
21221 Make sure that it will get emitted.
21222 If it was broken out into a comdat group, don't follow it. */
21223 if (! use_debug_types
21224 || a
->dw_attr
== DW_AT_specification
21225 || a
->dw_attr_val
.v
.val_die_ref
.die
->die_id
.die_type_node
== NULL
)
21226 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
21228 /* Set the string's refcount to 0 so that prune_unused_types_mark
21229 accounts properly for it. */
21230 if (AT_class (a
) == dw_val_class_str
)
21231 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
21235 /* Mark the generic parameters and arguments children DIEs of DIE. */
21238 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
21242 if (die
== NULL
|| die
->die_child
== NULL
)
21244 c
= die
->die_child
;
21247 switch (c
->die_tag
)
21249 case DW_TAG_template_type_param
:
21250 case DW_TAG_template_value_param
:
21251 case DW_TAG_GNU_template_template_param
:
21252 case DW_TAG_GNU_template_parameter_pack
:
21253 prune_unused_types_mark (c
, 1);
21259 } while (c
&& c
!= die
->die_child
);
21262 /* Mark DIE as being used. If DOKIDS is true, then walk down
21263 to DIE's children. */
21266 prune_unused_types_mark (dw_die_ref die
, int dokids
)
21270 if (die
->die_mark
== 0)
21272 /* We haven't done this node yet. Mark it as used. */
21274 /* If this is the DIE of a generic type instantiation,
21275 mark the children DIEs that describe its generic parms and
21277 prune_unused_types_mark_generic_parms_dies (die
);
21279 /* We also have to mark its parents as used.
21280 (But we don't want to mark our parents' kids due to this.) */
21281 if (die
->die_parent
)
21282 prune_unused_types_mark (die
->die_parent
, 0);
21284 /* Mark any referenced nodes. */
21285 prune_unused_types_walk_attribs (die
);
21287 /* If this node is a specification,
21288 also mark the definition, if it exists. */
21289 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
21290 prune_unused_types_mark (die
->die_definition
, 1);
21293 if (dokids
&& die
->die_mark
!= 2)
21295 /* We need to walk the children, but haven't done so yet.
21296 Remember that we've walked the kids. */
21299 /* If this is an array type, we need to make sure our
21300 kids get marked, even if they're types. If we're
21301 breaking out types into comdat sections, do this
21302 for all type definitions. */
21303 if (die
->die_tag
== DW_TAG_array_type
21304 || (use_debug_types
21305 && is_type_die (die
) && ! is_declaration_die (die
)))
21306 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
21308 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
21312 /* For local classes, look if any static member functions were emitted
21313 and if so, mark them. */
21316 prune_unused_types_walk_local_classes (dw_die_ref die
)
21320 if (die
->die_mark
== 2)
21323 switch (die
->die_tag
)
21325 case DW_TAG_structure_type
:
21326 case DW_TAG_union_type
:
21327 case DW_TAG_class_type
:
21330 case DW_TAG_subprogram
:
21331 if (!get_AT_flag (die
, DW_AT_declaration
)
21332 || die
->die_definition
!= NULL
)
21333 prune_unused_types_mark (die
, 1);
21340 /* Mark children. */
21341 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
21344 /* Walk the tree DIE and mark types that we actually use. */
21347 prune_unused_types_walk (dw_die_ref die
)
21351 /* Don't do anything if this node is already marked and
21352 children have been marked as well. */
21353 if (die
->die_mark
== 2)
21356 switch (die
->die_tag
)
21358 case DW_TAG_structure_type
:
21359 case DW_TAG_union_type
:
21360 case DW_TAG_class_type
:
21361 if (die
->die_perennial_p
)
21364 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
21365 if (c
->die_tag
== DW_TAG_subprogram
)
21368 /* Finding used static member functions inside of classes
21369 is needed just for local classes, because for other classes
21370 static member function DIEs with DW_AT_specification
21371 are emitted outside of the DW_TAG_*_type. If we ever change
21372 it, we'd need to call this even for non-local classes. */
21374 prune_unused_types_walk_local_classes (die
);
21376 /* It's a type node --- don't mark it. */
21379 case DW_TAG_const_type
:
21380 case DW_TAG_packed_type
:
21381 case DW_TAG_pointer_type
:
21382 case DW_TAG_reference_type
:
21383 case DW_TAG_rvalue_reference_type
:
21384 case DW_TAG_volatile_type
:
21385 case DW_TAG_typedef
:
21386 case DW_TAG_array_type
:
21387 case DW_TAG_interface_type
:
21388 case DW_TAG_friend
:
21389 case DW_TAG_variant_part
:
21390 case DW_TAG_enumeration_type
:
21391 case DW_TAG_subroutine_type
:
21392 case DW_TAG_string_type
:
21393 case DW_TAG_set_type
:
21394 case DW_TAG_subrange_type
:
21395 case DW_TAG_ptr_to_member_type
:
21396 case DW_TAG_file_type
:
21397 if (die
->die_perennial_p
)
21400 /* It's a type node --- don't mark it. */
21404 /* Mark everything else. */
21408 if (die
->die_mark
== 0)
21412 /* Now, mark any dies referenced from here. */
21413 prune_unused_types_walk_attribs (die
);
21418 /* Mark children. */
21419 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
21422 /* Increment the string counts on strings referred to from DIE's
21426 prune_unused_types_update_strings (dw_die_ref die
)
21431 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
21432 if (AT_class (a
) == dw_val_class_str
)
21434 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
21436 /* Avoid unnecessarily putting strings that are used less than
21437 twice in the hash table. */
21439 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
21442 slot
= htab_find_slot_with_hash (debug_str_hash
, s
->str
,
21443 htab_hash_string (s
->str
),
21445 gcc_assert (*slot
== NULL
);
21451 /* Remove from the tree DIE any dies that aren't marked. */
21454 prune_unused_types_prune (dw_die_ref die
)
21458 gcc_assert (die
->die_mark
);
21459 prune_unused_types_update_strings (die
);
21461 if (! die
->die_child
)
21464 c
= die
->die_child
;
21466 dw_die_ref prev
= c
;
21467 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
21468 if (c
== die
->die_child
)
21470 /* No marked children between 'prev' and the end of the list. */
21472 /* No marked children at all. */
21473 die
->die_child
= NULL
;
21476 prev
->die_sib
= c
->die_sib
;
21477 die
->die_child
= prev
;
21482 if (c
!= prev
->die_sib
)
21484 prune_unused_types_prune (c
);
21485 } while (c
!= die
->die_child
);
21488 /* Remove dies representing declarations that we never use. */
21491 prune_unused_types (void)
21494 limbo_die_node
*node
;
21495 comdat_type_node
*ctnode
;
21497 dw_die_ref base_type
;
21499 #if ENABLE_ASSERT_CHECKING
21500 /* All the marks should already be clear. */
21501 verify_marks_clear (comp_unit_die ());
21502 for (node
= limbo_die_list
; node
; node
= node
->next
)
21503 verify_marks_clear (node
->die
);
21504 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
21505 verify_marks_clear (ctnode
->root_die
);
21506 #endif /* ENABLE_ASSERT_CHECKING */
21508 /* Mark types that are used in global variables. */
21509 premark_types_used_by_global_vars ();
21511 /* Set the mark on nodes that are actually used. */
21512 prune_unused_types_walk (comp_unit_die ());
21513 for (node
= limbo_die_list
; node
; node
= node
->next
)
21514 prune_unused_types_walk (node
->die
);
21515 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
21517 prune_unused_types_walk (ctnode
->root_die
);
21518 prune_unused_types_mark (ctnode
->type_die
, 1);
21521 /* Also set the mark on nodes referenced from the
21523 FOR_EACH_VEC_ELT (pubname_entry
, pubname_table
, i
, pub
)
21524 prune_unused_types_mark (pub
->die
, 1);
21525 for (i
= 0; VEC_iterate (dw_die_ref
, base_types
, i
, base_type
); i
++)
21526 prune_unused_types_mark (base_type
, 1);
21528 if (debug_str_hash
)
21529 htab_empty (debug_str_hash
);
21530 prune_unused_types_prune (comp_unit_die ());
21531 for (node
= limbo_die_list
; node
; node
= node
->next
)
21532 prune_unused_types_prune (node
->die
);
21533 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
21534 prune_unused_types_prune (ctnode
->root_die
);
21536 /* Leave the marks clear. */
21537 prune_unmark_dies (comp_unit_die ());
21538 for (node
= limbo_die_list
; node
; node
= node
->next
)
21539 prune_unmark_dies (node
->die
);
21540 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
21541 prune_unmark_dies (ctnode
->root_die
);
21544 /* Set the parameter to true if there are any relative pathnames in
21547 file_table_relative_p (void ** slot
, void *param
)
21549 bool *p
= (bool *) param
;
21550 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
21551 if (!IS_ABSOLUTE_PATH (d
->filename
))
21559 /* Routines to manipulate hash table of comdat type units. */
21562 htab_ct_hash (const void *of
)
21565 const comdat_type_node
*const type_node
= (const comdat_type_node
*) of
;
21567 memcpy (&h
, type_node
->signature
, sizeof (h
));
21572 htab_ct_eq (const void *of1
, const void *of2
)
21574 const comdat_type_node
*const type_node_1
= (const comdat_type_node
*) of1
;
21575 const comdat_type_node
*const type_node_2
= (const comdat_type_node
*) of2
;
21577 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
21578 DWARF_TYPE_SIGNATURE_SIZE
));
21581 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
21582 to the location it would have been added, should we know its
21583 DECL_ASSEMBLER_NAME when we added other attributes. This will
21584 probably improve compactness of debug info, removing equivalent
21585 abbrevs, and hide any differences caused by deferring the
21586 computation of the assembler name, triggered by e.g. PCH. */
21589 move_linkage_attr (dw_die_ref die
)
21591 unsigned ix
= VEC_length (dw_attr_node
, die
->die_attr
);
21592 dw_attr_node linkage
= *VEC_index (dw_attr_node
, die
->die_attr
, ix
- 1);
21594 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
21595 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
21599 dw_attr_node
*prev
= VEC_index (dw_attr_node
, die
->die_attr
, ix
- 1);
21601 if (prev
->dw_attr
== DW_AT_decl_line
|| prev
->dw_attr
== DW_AT_name
)
21605 if (ix
!= VEC_length (dw_attr_node
, die
->die_attr
) - 1)
21607 VEC_pop (dw_attr_node
, die
->die_attr
);
21608 VEC_quick_insert (dw_attr_node
, die
->die_attr
, ix
, &linkage
);
21612 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
21613 referenced from typed stack ops and count how often they are used. */
21616 mark_base_types (dw_loc_descr_ref loc
)
21618 dw_die_ref base_type
= NULL
;
21620 for (; loc
; loc
= loc
->dw_loc_next
)
21622 switch (loc
->dw_loc_opc
)
21624 case DW_OP_GNU_regval_type
:
21625 case DW_OP_GNU_deref_type
:
21626 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
21628 case DW_OP_GNU_convert
:
21629 case DW_OP_GNU_reinterpret
:
21630 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
21633 case DW_OP_GNU_const_type
:
21634 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
21636 case DW_OP_GNU_entry_value
:
21637 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
21642 gcc_assert (base_type
->die_parent
== comp_unit_die ());
21643 if (base_type
->die_mark
)
21644 base_type
->die_mark
++;
21647 VEC_safe_push (dw_die_ref
, heap
, base_types
, base_type
);
21648 base_type
->die_mark
= 1;
21653 /* Comparison function for sorting marked base types. */
21656 base_type_cmp (const void *x
, const void *y
)
21658 dw_die_ref dx
= *(const dw_die_ref
*) x
;
21659 dw_die_ref dy
= *(const dw_die_ref
*) y
;
21660 unsigned int byte_size1
, byte_size2
;
21661 unsigned int encoding1
, encoding2
;
21662 if (dx
->die_mark
> dy
->die_mark
)
21664 if (dx
->die_mark
< dy
->die_mark
)
21666 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
21667 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
21668 if (byte_size1
< byte_size2
)
21670 if (byte_size1
> byte_size2
)
21672 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
21673 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
21674 if (encoding1
< encoding2
)
21676 if (encoding1
> encoding2
)
21681 /* Move base types marked by mark_base_types as early as possible
21682 in the CU, sorted by decreasing usage count both to make the
21683 uleb128 references as small as possible and to make sure they
21684 will have die_offset already computed by calc_die_sizes when
21685 sizes of typed stack loc ops is computed. */
21688 move_marked_base_types (void)
21691 dw_die_ref base_type
, die
, c
;
21693 if (VEC_empty (dw_die_ref
, base_types
))
21696 /* Sort by decreasing usage count, they will be added again in that
21698 VEC_qsort (dw_die_ref
, base_types
, base_type_cmp
);
21699 die
= comp_unit_die ();
21700 c
= die
->die_child
;
21703 dw_die_ref prev
= c
;
21705 while (c
->die_mark
)
21707 remove_child_with_prev (c
, prev
);
21708 /* As base types got marked, there must be at least
21709 one node other than DW_TAG_base_type. */
21710 gcc_assert (c
!= c
->die_sib
);
21714 while (c
!= die
->die_child
);
21715 gcc_assert (die
->die_child
);
21716 c
= die
->die_child
;
21717 for (i
= 0; VEC_iterate (dw_die_ref
, base_types
, i
, base_type
); i
++)
21719 base_type
->die_mark
= 0;
21720 base_type
->die_sib
= c
->die_sib
;
21721 c
->die_sib
= base_type
;
21726 /* Helper function for resolve_addr, attempt to resolve
21727 one CONST_STRING, return non-zero if not successful. Similarly verify that
21728 SYMBOL_REFs refer to variables emitted in the current CU. */
21731 resolve_one_addr (rtx
*addr
, void *data ATTRIBUTE_UNUSED
)
21735 if (GET_CODE (rtl
) == CONST_STRING
)
21737 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
21738 tree t
= build_string (len
, XSTR (rtl
, 0));
21739 tree tlen
= size_int (len
- 1);
21741 = build_array_type (char_type_node
, build_index_type (tlen
));
21742 rtl
= lookup_constant_def (t
);
21743 if (!rtl
|| !MEM_P (rtl
))
21745 rtl
= XEXP (rtl
, 0);
21746 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
21751 if (GET_CODE (rtl
) == SYMBOL_REF
21752 && SYMBOL_REF_DECL (rtl
))
21754 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
21756 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
21759 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
21763 if (GET_CODE (rtl
) == CONST
21764 && for_each_rtx (&XEXP (rtl
, 0), resolve_one_addr
, NULL
))
21770 /* Helper function for resolve_addr, handle one location
21771 expression, return false if at least one CONST_STRING or SYMBOL_REF in
21772 the location list couldn't be resolved. */
21775 resolve_addr_in_expr (dw_loc_descr_ref loc
)
21777 dw_loc_descr_ref keep
= NULL
;
21778 for (; loc
; loc
= loc
->dw_loc_next
)
21779 switch (loc
->dw_loc_opc
)
21782 if (resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
21785 case DW_OP_const4u
:
21786 case DW_OP_const8u
:
21788 && resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
21791 case DW_OP_plus_uconst
:
21792 if (size_of_loc_descr (loc
)
21793 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
21795 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
21797 dw_loc_descr_ref repl
21798 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
21799 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
21800 add_loc_descr (&repl
, loc
->dw_loc_next
);
21804 case DW_OP_implicit_value
:
21805 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
21806 && resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
, NULL
))
21809 case DW_OP_GNU_implicit_pointer
:
21810 case DW_OP_GNU_parameter_ref
:
21811 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
21814 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
21817 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
21818 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
21819 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
21822 case DW_OP_GNU_const_type
:
21823 case DW_OP_GNU_regval_type
:
21824 case DW_OP_GNU_deref_type
:
21825 case DW_OP_GNU_convert
:
21826 case DW_OP_GNU_reinterpret
:
21827 while (loc
->dw_loc_next
21828 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
)
21830 dw_die_ref base1
, base2
;
21831 unsigned enc1
, enc2
, size1
, size2
;
21832 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
21833 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
21834 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
21835 else if (loc
->dw_loc_oprnd1
.val_class
21836 == dw_val_class_unsigned_const
)
21839 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
21840 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
21841 == dw_val_class_unsigned_const
)
21843 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
21844 gcc_assert (base1
->die_tag
== DW_TAG_base_type
21845 && base2
->die_tag
== DW_TAG_base_type
);
21846 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
21847 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
21848 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
21849 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
21851 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
21852 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
21856 /* Optimize away next DW_OP_GNU_convert after
21857 adjusting LOC's base type die reference. */
21858 if (loc
->dw_loc_opc
== DW_OP_GNU_regval_type
21859 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
21860 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
21862 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
21863 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
21866 /* Don't change integer DW_OP_GNU_convert after e.g. floating
21867 point typed stack entry. */
21868 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
21869 keep
= loc
->dw_loc_next
;
21879 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
21880 an address in .rodata section if the string literal is emitted there,
21881 or remove the containing location list or replace DW_AT_const_value
21882 with DW_AT_location and empty location expression, if it isn't found
21883 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
21884 to something that has been emitted in the current CU. */
21887 resolve_addr (dw_die_ref die
)
21891 dw_loc_list_ref
*curr
, *start
, loc
;
21894 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
21895 switch (AT_class (a
))
21897 case dw_val_class_loc_list
:
21898 start
= curr
= AT_loc_list_ptr (a
);
21901 /* The same list can be referenced more than once. See if we have
21902 already recorded the result from a previous pass. */
21904 *curr
= loc
->dw_loc_next
;
21905 else if (!loc
->resolved_addr
)
21907 /* As things stand, we do not expect or allow one die to
21908 reference a suffix of another die's location list chain.
21909 References must be identical or completely separate.
21910 There is therefore no need to cache the result of this
21911 pass on any list other than the first; doing so
21912 would lead to unnecessary writes. */
21915 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
21916 if (!resolve_addr_in_expr ((*curr
)->expr
))
21918 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
21919 if (next
&& (*curr
)->ll_symbol
)
21921 gcc_assert (!next
->ll_symbol
);
21922 next
->ll_symbol
= (*curr
)->ll_symbol
;
21928 mark_base_types ((*curr
)->expr
);
21929 curr
= &(*curr
)->dw_loc_next
;
21933 loc
->resolved_addr
= 1;
21937 loc
->dw_loc_next
= *start
;
21942 remove_AT (die
, a
->dw_attr
);
21946 case dw_val_class_loc
:
21948 dw_loc_descr_ref l
= AT_loc (a
);
21949 /* For -gdwarf-2 don't attempt to optimize
21950 DW_AT_data_member_location containing
21951 DW_OP_plus_uconst - older consumers might
21952 rely on it being that op instead of a more complex,
21953 but shorter, location description. */
21954 if ((dwarf_version
> 2
21955 || a
->dw_attr
!= DW_AT_data_member_location
21957 || l
->dw_loc_opc
!= DW_OP_plus_uconst
21958 || l
->dw_loc_next
!= NULL
)
21959 && !resolve_addr_in_expr (l
))
21961 remove_AT (die
, a
->dw_attr
);
21965 mark_base_types (l
);
21968 case dw_val_class_addr
:
21969 if (a
->dw_attr
== DW_AT_const_value
21970 && resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
, NULL
))
21972 remove_AT (die
, a
->dw_attr
);
21975 if (die
->die_tag
== DW_TAG_GNU_call_site
21976 && a
->dw_attr
== DW_AT_abstract_origin
)
21978 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
21979 dw_die_ref tdie
= lookup_decl_die (tdecl
);
21981 && DECL_EXTERNAL (tdecl
)
21982 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
)
21984 force_decl_die (tdecl
);
21985 tdie
= lookup_decl_die (tdecl
);
21989 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
21990 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
21991 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
21995 remove_AT (die
, a
->dw_attr
);
22004 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
22007 /* Helper routines for optimize_location_lists.
22008 This pass tries to share identical local lists in .debug_loc
22011 /* Iteratively hash operands of LOC opcode. */
22013 static inline hashval_t
22014 hash_loc_operands (dw_loc_descr_ref loc
, hashval_t hash
)
22016 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
22017 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
22019 switch (loc
->dw_loc_opc
)
22021 case DW_OP_const4u
:
22022 case DW_OP_const8u
:
22026 case DW_OP_const1u
:
22027 case DW_OP_const1s
:
22028 case DW_OP_const2u
:
22029 case DW_OP_const2s
:
22030 case DW_OP_const4s
:
22031 case DW_OP_const8s
:
22035 case DW_OP_plus_uconst
:
22071 case DW_OP_deref_size
:
22072 case DW_OP_xderef_size
:
22073 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
22080 gcc_assert (val1
->val_class
== dw_val_class_loc
);
22081 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
22082 hash
= iterative_hash_object (offset
, hash
);
22085 case DW_OP_implicit_value
:
22086 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
22087 switch (val2
->val_class
)
22089 case dw_val_class_const
:
22090 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
22092 case dw_val_class_vec
:
22094 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
22095 unsigned int len
= val2
->v
.val_vec
.length
;
22097 hash
= iterative_hash_object (elt_size
, hash
);
22098 hash
= iterative_hash_object (len
, hash
);
22099 hash
= iterative_hash (val2
->v
.val_vec
.array
,
22100 len
* elt_size
, hash
);
22103 case dw_val_class_const_double
:
22104 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
22105 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
22107 case dw_val_class_addr
:
22108 hash
= iterative_hash_rtx (val2
->v
.val_addr
, hash
);
22111 gcc_unreachable ();
22115 case DW_OP_bit_piece
:
22116 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
22117 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
22123 unsigned char dtprel
= 0xd1;
22124 hash
= iterative_hash_object (dtprel
, hash
);
22126 hash
= iterative_hash_rtx (val1
->v
.val_addr
, hash
);
22128 case DW_OP_GNU_implicit_pointer
:
22129 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
22131 case DW_OP_GNU_entry_value
:
22132 hash
= hash_loc_operands (val1
->v
.val_loc
, hash
);
22134 case DW_OP_GNU_regval_type
:
22135 case DW_OP_GNU_deref_type
:
22137 unsigned int byte_size
22138 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
22139 unsigned int encoding
22140 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
22141 hash
= iterative_hash_object (val1
->v
.val_int
, hash
);
22142 hash
= iterative_hash_object (byte_size
, hash
);
22143 hash
= iterative_hash_object (encoding
, hash
);
22146 case DW_OP_GNU_convert
:
22147 case DW_OP_GNU_reinterpret
:
22148 if (val1
->val_class
== dw_val_class_unsigned_const
)
22150 hash
= iterative_hash_object (val1
->v
.val_unsigned
, hash
);
22154 case DW_OP_GNU_const_type
:
22156 unsigned int byte_size
22157 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
22158 unsigned int encoding
22159 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
22160 hash
= iterative_hash_object (byte_size
, hash
);
22161 hash
= iterative_hash_object (encoding
, hash
);
22162 if (loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
22164 hash
= iterative_hash_object (val2
->val_class
, hash
);
22165 switch (val2
->val_class
)
22167 case dw_val_class_const
:
22168 hash
= iterative_hash_object (val2
->v
.val_int
, hash
);
22170 case dw_val_class_vec
:
22172 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
22173 unsigned int len
= val2
->v
.val_vec
.length
;
22175 hash
= iterative_hash_object (elt_size
, hash
);
22176 hash
= iterative_hash_object (len
, hash
);
22177 hash
= iterative_hash (val2
->v
.val_vec
.array
,
22178 len
* elt_size
, hash
);
22181 case dw_val_class_const_double
:
22182 hash
= iterative_hash_object (val2
->v
.val_double
.low
, hash
);
22183 hash
= iterative_hash_object (val2
->v
.val_double
.high
, hash
);
22186 gcc_unreachable ();
22192 /* Other codes have no operands. */
22198 /* Iteratively hash the whole DWARF location expression LOC. */
22200 static inline hashval_t
22201 hash_locs (dw_loc_descr_ref loc
, hashval_t hash
)
22203 dw_loc_descr_ref l
;
22204 bool sizes_computed
= false;
22205 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
22206 size_of_locs (loc
);
22208 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
22210 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
22211 hash
= iterative_hash_object (opc
, hash
);
22212 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
22214 size_of_locs (loc
);
22215 sizes_computed
= true;
22217 hash
= hash_loc_operands (l
, hash
);
22222 /* Compute hash of the whole location list LIST_HEAD. */
22225 hash_loc_list (dw_loc_list_ref list_head
)
22227 dw_loc_list_ref curr
= list_head
;
22228 hashval_t hash
= 0;
22230 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
22232 hash
= iterative_hash (curr
->begin
, strlen (curr
->begin
) + 1, hash
);
22233 hash
= iterative_hash (curr
->end
, strlen (curr
->end
) + 1, hash
);
22235 hash
= iterative_hash (curr
->section
, strlen (curr
->section
) + 1,
22237 hash
= hash_locs (curr
->expr
, hash
);
22239 list_head
->hash
= hash
;
22242 /* Return true if X and Y opcodes have the same operands. */
22245 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
22247 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
22248 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
22249 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
22250 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
22252 switch (x
->dw_loc_opc
)
22254 case DW_OP_const4u
:
22255 case DW_OP_const8u
:
22259 case DW_OP_const1u
:
22260 case DW_OP_const1s
:
22261 case DW_OP_const2u
:
22262 case DW_OP_const2s
:
22263 case DW_OP_const4s
:
22264 case DW_OP_const8s
:
22268 case DW_OP_plus_uconst
:
22304 case DW_OP_deref_size
:
22305 case DW_OP_xderef_size
:
22306 return valx1
->v
.val_int
== valy1
->v
.val_int
;
22309 gcc_assert (valx1
->val_class
== dw_val_class_loc
22310 && valy1
->val_class
== dw_val_class_loc
22311 && x
->dw_loc_addr
== y
->dw_loc_addr
);
22312 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
22313 case DW_OP_implicit_value
:
22314 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
22315 || valx2
->val_class
!= valy2
->val_class
)
22317 switch (valx2
->val_class
)
22319 case dw_val_class_const
:
22320 return valx2
->v
.val_int
== valy2
->v
.val_int
;
22321 case dw_val_class_vec
:
22322 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
22323 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
22324 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
22325 valx2
->v
.val_vec
.elt_size
22326 * valx2
->v
.val_vec
.length
) == 0;
22327 case dw_val_class_const_double
:
22328 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
22329 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
22330 case dw_val_class_addr
:
22331 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
22333 gcc_unreachable ();
22336 case DW_OP_bit_piece
:
22337 return valx1
->v
.val_int
== valy1
->v
.val_int
22338 && valx2
->v
.val_int
== valy2
->v
.val_int
;
22341 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
22342 case DW_OP_GNU_implicit_pointer
:
22343 return valx1
->val_class
== dw_val_class_die_ref
22344 && valx1
->val_class
== valy1
->val_class
22345 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
22346 && valx2
->v
.val_int
== valy2
->v
.val_int
;
22347 case DW_OP_GNU_entry_value
:
22348 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
22349 case DW_OP_GNU_const_type
:
22350 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
22351 || valx2
->val_class
!= valy2
->val_class
)
22353 switch (valx2
->val_class
)
22355 case dw_val_class_const
:
22356 return valx2
->v
.val_int
== valy2
->v
.val_int
;
22357 case dw_val_class_vec
:
22358 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
22359 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
22360 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
22361 valx2
->v
.val_vec
.elt_size
22362 * valx2
->v
.val_vec
.length
) == 0;
22363 case dw_val_class_const_double
:
22364 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
22365 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
22367 gcc_unreachable ();
22369 case DW_OP_GNU_regval_type
:
22370 case DW_OP_GNU_deref_type
:
22371 return valx1
->v
.val_int
== valy1
->v
.val_int
22372 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
22373 case DW_OP_GNU_convert
:
22374 case DW_OP_GNU_reinterpret
:
22375 if (valx1
->val_class
!= valy1
->val_class
)
22377 if (valx1
->val_class
== dw_val_class_unsigned_const
)
22378 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
22379 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
22380 case DW_OP_GNU_parameter_ref
:
22381 return valx1
->val_class
== dw_val_class_die_ref
22382 && valx1
->val_class
== valy1
->val_class
22383 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
22385 /* Other codes have no operands. */
22390 /* Return true if DWARF location expressions X and Y are the same. */
22393 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
22395 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
22396 if (x
->dw_loc_opc
!= y
->dw_loc_opc
22397 || x
->dtprel
!= y
->dtprel
22398 || !compare_loc_operands (x
, y
))
22400 return x
== NULL
&& y
== NULL
;
22403 /* Return precomputed hash of location list X. */
22406 loc_list_hash (const void *x
)
22408 return ((const struct dw_loc_list_struct
*) x
)->hash
;
22411 /* Return 1 if location lists X and Y are the same. */
22414 loc_list_eq (const void *x
, const void *y
)
22416 const struct dw_loc_list_struct
*a
= (const struct dw_loc_list_struct
*) x
;
22417 const struct dw_loc_list_struct
*b
= (const struct dw_loc_list_struct
*) y
;
22420 if (a
->hash
!= b
->hash
)
22422 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
22423 if (strcmp (a
->begin
, b
->begin
) != 0
22424 || strcmp (a
->end
, b
->end
) != 0
22425 || (a
->section
== NULL
) != (b
->section
== NULL
)
22426 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
22427 || !compare_locs (a
->expr
, b
->expr
))
22429 return a
== NULL
&& b
== NULL
;
22432 /* Recursively optimize location lists referenced from DIE
22433 children and share them whenever possible. */
22436 optimize_location_lists_1 (dw_die_ref die
, htab_t htab
)
22443 FOR_EACH_VEC_ELT (dw_attr_node
, die
->die_attr
, ix
, a
)
22444 if (AT_class (a
) == dw_val_class_loc_list
)
22446 dw_loc_list_ref list
= AT_loc_list (a
);
22447 /* TODO: perform some optimizations here, before hashing
22448 it and storing into the hash table. */
22449 hash_loc_list (list
);
22450 slot
= htab_find_slot_with_hash (htab
, list
, list
->hash
,
22453 *slot
= (void *) list
;
22455 a
->dw_attr_val
.v
.val_loc_list
= (dw_loc_list_ref
) *slot
;
22458 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
22461 /* Optimize location lists referenced from DIE
22462 children and share them whenever possible. */
22465 optimize_location_lists (dw_die_ref die
)
22467 htab_t htab
= htab_create (500, loc_list_hash
, loc_list_eq
, NULL
);
22468 optimize_location_lists_1 (die
, htab
);
22469 htab_delete (htab
);
22472 /* Output stuff that dwarf requires at the end of every file,
22473 and generate the DWARF-2 debugging info. */
22476 dwarf2out_finish (const char *filename
)
22478 limbo_die_node
*node
, *next_node
;
22479 comdat_type_node
*ctnode
;
22480 htab_t comdat_type_table
;
22483 /* PCH might result in DW_AT_producer string being restored from the
22484 header compilation, fix it up if needed. */
22485 dw_attr_ref producer
= get_AT (comp_unit_die (), DW_AT_producer
);
22486 if (strcmp (AT_string (producer
), producer_string
) != 0)
22488 struct indirect_string_node
*node
= find_AT_string (producer_string
);
22489 producer
->dw_attr_val
.v
.val_str
= node
;
22492 gen_scheduled_generic_parms_dies ();
22493 gen_remaining_tmpl_value_param_die_attribute ();
22495 /* Add the name for the main input file now. We delayed this from
22496 dwarf2out_init to avoid complications with PCH. */
22497 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
22498 if (!IS_ABSOLUTE_PATH (filename
))
22499 add_comp_dir_attribute (comp_unit_die ());
22500 else if (get_AT (comp_unit_die (), DW_AT_comp_dir
) == NULL
)
22503 htab_traverse (file_table
, file_table_relative_p
, &p
);
22505 add_comp_dir_attribute (comp_unit_die ());
22508 for (i
= 0; i
< VEC_length (deferred_locations
, deferred_locations_list
); i
++)
22510 add_location_or_const_value_attribute (
22511 VEC_index (deferred_locations
, deferred_locations_list
, i
)->die
,
22512 VEC_index (deferred_locations
, deferred_locations_list
, i
)->variable
,
22517 /* Traverse the limbo die list, and add parent/child links. The only
22518 dies without parents that should be here are concrete instances of
22519 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
22520 For concrete instances, we can get the parent die from the abstract
22522 for (node
= limbo_die_list
; node
; node
= next_node
)
22524 dw_die_ref die
= node
->die
;
22525 next_node
= node
->next
;
22527 if (die
->die_parent
== NULL
)
22529 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
22531 if (origin
&& origin
->die_parent
)
22532 add_child_die (origin
->die_parent
, die
);
22533 else if (is_cu_die (die
))
22535 else if (seen_error ())
22536 /* It's OK to be confused by errors in the input. */
22537 add_child_die (comp_unit_die (), die
);
22540 /* In certain situations, the lexical block containing a
22541 nested function can be optimized away, which results
22542 in the nested function die being orphaned. Likewise
22543 with the return type of that nested function. Force
22544 this to be a child of the containing function.
22546 It may happen that even the containing function got fully
22547 inlined and optimized out. In that case we are lost and
22548 assign the empty child. This should not be big issue as
22549 the function is likely unreachable too. */
22550 tree context
= NULL_TREE
;
22552 gcc_assert (node
->created_for
);
22554 if (DECL_P (node
->created_for
))
22555 context
= DECL_CONTEXT (node
->created_for
);
22556 else if (TYPE_P (node
->created_for
))
22557 context
= TYPE_CONTEXT (node
->created_for
);
22559 origin
= get_context_die (context
);
22560 add_child_die (origin
, die
);
22565 limbo_die_list
= NULL
;
22567 #if ENABLE_ASSERT_CHECKING
22569 dw_die_ref die
= comp_unit_die (), c
;
22570 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
22573 resolve_addr (comp_unit_die ());
22574 move_marked_base_types ();
22576 for (node
= deferred_asm_name
; node
; node
= node
->next
)
22578 tree decl
= node
->created_for
;
22579 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
22581 add_linkage_attr (node
->die
, decl
);
22582 move_linkage_attr (node
->die
);
22586 deferred_asm_name
= NULL
;
22588 /* Walk through the list of incomplete types again, trying once more to
22589 emit full debugging info for them. */
22590 retry_incomplete_types ();
22592 if (flag_eliminate_unused_debug_types
)
22593 prune_unused_types ();
22595 /* Generate separate CUs for each of the include files we've seen.
22596 They will go into limbo_die_list. */
22597 if (flag_eliminate_dwarf2_dups
&& ! use_debug_types
)
22598 break_out_includes (comp_unit_die ());
22600 /* Generate separate COMDAT sections for type DIEs. */
22601 if (use_debug_types
)
22603 break_out_comdat_types (comp_unit_die ());
22605 /* Each new type_unit DIE was added to the limbo die list when created.
22606 Since these have all been added to comdat_type_list, clear the
22608 limbo_die_list
= NULL
;
22610 /* For each new comdat type unit, copy declarations for incomplete
22611 types to make the new unit self-contained (i.e., no direct
22612 references to the main compile unit). */
22613 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
22614 copy_decls_for_unworthy_types (ctnode
->root_die
);
22615 copy_decls_for_unworthy_types (comp_unit_die ());
22617 /* In the process of copying declarations from one unit to another,
22618 we may have left some declarations behind that are no longer
22619 referenced. Prune them. */
22620 prune_unused_types ();
22623 /* Traverse the DIE's and add add sibling attributes to those DIE's
22624 that have children. */
22625 add_sibling_attributes (comp_unit_die ());
22626 for (node
= limbo_die_list
; node
; node
= node
->next
)
22627 add_sibling_attributes (node
->die
);
22628 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
22629 add_sibling_attributes (ctnode
->root_die
);
22631 /* Output a terminator label for the .text section. */
22632 switch_to_section (text_section
);
22633 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
22634 if (cold_text_section
)
22636 switch_to_section (cold_text_section
);
22637 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
22640 /* We can only use the low/high_pc attributes if all of the code was
22642 if (!have_multiple_function_sections
22643 || (dwarf_version
< 3 && dwarf_strict
))
22645 /* Don't add if the CU has no associated code. */
22646 if (text_section_used
)
22648 add_AT_lbl_id (comp_unit_die (), DW_AT_low_pc
, text_section_label
);
22649 add_AT_lbl_id (comp_unit_die (), DW_AT_high_pc
, text_end_label
);
22656 bool range_list_added
= false;
22658 if (text_section_used
)
22659 add_ranges_by_labels (comp_unit_die (), text_section_label
,
22660 text_end_label
, &range_list_added
);
22661 if (cold_text_section_used
)
22662 add_ranges_by_labels (comp_unit_die (), cold_text_section_label
,
22663 cold_end_label
, &range_list_added
);
22665 FOR_EACH_VEC_ELT (dw_fde_ref
, fde_vec
, fde_idx
, fde
)
22667 if (!fde
->in_std_section
)
22668 add_ranges_by_labels (comp_unit_die (), fde
->dw_fde_begin
,
22669 fde
->dw_fde_end
, &range_list_added
);
22670 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
22671 add_ranges_by_labels (comp_unit_die (), fde
->dw_fde_second_begin
,
22672 fde
->dw_fde_second_end
, &range_list_added
);
22675 if (range_list_added
)
22677 /* We need to give .debug_loc and .debug_ranges an appropriate
22678 "base address". Use zero so that these addresses become
22679 absolute. Historically, we've emitted the unexpected
22680 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
22681 Emit both to give time for other tools to adapt. */
22682 add_AT_addr (comp_unit_die (), DW_AT_low_pc
, const0_rtx
);
22683 if (! dwarf_strict
&& dwarf_version
< 4)
22684 add_AT_addr (comp_unit_die (), DW_AT_entry_pc
, const0_rtx
);
22690 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
22691 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list
,
22692 debug_line_section_label
);
22694 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22695 add_AT_macptr (comp_unit_die (),
22696 dwarf_strict
? DW_AT_macro_info
: DW_AT_GNU_macros
,
22697 macinfo_section_label
);
22699 if (have_location_lists
)
22700 optimize_location_lists (comp_unit_die ());
22702 /* Output all of the compilation units. We put the main one last so that
22703 the offsets are available to output_pubnames. */
22704 for (node
= limbo_die_list
; node
; node
= node
->next
)
22705 output_comp_unit (node
->die
, 0);
22707 comdat_type_table
= htab_create (100, htab_ct_hash
, htab_ct_eq
, NULL
);
22708 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
22710 void **slot
= htab_find_slot (comdat_type_table
, ctnode
, INSERT
);
22712 /* Don't output duplicate types. */
22713 if (*slot
!= HTAB_EMPTY_ENTRY
)
22716 /* Add a pointer to the line table for the main compilation unit
22717 so that the debugger can make sense of DW_AT_decl_file
22719 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
22720 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
22721 debug_line_section_label
);
22723 output_comdat_type_unit (ctnode
);
22726 htab_delete (comdat_type_table
);
22728 /* Output the main compilation unit if non-empty or if .debug_macinfo
22729 will be emitted. */
22730 output_comp_unit (comp_unit_die (), debug_info_level
>= DINFO_LEVEL_VERBOSE
);
22732 /* Output the abbreviation table. */
22733 if (abbrev_die_table_in_use
!= 1)
22735 switch_to_section (debug_abbrev_section
);
22736 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
22737 output_abbrev_section ();
22740 /* Output location list section if necessary. */
22741 if (have_location_lists
)
22743 /* Output the location lists info. */
22744 switch_to_section (debug_loc_section
);
22745 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
,
22746 DEBUG_LOC_SECTION_LABEL
, 0);
22747 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
22748 output_location_lists (comp_unit_die ());
22751 /* Output public names table if necessary. */
22752 if (!VEC_empty (pubname_entry
, pubname_table
))
22754 gcc_assert (info_section_emitted
);
22755 switch_to_section (debug_pubnames_section
);
22756 output_pubnames (pubname_table
);
22759 /* Output public types table if necessary. */
22760 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
22761 It shouldn't hurt to emit it always, since pure DWARF2 consumers
22762 simply won't look for the section. */
22763 if (!VEC_empty (pubname_entry
, pubtype_table
))
22765 bool empty
= false;
22767 if (flag_eliminate_unused_debug_types
)
22769 /* The pubtypes table might be emptied by pruning unused items. */
22773 FOR_EACH_VEC_ELT (pubname_entry
, pubtype_table
, i
, p
)
22774 if (p
->die
->die_offset
!= 0)
22782 gcc_assert (info_section_emitted
);
22783 switch_to_section (debug_pubtypes_section
);
22784 output_pubnames (pubtype_table
);
22788 /* Output the address range information if a CU (.debug_info section)
22789 was emitted. We output an empty table even if we had no functions
22790 to put in it. This because the consumer has no way to tell the
22791 difference between an empty table that we omitted and failure to
22792 generate a table that would have contained data. */
22793 if (info_section_emitted
)
22795 unsigned long aranges_length
= size_of_aranges ();
22797 switch_to_section (debug_aranges_section
);
22798 output_aranges (aranges_length
);
22801 /* Output ranges section if necessary. */
22802 if (ranges_table_in_use
)
22804 switch_to_section (debug_ranges_section
);
22805 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
22809 /* Have to end the macro section. */
22810 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22812 switch_to_section (debug_macinfo_section
);
22813 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
22814 if (!VEC_empty (macinfo_entry
, macinfo_table
))
22816 dw2_asm_output_data (1, 0, "End compilation unit");
22819 /* Output the source line correspondence table. We must do this
22820 even if there is no line information. Otherwise, on an empty
22821 translation unit, we will generate a present, but empty,
22822 .debug_info section. IRIX 6.5 `nm' will then complain when
22823 examining the file. This is done late so that any filenames
22824 used by the debug_info section are marked as 'used'. */
22825 switch_to_section (debug_line_section
);
22826 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
22827 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
22828 output_line_info ();
22830 /* If we emitted any DW_FORM_strp form attribute, output the string
22832 if (debug_str_hash
)
22833 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
22836 #include "gt-dwarf2out.h"