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
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;
102 #ifdef VMS_DEBUGGING_INFO
103 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
105 /* Define this macro to be a nonzero value if the directory specifications
106 which are output in the debug info should end with a separator. */
107 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
108 /* Define this macro to evaluate to a nonzero value if GCC should refrain
109 from generating indirect strings in DWARF2 debug information, for instance
110 if your target is stuck with an old version of GDB that is unable to
111 process them properly or uses VMS Debug. */
112 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
114 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
115 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
118 /* ??? Poison these here until it can be done generically. They've been
119 totally replaced in this file; make sure it stays that way. */
120 #undef DWARF2_UNWIND_INFO
121 #undef DWARF2_FRAME_INFO
122 #if (GCC_VERSION >= 3000)
123 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
126 /* The size of the target's pointer type. */
128 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
131 /* Array of RTXes referenced by the debugging information, which therefore
132 must be kept around forever. */
133 static GTY(()) VEC(rtx,gc) *used_rtx_array;
135 /* A pointer to the base of a list of incomplete types which might be
136 completed at some later time. incomplete_types_list needs to be a
137 VEC(tree,gc) because we want to tell the garbage collector about
139 static GTY(()) VEC(tree,gc) *incomplete_types;
141 /* A pointer to the base of a table of references to declaration
142 scopes. This table is a display which tracks the nesting
143 of declaration scopes at the current scope and containing
144 scopes. This table is used to find the proper place to
145 define type declaration DIE's. */
146 static GTY(()) VEC(tree,gc) *decl_scope_table;
148 /* Pointers to various DWARF2 sections. */
149 static GTY(()) section *debug_info_section;
150 static GTY(()) section *debug_abbrev_section;
151 static GTY(()) section *debug_aranges_section;
152 static GTY(()) section *debug_macinfo_section;
153 static GTY(()) section *debug_line_section;
154 static GTY(()) section *debug_loc_section;
155 static GTY(()) section *debug_pubnames_section;
156 static GTY(()) section *debug_pubtypes_section;
157 static GTY(()) section *debug_str_section;
158 static GTY(()) section *debug_ranges_section;
159 static GTY(()) section *debug_frame_section;
161 /* Maximum size (in bytes) of an artificially generated label. */
162 #define MAX_ARTIFICIAL_LABEL_BYTES 30
164 /* According to the (draft) DWARF 3 specification, the initial length
165 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
166 bytes are 0xffffffff, followed by the length stored in the next 8
169 However, the SGI/MIPS ABI uses an initial length which is equal to
170 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
172 #ifndef DWARF_INITIAL_LENGTH_SIZE
173 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
176 /* Round SIZE up to the nearest BOUNDARY. */
177 #define DWARF_ROUND(SIZE,BOUNDARY) \
178 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
180 /* CIE identifier. */
181 #if HOST_BITS_PER_WIDE_INT >= 64
182 #define DWARF_CIE_ID \
183 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
185 #define DWARF_CIE_ID DW_CIE_ID
188 DEF_VEC_P (dw_fde_ref);
189 DEF_VEC_ALLOC_P (dw_fde_ref, gc);
191 /* A vector for a table that contains frame description
192 information for each routine. */
193 static GTY(()) VEC(dw_fde_ref, gc) *fde_vec;
195 struct GTY(()) indirect_string_node {
197 unsigned int refcount;
198 enum dwarf_form form;
202 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
204 static GTY(()) int dw2_string_counter;
206 /* True if the compilation unit places functions in more than one section. */
207 static GTY(()) bool have_multiple_function_sections = false;
209 /* Whether the default text and cold text sections have been used at all. */
211 static GTY(()) bool text_section_used = false;
212 static GTY(()) bool cold_text_section_used = false;
214 /* The default cold text section. */
215 static GTY(()) section *cold_text_section;
217 /* Forward declarations for functions defined in this file. */
219 static char *stripattributes (const char *);
220 static void output_call_frame_info (int);
221 static void dwarf2out_note_section_used (void);
223 /* Personality decl of current unit. Used only when assembler does not support
225 static GTY(()) rtx current_unit_personality;
227 /* Data and reference forms for relocatable data. */
228 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
229 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
231 #ifndef DEBUG_FRAME_SECTION
232 #define DEBUG_FRAME_SECTION ".debug_frame"
235 #ifndef FUNC_BEGIN_LABEL
236 #define FUNC_BEGIN_LABEL "LFB"
239 #ifndef FUNC_END_LABEL
240 #define FUNC_END_LABEL "LFE"
243 #ifndef PROLOGUE_END_LABEL
244 #define PROLOGUE_END_LABEL "LPE"
247 #ifndef EPILOGUE_BEGIN_LABEL
248 #define EPILOGUE_BEGIN_LABEL "LEB"
251 #ifndef FRAME_BEGIN_LABEL
252 #define FRAME_BEGIN_LABEL "Lframe"
254 #define CIE_AFTER_SIZE_LABEL "LSCIE"
255 #define CIE_END_LABEL "LECIE"
256 #define FDE_LABEL "LSFDE"
257 #define FDE_AFTER_SIZE_LABEL "LASFDE"
258 #define FDE_END_LABEL "LEFDE"
259 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
260 #define LINE_NUMBER_END_LABEL "LELT"
261 #define LN_PROLOG_AS_LABEL "LASLTP"
262 #define LN_PROLOG_END_LABEL "LELTP"
263 #define DIE_LABEL_PREFIX "DW"
265 /* Match the base name of a file to the base name of a compilation unit. */
268 matches_main_base (const char *path)
270 /* Cache the last query. */
271 static const char *last_path = NULL;
272 static int last_match = 0;
273 if (path != last_path)
276 int length = base_of_path (path, &base);
278 last_match = (length == main_input_baselength
279 && memcmp (base, main_input_basename, length) == 0);
284 #ifdef DEBUG_DEBUG_STRUCT
287 dump_struct_debug (tree type, enum debug_info_usage usage,
288 enum debug_struct_file criterion, int generic,
289 int matches, int result)
291 /* Find the type name. */
292 tree type_decl = TYPE_STUB_DECL (type);
294 const char *name = 0;
295 if (TREE_CODE (t) == TYPE_DECL)
298 name = IDENTIFIER_POINTER (t);
300 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
302 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
303 matches ? "bas" : "hdr",
304 generic ? "gen" : "ord",
305 usage == DINFO_USAGE_DFN ? ";" :
306 usage == DINFO_USAGE_DIR_USE ? "." : "*",
308 (void*) type_decl, name);
311 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
312 dump_struct_debug (type, usage, criterion, generic, matches, result)
316 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
322 should_emit_struct_debug (tree type, enum debug_info_usage usage)
324 enum debug_struct_file criterion;
326 bool generic = lang_hooks.types.generic_p (type);
329 criterion = debug_struct_generic[usage];
331 criterion = debug_struct_ordinary[usage];
333 if (criterion == DINFO_STRUCT_FILE_NONE)
334 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
335 if (criterion == DINFO_STRUCT_FILE_ANY)
336 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
338 type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
340 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
341 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
343 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
344 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
345 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
348 /* Return a pointer to a copy of the section string name S with all
349 attributes stripped off, and an asterisk prepended (for assemble_name). */
352 stripattributes (const char *s)
354 char *stripped = XNEWVEC (char, strlen (s) + 2);
359 while (*s && *s != ',')
366 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
367 switch to the data section instead, and write out a synthetic start label
368 for collect2 the first time around. */
371 switch_to_eh_frame_section (bool back)
375 #ifdef EH_FRAME_SECTION_NAME
376 if (eh_frame_section == 0)
380 if (EH_TABLES_CAN_BE_READ_ONLY)
386 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
388 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
390 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
393 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
394 && (fde_encoding & 0x70) != DW_EH_PE_aligned
395 && (per_encoding & 0x70) != DW_EH_PE_absptr
396 && (per_encoding & 0x70) != DW_EH_PE_aligned
397 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
398 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
399 ? 0 : SECTION_WRITE);
402 flags = SECTION_WRITE;
403 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
405 #endif /* EH_FRAME_SECTION_NAME */
407 if (eh_frame_section)
408 switch_to_section (eh_frame_section);
411 /* We have no special eh_frame section. Put the information in
412 the data section and emit special labels to guide collect2. */
413 switch_to_section (data_section);
417 label = get_file_function_name ("F");
418 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
419 targetm.asm_out.globalize_label (asm_out_file,
420 IDENTIFIER_POINTER (label));
421 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
426 /* Switch [BACK] to the eh or debug frame table section, depending on
430 switch_to_frame_table_section (int for_eh, bool back)
433 switch_to_eh_frame_section (back);
436 if (!debug_frame_section)
437 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
438 SECTION_DEBUG, NULL);
439 switch_to_section (debug_frame_section);
443 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
445 enum dw_cfi_oprnd_type
446 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
451 case DW_CFA_GNU_window_save:
452 case DW_CFA_remember_state:
453 case DW_CFA_restore_state:
454 return dw_cfi_oprnd_unused;
457 case DW_CFA_advance_loc1:
458 case DW_CFA_advance_loc2:
459 case DW_CFA_advance_loc4:
460 case DW_CFA_MIPS_advance_loc8:
461 return dw_cfi_oprnd_addr;
464 case DW_CFA_offset_extended:
466 case DW_CFA_offset_extended_sf:
467 case DW_CFA_def_cfa_sf:
469 case DW_CFA_restore_extended:
470 case DW_CFA_undefined:
471 case DW_CFA_same_value:
472 case DW_CFA_def_cfa_register:
473 case DW_CFA_register:
474 case DW_CFA_expression:
475 return dw_cfi_oprnd_reg_num;
477 case DW_CFA_def_cfa_offset:
478 case DW_CFA_GNU_args_size:
479 case DW_CFA_def_cfa_offset_sf:
480 return dw_cfi_oprnd_offset;
482 case DW_CFA_def_cfa_expression:
483 return dw_cfi_oprnd_loc;
490 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
492 enum dw_cfi_oprnd_type
493 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
498 case DW_CFA_def_cfa_sf:
500 case DW_CFA_offset_extended_sf:
501 case DW_CFA_offset_extended:
502 return dw_cfi_oprnd_offset;
504 case DW_CFA_register:
505 return dw_cfi_oprnd_reg_num;
507 case DW_CFA_expression:
508 return dw_cfi_oprnd_loc;
511 return dw_cfi_oprnd_unused;
515 /* Output one FDE. */
518 output_fde (dw_fde_ref fde, bool for_eh, bool second,
519 char *section_start_label, int fde_encoding, char *augmentation,
520 bool any_lsda_needed, int lsda_encoding)
522 const char *begin, *end;
523 static unsigned int j;
526 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
528 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
530 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
531 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
532 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
533 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
534 " indicating 64-bit DWARF extension");
535 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
537 ASM_OUTPUT_LABEL (asm_out_file, l1);
540 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
542 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
543 debug_frame_section, "FDE CIE offset");
545 begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
546 end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
550 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
551 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
552 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
553 "FDE initial location");
554 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
555 end, begin, "FDE address range");
559 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
560 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
567 int size = size_of_encoded_value (lsda_encoding);
569 if (lsda_encoding == DW_EH_PE_aligned)
571 int offset = ( 4 /* Length */
573 + 2 * size_of_encoded_value (fde_encoding)
574 + 1 /* Augmentation size */ );
575 int pad = -offset & (PTR_SIZE - 1);
578 gcc_assert (size_of_uleb128 (size) == 1);
581 dw2_asm_output_data_uleb128 (size, "Augmentation size");
583 if (fde->uses_eh_lsda)
585 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
586 fde->funcdef_number);
587 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
588 gen_rtx_SYMBOL_REF (Pmode, l1),
590 "Language Specific Data Area");
594 if (lsda_encoding == DW_EH_PE_aligned)
595 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
596 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
597 "Language Specific Data Area (none)");
601 dw2_asm_output_data_uleb128 (0, "Augmentation size");
604 /* Loop through the Call Frame Instructions associated with this FDE. */
605 fde->dw_fde_current_label = begin;
607 size_t from, until, i;
610 until = VEC_length (dw_cfi_ref, fde->dw_fde_cfi);
612 if (fde->dw_fde_second_begin == NULL)
615 until = fde->dw_fde_switch_cfi_index;
617 from = fde->dw_fde_switch_cfi_index;
619 for (i = from; i < until; i++)
620 output_cfi (VEC_index (dw_cfi_ref, fde->dw_fde_cfi, i), fde, for_eh);
623 /* If we are to emit a ref/link from function bodies to their frame tables,
624 do it now. This is typically performed to make sure that tables
625 associated with functions are dragged with them and not discarded in
626 garbage collecting links. We need to do this on a per function basis to
627 cope with -ffunction-sections. */
629 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
630 /* Switch to the function section, emit the ref to the tables, and
631 switch *back* into the table section. */
632 switch_to_section (function_section (fde->decl));
633 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
634 switch_to_frame_table_section (for_eh, true);
637 /* Pad the FDE out to an address sized boundary. */
638 ASM_OUTPUT_ALIGN (asm_out_file,
639 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
640 ASM_OUTPUT_LABEL (asm_out_file, l2);
645 /* Return true if frame description entry FDE is needed for EH. */
648 fde_needed_for_eh_p (dw_fde_ref fde)
650 if (flag_asynchronous_unwind_tables)
653 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
656 if (fde->uses_eh_lsda)
659 /* If exceptions are enabled, we have collected nothrow info. */
660 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
666 /* Output the call frame information used to record information
667 that relates to calculating the frame pointer, and records the
668 location of saved registers. */
671 output_call_frame_info (int for_eh)
676 char l1[20], l2[20], section_start_label[20];
677 bool any_lsda_needed = false;
678 char augmentation[6];
679 int augmentation_size;
680 int fde_encoding = DW_EH_PE_absptr;
681 int per_encoding = DW_EH_PE_absptr;
682 int lsda_encoding = DW_EH_PE_absptr;
684 rtx personality = NULL;
687 /* Don't emit a CIE if there won't be any FDEs. */
691 /* Nothing to do if the assembler's doing it all. */
692 if (dwarf2out_do_cfi_asm ())
695 /* If we don't have any functions we'll want to unwind out of, don't emit
696 any EH unwind information. If we make FDEs linkonce, we may have to
697 emit an empty label for an FDE that wouldn't otherwise be emitted. We
698 want to avoid having an FDE kept around when the function it refers to
699 is discarded. Example where this matters: a primary function template
700 in C++ requires EH information, an explicit specialization doesn't. */
703 bool any_eh_needed = false;
705 FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, i, fde)
707 if (fde->uses_eh_lsda)
708 any_eh_needed = any_lsda_needed = true;
709 else if (fde_needed_for_eh_p (fde))
710 any_eh_needed = true;
711 else if (TARGET_USES_WEAK_UNWIND_INFO)
712 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);
719 /* We're going to be generating comments, so turn on app. */
723 /* Switch to the proper frame section, first time. */
724 switch_to_frame_table_section (for_eh, false);
726 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
727 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
729 /* Output the CIE. */
730 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
731 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
732 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
733 dw2_asm_output_data (4, 0xffffffff,
734 "Initial length escape value indicating 64-bit DWARF extension");
735 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
736 "Length of Common Information Entry");
737 ASM_OUTPUT_LABEL (asm_out_file, l1);
739 /* Now that the CIE pointer is PC-relative for EH,
740 use 0 to identify the CIE. */
741 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
742 (for_eh ? 0 : DWARF_CIE_ID),
743 "CIE Identifier Tag");
745 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
746 use CIE version 1, unless that would produce incorrect results
747 due to overflowing the return register column. */
748 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
750 if (return_reg >= 256 || dwarf_version > 2)
752 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
755 augmentation_size = 0;
757 personality = current_unit_personality;
763 z Indicates that a uleb128 is present to size the
764 augmentation section.
765 L Indicates the encoding (and thus presence) of
766 an LSDA pointer in the FDE augmentation.
767 R Indicates a non-default pointer encoding for
769 P Indicates the presence of an encoding + language
770 personality routine in the CIE augmentation. */
772 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
773 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
774 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
776 p = augmentation + 1;
780 augmentation_size += 1 + size_of_encoded_value (per_encoding);
781 assemble_external_libcall (personality);
786 augmentation_size += 1;
788 if (fde_encoding != DW_EH_PE_absptr)
791 augmentation_size += 1;
793 if (p > augmentation + 1)
795 augmentation[0] = 'z';
799 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
800 if (personality && per_encoding == DW_EH_PE_aligned)
802 int offset = ( 4 /* Length */
804 + 1 /* CIE version */
805 + strlen (augmentation) + 1 /* Augmentation */
806 + size_of_uleb128 (1) /* Code alignment */
807 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
809 + 1 /* Augmentation size */
810 + 1 /* Personality encoding */ );
811 int pad = -offset & (PTR_SIZE - 1);
813 augmentation_size += pad;
815 /* Augmentations should be small, so there's scarce need to
816 iterate for a solution. Die if we exceed one uleb128 byte. */
817 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
821 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
822 if (dw_cie_version >= 4)
824 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
825 dw2_asm_output_data (1, 0, "CIE Segment Size");
827 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
828 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
829 "CIE Data Alignment Factor");
831 if (dw_cie_version == 1)
832 dw2_asm_output_data (1, return_reg, "CIE RA Column");
834 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
838 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
841 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
842 eh_data_format_name (per_encoding));
843 dw2_asm_output_encoded_addr_rtx (per_encoding,
849 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
850 eh_data_format_name (lsda_encoding));
852 if (fde_encoding != DW_EH_PE_absptr)
853 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
854 eh_data_format_name (fde_encoding));
857 FOR_EACH_VEC_ELT (dw_cfi_ref, cie_cfi_vec, i, cfi)
858 output_cfi (cfi, NULL, for_eh);
860 /* Pad the CIE out to an address sized boundary. */
861 ASM_OUTPUT_ALIGN (asm_out_file,
862 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
863 ASM_OUTPUT_LABEL (asm_out_file, l2);
865 /* Loop through all of the FDE's. */
866 FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, i, fde)
870 /* Don't emit EH unwind info for leaf functions that don't need it. */
871 if (for_eh && !fde_needed_for_eh_p (fde))
874 for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
875 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
876 augmentation, any_lsda_needed, lsda_encoding);
879 if (for_eh && targetm.terminate_dw2_eh_frame_info)
880 dw2_asm_output_data (4, 0, "End of Table");
881 #ifdef MIPS_DEBUGGING_INFO
882 /* Work around Irix 6 assembler bug whereby labels at the end of a section
883 get a value of 0. Putting .align 0 after the label fixes it. */
884 ASM_OUTPUT_ALIGN (asm_out_file, 0);
887 /* Turn off app to make assembly quicker. */
892 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
895 dwarf2out_do_cfi_startproc (bool second)
899 rtx personality = get_personality_function (current_function_decl);
901 fprintf (asm_out_file, "\t.cfi_startproc\n");
905 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
908 /* ??? The GAS support isn't entirely consistent. We have to
909 handle indirect support ourselves, but PC-relative is done
910 in the assembler. Further, the assembler can't handle any
911 of the weirder relocation types. */
912 if (enc & DW_EH_PE_indirect)
913 ref = dw2_force_const_mem (ref, true);
915 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
916 output_addr_const (asm_out_file, ref);
917 fputc ('\n', asm_out_file);
920 if (crtl->uses_eh_lsda)
924 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
925 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
926 current_function_funcdef_no);
927 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
928 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
930 if (enc & DW_EH_PE_indirect)
931 ref = dw2_force_const_mem (ref, true);
933 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
934 output_addr_const (asm_out_file, ref);
935 fputc ('\n', asm_out_file);
939 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
940 this allocation may be done before pass_final. */
943 dwarf2out_alloc_current_fde (void)
947 fde = ggc_alloc_cleared_dw_fde_node ();
948 fde->decl = current_function_decl;
949 fde->funcdef_number = current_function_funcdef_no;
950 fde->fde_index = VEC_length (dw_fde_ref, fde_vec);
951 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
952 fde->uses_eh_lsda = crtl->uses_eh_lsda;
953 fde->nothrow = crtl->nothrow;
954 fde->drap_reg = INVALID_REGNUM;
955 fde->vdrap_reg = INVALID_REGNUM;
957 /* Record the FDE associated with this function. */
959 VEC_safe_push (dw_fde_ref, gc, fde_vec, fde);
964 /* Output a marker (i.e. a label) for the beginning of a function, before
968 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
969 const char *file ATTRIBUTE_UNUSED)
971 char label[MAX_ARTIFICIAL_LABEL_BYTES];
977 current_function_func_begin_label = NULL;
979 do_frame = dwarf2out_do_frame ();
981 /* ??? current_function_func_begin_label is also used by except.c for
982 call-site information. We must emit this label if it might be used. */
985 || targetm_common.except_unwind_info (&global_options) != UI_TARGET))
988 fnsec = function_section (current_function_decl);
989 switch_to_section (fnsec);
990 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
991 current_function_funcdef_no);
992 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
993 current_function_funcdef_no);
994 dup_label = xstrdup (label);
995 current_function_func_begin_label = dup_label;
997 /* We can elide the fde allocation if we're not emitting debug info. */
1001 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1002 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1003 would include pass_dwarf2_frame. If we've not created the FDE yet,
1007 fde = dwarf2out_alloc_current_fde ();
1009 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1010 fde->dw_fde_begin = dup_label;
1011 fde->dw_fde_current_label = dup_label;
1012 fde->in_std_section = (fnsec == text_section
1013 || (cold_text_section && fnsec == cold_text_section));
1015 /* We only want to output line number information for the genuine dwarf2
1016 prologue case, not the eh frame case. */
1017 #ifdef DWARF2_DEBUGGING_INFO
1019 dwarf2out_source_line (line, file, 0, true);
1022 if (dwarf2out_do_cfi_asm ())
1023 dwarf2out_do_cfi_startproc (false);
1026 rtx personality = get_personality_function (current_function_decl);
1027 if (!current_unit_personality)
1028 current_unit_personality = personality;
1030 /* We cannot keep a current personality per function as without CFI
1031 asm, at the point where we emit the CFI data, there is no current
1032 function anymore. */
1033 if (personality && current_unit_personality != personality)
1034 sorry ("multiple EH personalities are supported only with assemblers "
1035 "supporting .cfi_personality directive");
1039 /* Output a marker (i.e. a label) for the end of the generated code
1040 for a function prologue. This gets called *after* the prologue code has
1044 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
1045 const char *file ATTRIBUTE_UNUSED)
1047 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1049 /* Output a label to mark the endpoint of the code generated for this
1051 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
1052 current_function_funcdef_no);
1053 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
1054 current_function_funcdef_no);
1055 cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
1058 /* Output a marker (i.e. a label) for the beginning of the generated code
1059 for a function epilogue. This gets called *before* the prologue code has
1063 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1064 const char *file ATTRIBUTE_UNUSED)
1066 dw_fde_ref fde = cfun->fde;
1067 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1069 if (fde->dw_fde_vms_begin_epilogue)
1072 /* Output a label to mark the endpoint of the code generated for this
1074 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
1075 current_function_funcdef_no);
1076 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
1077 current_function_funcdef_no);
1078 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
1081 /* Output a marker (i.e. a label) for the absolute end of the generated code
1082 for a function definition. This gets called *after* the epilogue code has
1086 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1087 const char *file ATTRIBUTE_UNUSED)
1090 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1092 last_var_location_insn = NULL_RTX;
1094 if (dwarf2out_do_cfi_asm ())
1095 fprintf (asm_out_file, "\t.cfi_endproc\n");
1097 /* Output a label to mark the endpoint of the code generated for this
1099 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1100 current_function_funcdef_no);
1101 ASM_OUTPUT_LABEL (asm_out_file, label);
1103 gcc_assert (fde != NULL);
1104 if (fde->dw_fde_second_begin == NULL)
1105 fde->dw_fde_end = xstrdup (label);
1109 dwarf2out_frame_finish (void)
1111 /* Output call frame information. */
1112 if (targetm.debug_unwind_info () == UI_DWARF2)
1113 output_call_frame_info (0);
1115 /* Output another copy for the unwinder. */
1116 if ((flag_unwind_tables || flag_exceptions)
1117 && targetm_common.except_unwind_info (&global_options) == UI_DWARF2)
1118 output_call_frame_info (1);
1121 /* Note that the current function section is being used for code. */
1124 dwarf2out_note_section_used (void)
1126 section *sec = current_function_section ();
1127 if (sec == text_section)
1128 text_section_used = true;
1129 else if (sec == cold_text_section)
1130 cold_text_section_used = true;
1133 static void var_location_switch_text_section (void);
1134 static void set_cur_line_info_table (section *);
1137 dwarf2out_switch_text_section (void)
1140 dw_fde_ref fde = cfun->fde;
1142 gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
1144 if (!in_cold_section_p)
1146 fde->dw_fde_end = crtl->subsections.cold_section_end_label;
1147 fde->dw_fde_second_begin = crtl->subsections.hot_section_label;
1148 fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
1152 fde->dw_fde_end = crtl->subsections.hot_section_end_label;
1153 fde->dw_fde_second_begin = crtl->subsections.cold_section_label;
1154 fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
1156 have_multiple_function_sections = true;
1158 /* There is no need to mark used sections when not debugging. */
1159 if (cold_text_section != NULL)
1160 dwarf2out_note_section_used ();
1162 if (dwarf2out_do_cfi_asm ())
1163 fprintf (asm_out_file, "\t.cfi_endproc\n");
1165 /* Now do the real section switch. */
1166 sect = current_function_section ();
1167 switch_to_section (sect);
1169 fde->second_in_std_section
1170 = (sect == text_section
1171 || (cold_text_section && sect == cold_text_section));
1173 if (dwarf2out_do_cfi_asm ())
1174 dwarf2out_do_cfi_startproc (true);
1176 var_location_switch_text_section ();
1178 set_cur_line_info_table (sect);
1181 /* And now, the subset of the debugging information support code necessary
1182 for emitting location expressions. */
1184 /* Data about a single source file. */
1185 struct GTY(()) dwarf_file_data {
1186 const char * filename;
1190 typedef struct GTY(()) deferred_locations_struct
1194 } deferred_locations;
1196 DEF_VEC_O(deferred_locations);
1197 DEF_VEC_ALLOC_O(deferred_locations,gc);
1199 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
1201 DEF_VEC_P(dw_die_ref);
1202 DEF_VEC_ALLOC_P(dw_die_ref,heap);
1204 /* Location lists are ranges + location descriptions for that range,
1205 so you can track variables that are in different places over
1206 their entire life. */
1207 typedef struct GTY(()) dw_loc_list_struct {
1208 dw_loc_list_ref dw_loc_next;
1209 const char *begin; /* Label for begin address of range */
1210 const char *end; /* Label for end address of range */
1211 char *ll_symbol; /* Label for beginning of location list.
1212 Only on head of list */
1213 const char *section; /* Section this loclist is relative to */
1214 dw_loc_descr_ref expr;
1216 /* True if all addresses in this and subsequent lists are known to be
1219 /* True if this list has been replaced by dw_loc_next. */
1222 /* True if the range should be emitted even if begin and end
1227 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
1229 /* Convert a DWARF stack opcode into its string name. */
1232 dwarf_stack_op_name (unsigned int op)
1237 return "DW_OP_addr";
1239 return "DW_OP_deref";
1241 return "DW_OP_const1u";
1243 return "DW_OP_const1s";
1245 return "DW_OP_const2u";
1247 return "DW_OP_const2s";
1249 return "DW_OP_const4u";
1251 return "DW_OP_const4s";
1253 return "DW_OP_const8u";
1255 return "DW_OP_const8s";
1257 return "DW_OP_constu";
1259 return "DW_OP_consts";
1263 return "DW_OP_drop";
1265 return "DW_OP_over";
1267 return "DW_OP_pick";
1269 return "DW_OP_swap";
1273 return "DW_OP_xderef";
1281 return "DW_OP_minus";
1293 return "DW_OP_plus";
1294 case DW_OP_plus_uconst:
1295 return "DW_OP_plus_uconst";
1301 return "DW_OP_shra";
1319 return "DW_OP_skip";
1321 return "DW_OP_lit0";
1323 return "DW_OP_lit1";
1325 return "DW_OP_lit2";
1327 return "DW_OP_lit3";
1329 return "DW_OP_lit4";
1331 return "DW_OP_lit5";
1333 return "DW_OP_lit6";
1335 return "DW_OP_lit7";
1337 return "DW_OP_lit8";
1339 return "DW_OP_lit9";
1341 return "DW_OP_lit10";
1343 return "DW_OP_lit11";
1345 return "DW_OP_lit12";
1347 return "DW_OP_lit13";
1349 return "DW_OP_lit14";
1351 return "DW_OP_lit15";
1353 return "DW_OP_lit16";
1355 return "DW_OP_lit17";
1357 return "DW_OP_lit18";
1359 return "DW_OP_lit19";
1361 return "DW_OP_lit20";
1363 return "DW_OP_lit21";
1365 return "DW_OP_lit22";
1367 return "DW_OP_lit23";
1369 return "DW_OP_lit24";
1371 return "DW_OP_lit25";
1373 return "DW_OP_lit26";
1375 return "DW_OP_lit27";
1377 return "DW_OP_lit28";
1379 return "DW_OP_lit29";
1381 return "DW_OP_lit30";
1383 return "DW_OP_lit31";
1385 return "DW_OP_reg0";
1387 return "DW_OP_reg1";
1389 return "DW_OP_reg2";
1391 return "DW_OP_reg3";
1393 return "DW_OP_reg4";
1395 return "DW_OP_reg5";
1397 return "DW_OP_reg6";
1399 return "DW_OP_reg7";
1401 return "DW_OP_reg8";
1403 return "DW_OP_reg9";
1405 return "DW_OP_reg10";
1407 return "DW_OP_reg11";
1409 return "DW_OP_reg12";
1411 return "DW_OP_reg13";
1413 return "DW_OP_reg14";
1415 return "DW_OP_reg15";
1417 return "DW_OP_reg16";
1419 return "DW_OP_reg17";
1421 return "DW_OP_reg18";
1423 return "DW_OP_reg19";
1425 return "DW_OP_reg20";
1427 return "DW_OP_reg21";
1429 return "DW_OP_reg22";
1431 return "DW_OP_reg23";
1433 return "DW_OP_reg24";
1435 return "DW_OP_reg25";
1437 return "DW_OP_reg26";
1439 return "DW_OP_reg27";
1441 return "DW_OP_reg28";
1443 return "DW_OP_reg29";
1445 return "DW_OP_reg30";
1447 return "DW_OP_reg31";
1449 return "DW_OP_breg0";
1451 return "DW_OP_breg1";
1453 return "DW_OP_breg2";
1455 return "DW_OP_breg3";
1457 return "DW_OP_breg4";
1459 return "DW_OP_breg5";
1461 return "DW_OP_breg6";
1463 return "DW_OP_breg7";
1465 return "DW_OP_breg8";
1467 return "DW_OP_breg9";
1469 return "DW_OP_breg10";
1471 return "DW_OP_breg11";
1473 return "DW_OP_breg12";
1475 return "DW_OP_breg13";
1477 return "DW_OP_breg14";
1479 return "DW_OP_breg15";
1481 return "DW_OP_breg16";
1483 return "DW_OP_breg17";
1485 return "DW_OP_breg18";
1487 return "DW_OP_breg19";
1489 return "DW_OP_breg20";
1491 return "DW_OP_breg21";
1493 return "DW_OP_breg22";
1495 return "DW_OP_breg23";
1497 return "DW_OP_breg24";
1499 return "DW_OP_breg25";
1501 return "DW_OP_breg26";
1503 return "DW_OP_breg27";
1505 return "DW_OP_breg28";
1507 return "DW_OP_breg29";
1509 return "DW_OP_breg30";
1511 return "DW_OP_breg31";
1513 return "DW_OP_regx";
1515 return "DW_OP_fbreg";
1517 return "DW_OP_bregx";
1519 return "DW_OP_piece";
1520 case DW_OP_deref_size:
1521 return "DW_OP_deref_size";
1522 case DW_OP_xderef_size:
1523 return "DW_OP_xderef_size";
1527 case DW_OP_push_object_address:
1528 return "DW_OP_push_object_address";
1530 return "DW_OP_call2";
1532 return "DW_OP_call4";
1533 case DW_OP_call_ref:
1534 return "DW_OP_call_ref";
1535 case DW_OP_implicit_value:
1536 return "DW_OP_implicit_value";
1537 case DW_OP_stack_value:
1538 return "DW_OP_stack_value";
1539 case DW_OP_form_tls_address:
1540 return "DW_OP_form_tls_address";
1541 case DW_OP_call_frame_cfa:
1542 return "DW_OP_call_frame_cfa";
1543 case DW_OP_bit_piece:
1544 return "DW_OP_bit_piece";
1546 case DW_OP_GNU_push_tls_address:
1547 return "DW_OP_GNU_push_tls_address";
1548 case DW_OP_GNU_uninit:
1549 return "DW_OP_GNU_uninit";
1550 case DW_OP_GNU_encoded_addr:
1551 return "DW_OP_GNU_encoded_addr";
1552 case DW_OP_GNU_implicit_pointer:
1553 return "DW_OP_GNU_implicit_pointer";
1554 case DW_OP_GNU_entry_value:
1555 return "DW_OP_GNU_entry_value";
1556 case DW_OP_GNU_const_type:
1557 return "DW_OP_GNU_const_type";
1558 case DW_OP_GNU_regval_type:
1559 return "DW_OP_GNU_regval_type";
1560 case DW_OP_GNU_deref_type:
1561 return "DW_OP_GNU_deref_type";
1562 case DW_OP_GNU_convert:
1563 return "DW_OP_GNU_convert";
1564 case DW_OP_GNU_reinterpret:
1565 return "DW_OP_GNU_reinterpret";
1566 case DW_OP_GNU_parameter_ref:
1567 return "DW_OP_GNU_parameter_ref";
1570 return "OP_<unknown>";
1574 /* Return a pointer to a newly allocated location description. Location
1575 descriptions are simple expression terms that can be strung
1576 together to form more complicated location (address) descriptions. */
1578 static inline dw_loc_descr_ref
1579 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
1580 unsigned HOST_WIDE_INT oprnd2)
1582 dw_loc_descr_ref descr = ggc_alloc_cleared_dw_loc_descr_node ();
1584 descr->dw_loc_opc = op;
1585 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
1586 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
1587 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
1588 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
1593 /* Return a pointer to a newly allocated location description for
1596 static inline dw_loc_descr_ref
1597 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
1600 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
1603 return new_loc_descr (DW_OP_bregx, reg, offset);
1606 /* Add a location description term to a location description expression. */
1609 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
1611 dw_loc_descr_ref *d;
1613 /* Find the end of the chain. */
1614 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
1620 /* Compare two location operands for exact equality. */
1623 dw_val_equal_p (dw_val_node *a, dw_val_node *b)
1625 if (a->val_class != b->val_class)
1627 switch (a->val_class)
1629 case dw_val_class_none:
1631 case dw_val_class_addr:
1632 return rtx_equal_p (a->v.val_addr, b->v.val_addr);
1634 case dw_val_class_offset:
1635 case dw_val_class_unsigned_const:
1636 case dw_val_class_const:
1637 case dw_val_class_range_list:
1638 case dw_val_class_lineptr:
1639 case dw_val_class_macptr:
1640 /* These are all HOST_WIDE_INT, signed or unsigned. */
1641 return a->v.val_unsigned == b->v.val_unsigned;
1643 case dw_val_class_loc:
1644 return a->v.val_loc == b->v.val_loc;
1645 case dw_val_class_loc_list:
1646 return a->v.val_loc_list == b->v.val_loc_list;
1647 case dw_val_class_die_ref:
1648 return a->v.val_die_ref.die == b->v.val_die_ref.die;
1649 case dw_val_class_fde_ref:
1650 return a->v.val_fde_index == b->v.val_fde_index;
1651 case dw_val_class_lbl_id:
1652 return strcmp (a->v.val_lbl_id, b->v.val_lbl_id) == 0;
1653 case dw_val_class_str:
1654 return a->v.val_str == b->v.val_str;
1655 case dw_val_class_flag:
1656 return a->v.val_flag == b->v.val_flag;
1657 case dw_val_class_file:
1658 return a->v.val_file == b->v.val_file;
1659 case dw_val_class_decl_ref:
1660 return a->v.val_decl_ref == b->v.val_decl_ref;
1662 case dw_val_class_const_double:
1663 return (a->v.val_double.high == b->v.val_double.high
1664 && a->v.val_double.low == b->v.val_double.low);
1666 case dw_val_class_vec:
1668 size_t a_len = a->v.val_vec.elt_size * a->v.val_vec.length;
1669 size_t b_len = b->v.val_vec.elt_size * b->v.val_vec.length;
1671 return (a_len == b_len
1672 && !memcmp (a->v.val_vec.array, b->v.val_vec.array, a_len));
1675 case dw_val_class_data8:
1676 return memcmp (a->v.val_data8, b->v.val_data8, 8) == 0;
1678 case dw_val_class_vms_delta:
1679 return (!strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1)
1680 && !strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1));
1685 /* Compare two location atoms for exact equality. */
1688 loc_descr_equal_p_1 (dw_loc_descr_ref a, dw_loc_descr_ref b)
1690 if (a->dw_loc_opc != b->dw_loc_opc)
1693 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1694 address size, but since we always allocate cleared storage it
1695 should be zero for other types of locations. */
1696 if (a->dtprel != b->dtprel)
1699 return (dw_val_equal_p (&a->dw_loc_oprnd1, &b->dw_loc_oprnd1)
1700 && dw_val_equal_p (&a->dw_loc_oprnd2, &b->dw_loc_oprnd2));
1703 /* Compare two complete location expressions for exact equality. */
1706 loc_descr_equal_p (dw_loc_descr_ref a, dw_loc_descr_ref b)
1712 if (a == NULL || b == NULL)
1714 if (!loc_descr_equal_p_1 (a, b))
1723 /* Add a constant OFFSET to a location expression. */
1726 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
1728 dw_loc_descr_ref loc;
1731 gcc_assert (*list_head != NULL);
1736 /* Find the end of the chain. */
1737 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
1741 if (loc->dw_loc_opc == DW_OP_fbreg
1742 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
1743 p = &loc->dw_loc_oprnd1.v.val_int;
1744 else if (loc->dw_loc_opc == DW_OP_bregx)
1745 p = &loc->dw_loc_oprnd2.v.val_int;
1747 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1748 offset. Don't optimize if an signed integer overflow would happen. */
1750 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
1751 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
1754 else if (offset > 0)
1755 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
1759 loc->dw_loc_next = int_loc_descriptor (-offset);
1760 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
1764 /* Add a constant OFFSET to a location list. */
1767 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
1770 for (d = list_head; d != NULL; d = d->dw_loc_next)
1771 loc_descr_plus_const (&d->expr, offset);
1774 #define DWARF_REF_SIZE \
1775 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1777 static unsigned long int get_base_type_offset (dw_die_ref);
1779 /* Return the size of a location descriptor. */
1781 static unsigned long
1782 size_of_loc_descr (dw_loc_descr_ref loc)
1784 unsigned long size = 1;
1786 switch (loc->dw_loc_opc)
1789 size += DWARF2_ADDR_SIZE;
1808 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1811 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1816 case DW_OP_plus_uconst:
1817 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1855 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1858 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1861 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1864 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1865 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1868 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1870 case DW_OP_bit_piece:
1871 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1872 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
1874 case DW_OP_deref_size:
1875 case DW_OP_xderef_size:
1884 case DW_OP_call_ref:
1885 size += DWARF_REF_SIZE;
1887 case DW_OP_implicit_value:
1888 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1889 + loc->dw_loc_oprnd1.v.val_unsigned;
1891 case DW_OP_GNU_implicit_pointer:
1892 size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1894 case DW_OP_GNU_entry_value:
1896 unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
1897 size += size_of_uleb128 (op_size) + op_size;
1900 case DW_OP_GNU_const_type:
1903 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1904 size += size_of_uleb128 (o) + 1;
1905 switch (loc->dw_loc_oprnd2.val_class)
1907 case dw_val_class_vec:
1908 size += loc->dw_loc_oprnd2.v.val_vec.length
1909 * loc->dw_loc_oprnd2.v.val_vec.elt_size;
1911 case dw_val_class_const:
1912 size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1914 case dw_val_class_const_double:
1915 size += 2 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1922 case DW_OP_GNU_regval_type:
1925 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1926 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1927 + size_of_uleb128 (o);
1930 case DW_OP_GNU_deref_type:
1933 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1934 size += 1 + size_of_uleb128 (o);
1937 case DW_OP_GNU_convert:
1938 case DW_OP_GNU_reinterpret:
1939 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
1940 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1944 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1945 size += size_of_uleb128 (o);
1948 case DW_OP_GNU_parameter_ref:
1958 /* Return the size of a series of location descriptors. */
1961 size_of_locs (dw_loc_descr_ref loc)
1966 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1967 field, to avoid writing to a PCH file. */
1968 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1970 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
1972 size += size_of_loc_descr (l);
1977 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1979 l->dw_loc_addr = size;
1980 size += size_of_loc_descr (l);
1986 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
1987 static void get_ref_die_offset_label (char *, dw_die_ref);
1988 static unsigned long int get_ref_die_offset (dw_die_ref);
1990 /* Output location description stack opcode's operands (if any).
1991 The for_eh_or_skip parameter controls whether register numbers are
1992 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1993 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1994 info). This should be suppressed for the cases that have not been converted
1995 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1998 output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
2000 dw_val_ref val1 = &loc->dw_loc_oprnd1;
2001 dw_val_ref val2 = &loc->dw_loc_oprnd2;
2003 switch (loc->dw_loc_opc)
2005 #ifdef DWARF2_DEBUGGING_INFO
2008 dw2_asm_output_data (2, val1->v.val_int, NULL);
2013 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
2014 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
2016 fputc ('\n', asm_out_file);
2021 dw2_asm_output_data (4, val1->v.val_int, NULL);
2026 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
2027 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
2029 fputc ('\n', asm_out_file);
2034 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2035 dw2_asm_output_data (8, val1->v.val_int, NULL);
2042 gcc_assert (val1->val_class == dw_val_class_loc);
2043 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2045 dw2_asm_output_data (2, offset, NULL);
2048 case DW_OP_implicit_value:
2049 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2050 switch (val2->val_class)
2052 case dw_val_class_const:
2053 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
2055 case dw_val_class_vec:
2057 unsigned int elt_size = val2->v.val_vec.elt_size;
2058 unsigned int len = val2->v.val_vec.length;
2062 if (elt_size > sizeof (HOST_WIDE_INT))
2067 for (i = 0, p = val2->v.val_vec.array;
2070 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2071 "fp or vector constant word %u", i);
2074 case dw_val_class_const_double:
2076 unsigned HOST_WIDE_INT first, second;
2078 if (WORDS_BIG_ENDIAN)
2080 first = val2->v.val_double.high;
2081 second = val2->v.val_double.low;
2085 first = val2->v.val_double.low;
2086 second = val2->v.val_double.high;
2088 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2090 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2094 case dw_val_class_addr:
2095 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
2096 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
2111 case DW_OP_implicit_value:
2112 /* We currently don't make any attempt to make sure these are
2113 aligned properly like we do for the main unwind info, so
2114 don't support emitting things larger than a byte if we're
2115 only doing unwinding. */
2120 dw2_asm_output_data (1, val1->v.val_int, NULL);
2123 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2126 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2129 dw2_asm_output_data (1, val1->v.val_int, NULL);
2131 case DW_OP_plus_uconst:
2132 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2166 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2170 unsigned r = val1->v.val_unsigned;
2171 if (for_eh_or_skip >= 0)
2172 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2173 gcc_assert (size_of_uleb128 (r)
2174 == size_of_uleb128 (val1->v.val_unsigned));
2175 dw2_asm_output_data_uleb128 (r, NULL);
2179 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2183 unsigned r = val1->v.val_unsigned;
2184 if (for_eh_or_skip >= 0)
2185 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2186 gcc_assert (size_of_uleb128 (r)
2187 == size_of_uleb128 (val1->v.val_unsigned));
2188 dw2_asm_output_data_uleb128 (r, NULL);
2189 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2193 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2195 case DW_OP_bit_piece:
2196 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2197 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
2199 case DW_OP_deref_size:
2200 case DW_OP_xderef_size:
2201 dw2_asm_output_data (1, val1->v.val_int, NULL);
2207 if (targetm.asm_out.output_dwarf_dtprel)
2209 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
2212 fputc ('\n', asm_out_file);
2219 #ifdef DWARF2_DEBUGGING_INFO
2220 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2227 case DW_OP_GNU_implicit_pointer:
2229 char label[MAX_ARTIFICIAL_LABEL_BYTES
2230 + HOST_BITS_PER_WIDE_INT / 2 + 2];
2231 gcc_assert (val1->val_class == dw_val_class_die_ref);
2232 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2233 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2234 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2238 case DW_OP_GNU_entry_value:
2239 dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
2240 output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
2243 case DW_OP_GNU_const_type:
2245 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
2247 dw2_asm_output_data_uleb128 (o, NULL);
2248 switch (val2->val_class)
2250 case dw_val_class_const:
2251 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2252 dw2_asm_output_data (1, l, NULL);
2253 dw2_asm_output_data (l, val2->v.val_int, NULL);
2255 case dw_val_class_vec:
2257 unsigned int elt_size = val2->v.val_vec.elt_size;
2258 unsigned int len = val2->v.val_vec.length;
2263 dw2_asm_output_data (1, l, NULL);
2264 if (elt_size > sizeof (HOST_WIDE_INT))
2269 for (i = 0, p = val2->v.val_vec.array;
2272 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2273 "fp or vector constant word %u", i);
2276 case dw_val_class_const_double:
2278 unsigned HOST_WIDE_INT first, second;
2279 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2281 dw2_asm_output_data (1, 2 * l, NULL);
2282 if (WORDS_BIG_ENDIAN)
2284 first = val2->v.val_double.high;
2285 second = val2->v.val_double.low;
2289 first = val2->v.val_double.low;
2290 second = val2->v.val_double.high;
2292 dw2_asm_output_data (l, first, NULL);
2293 dw2_asm_output_data (l, second, NULL);
2301 case DW_OP_GNU_regval_type:
2303 unsigned r = val1->v.val_unsigned;
2304 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2306 if (for_eh_or_skip >= 0)
2308 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2309 gcc_assert (size_of_uleb128 (r)
2310 == size_of_uleb128 (val1->v.val_unsigned));
2312 dw2_asm_output_data_uleb128 (r, NULL);
2313 dw2_asm_output_data_uleb128 (o, NULL);
2316 case DW_OP_GNU_deref_type:
2318 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2320 dw2_asm_output_data (1, val1->v.val_int, NULL);
2321 dw2_asm_output_data_uleb128 (o, NULL);
2324 case DW_OP_GNU_convert:
2325 case DW_OP_GNU_reinterpret:
2326 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
2327 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2330 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
2332 dw2_asm_output_data_uleb128 (o, NULL);
2336 case DW_OP_GNU_parameter_ref:
2339 gcc_assert (val1->val_class == dw_val_class_die_ref);
2340 o = get_ref_die_offset (val1->v.val_die_ref.die);
2341 dw2_asm_output_data (4, o, NULL);
2346 /* Other codes have no operands. */
2351 /* Output a sequence of location operations.
2352 The for_eh_or_skip parameter controls whether register numbers are
2353 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2354 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2355 info). This should be suppressed for the cases that have not been converted
2356 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2359 output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
2361 for (; loc != NULL; loc = loc->dw_loc_next)
2363 enum dwarf_location_atom opc = loc->dw_loc_opc;
2364 /* Output the opcode. */
2365 if (for_eh_or_skip >= 0
2366 && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2368 unsigned r = (opc - DW_OP_breg0);
2369 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2370 gcc_assert (r <= 31);
2371 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2373 else if (for_eh_or_skip >= 0
2374 && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2376 unsigned r = (opc - DW_OP_reg0);
2377 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2378 gcc_assert (r <= 31);
2379 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2382 dw2_asm_output_data (1, opc,
2383 "%s", dwarf_stack_op_name (opc));
2385 /* Output the operand(s) (if any). */
2386 output_loc_operands (loc, for_eh_or_skip);
2390 /* Output location description stack opcode's operands (if any).
2391 The output is single bytes on a line, suitable for .cfi_escape. */
2394 output_loc_operands_raw (dw_loc_descr_ref loc)
2396 dw_val_ref val1 = &loc->dw_loc_oprnd1;
2397 dw_val_ref val2 = &loc->dw_loc_oprnd2;
2399 switch (loc->dw_loc_opc)
2402 case DW_OP_implicit_value:
2403 /* We cannot output addresses in .cfi_escape, only bytes. */
2409 case DW_OP_deref_size:
2410 case DW_OP_xderef_size:
2411 fputc (',', asm_out_file);
2412 dw2_asm_output_data_raw (1, val1->v.val_int);
2417 fputc (',', asm_out_file);
2418 dw2_asm_output_data_raw (2, val1->v.val_int);
2423 fputc (',', asm_out_file);
2424 dw2_asm_output_data_raw (4, val1->v.val_int);
2429 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2430 fputc (',', asm_out_file);
2431 dw2_asm_output_data_raw (8, val1->v.val_int);
2439 gcc_assert (val1->val_class == dw_val_class_loc);
2440 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2442 fputc (',', asm_out_file);
2443 dw2_asm_output_data_raw (2, offset);
2449 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2450 gcc_assert (size_of_uleb128 (r)
2451 == size_of_uleb128 (val1->v.val_unsigned));
2452 fputc (',', asm_out_file);
2453 dw2_asm_output_data_uleb128_raw (r);
2458 case DW_OP_plus_uconst:
2460 fputc (',', asm_out_file);
2461 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2464 case DW_OP_bit_piece:
2465 fputc (',', asm_out_file);
2466 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2467 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
2504 fputc (',', asm_out_file);
2505 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
2510 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2511 gcc_assert (size_of_uleb128 (r)
2512 == size_of_uleb128 (val1->v.val_unsigned));
2513 fputc (',', asm_out_file);
2514 dw2_asm_output_data_uleb128_raw (r);
2515 fputc (',', asm_out_file);
2516 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
2520 case DW_OP_GNU_implicit_pointer:
2521 case DW_OP_GNU_entry_value:
2522 case DW_OP_GNU_const_type:
2523 case DW_OP_GNU_regval_type:
2524 case DW_OP_GNU_deref_type:
2525 case DW_OP_GNU_convert:
2526 case DW_OP_GNU_reinterpret:
2527 case DW_OP_GNU_parameter_ref:
2532 /* Other codes have no operands. */
2538 output_loc_sequence_raw (dw_loc_descr_ref loc)
2542 enum dwarf_location_atom opc = loc->dw_loc_opc;
2543 /* Output the opcode. */
2544 if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2546 unsigned r = (opc - DW_OP_breg0);
2547 r = DWARF2_FRAME_REG_OUT (r, 1);
2548 gcc_assert (r <= 31);
2549 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2551 else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2553 unsigned r = (opc - DW_OP_reg0);
2554 r = DWARF2_FRAME_REG_OUT (r, 1);
2555 gcc_assert (r <= 31);
2556 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2558 /* Output the opcode. */
2559 fprintf (asm_out_file, "%#x", opc);
2560 output_loc_operands_raw (loc);
2562 if (!loc->dw_loc_next)
2564 loc = loc->dw_loc_next;
2566 fputc (',', asm_out_file);
2570 /* This function builds a dwarf location descriptor sequence from a
2571 dw_cfa_location, adding the given OFFSET to the result of the
2574 struct dw_loc_descr_struct *
2575 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
2577 struct dw_loc_descr_struct *head, *tmp;
2579 offset += cfa->offset;
2583 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
2584 head->dw_loc_oprnd1.val_class = dw_val_class_const;
2585 tmp = new_loc_descr (DW_OP_deref, 0, 0);
2586 add_loc_descr (&head, tmp);
2589 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
2590 add_loc_descr (&head, tmp);
2594 head = new_reg_loc_descr (cfa->reg, offset);
2599 /* This function builds a dwarf location descriptor sequence for
2600 the address at OFFSET from the CFA when stack is aligned to
2603 struct dw_loc_descr_struct *
2604 build_cfa_aligned_loc (dw_cfa_location *cfa,
2605 HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
2607 struct dw_loc_descr_struct *head;
2608 unsigned int dwarf_fp
2609 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
2611 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2612 if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0)
2614 head = new_reg_loc_descr (dwarf_fp, 0);
2615 add_loc_descr (&head, int_loc_descriptor (alignment));
2616 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
2617 loc_descr_plus_const (&head, offset);
2620 head = new_reg_loc_descr (dwarf_fp, offset);
2624 /* And now, the support for symbolic debugging information. */
2626 /* .debug_str support. */
2627 static int output_indirect_string (void **, void *);
2629 static void dwarf2out_init (const char *);
2630 static void dwarf2out_finish (const char *);
2631 static void dwarf2out_assembly_start (void);
2632 static void dwarf2out_define (unsigned int, const char *);
2633 static void dwarf2out_undef (unsigned int, const char *);
2634 static void dwarf2out_start_source_file (unsigned, const char *);
2635 static void dwarf2out_end_source_file (unsigned);
2636 static void dwarf2out_function_decl (tree);
2637 static void dwarf2out_begin_block (unsigned, unsigned);
2638 static void dwarf2out_end_block (unsigned, unsigned);
2639 static bool dwarf2out_ignore_block (const_tree);
2640 static void dwarf2out_global_decl (tree);
2641 static void dwarf2out_type_decl (tree, int);
2642 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
2643 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
2645 static void dwarf2out_abstract_function (tree);
2646 static void dwarf2out_var_location (rtx);
2647 static void dwarf2out_begin_function (tree);
2648 static void dwarf2out_set_name (tree, tree);
2650 /* The debug hooks structure. */
2652 const struct gcc_debug_hooks dwarf2_debug_hooks =
2656 dwarf2out_assembly_start,
2659 dwarf2out_start_source_file,
2660 dwarf2out_end_source_file,
2661 dwarf2out_begin_block,
2662 dwarf2out_end_block,
2663 dwarf2out_ignore_block,
2664 dwarf2out_source_line,
2665 dwarf2out_begin_prologue,
2666 #if VMS_DEBUGGING_INFO
2667 dwarf2out_vms_end_prologue,
2668 dwarf2out_vms_begin_epilogue,
2670 debug_nothing_int_charstar,
2671 debug_nothing_int_charstar,
2673 dwarf2out_end_epilogue,
2674 dwarf2out_begin_function,
2675 debug_nothing_int, /* end_function */
2676 dwarf2out_function_decl, /* function_decl */
2677 dwarf2out_global_decl,
2678 dwarf2out_type_decl, /* type_decl */
2679 dwarf2out_imported_module_or_decl,
2680 debug_nothing_tree, /* deferred_inline_function */
2681 /* The DWARF 2 backend tries to reduce debugging bloat by not
2682 emitting the abstract description of inline functions until
2683 something tries to reference them. */
2684 dwarf2out_abstract_function, /* outlining_inline_function */
2685 debug_nothing_rtx, /* label */
2686 debug_nothing_int, /* handle_pch */
2687 dwarf2out_var_location,
2688 dwarf2out_switch_text_section,
2690 1, /* start_end_main_source_file */
2691 TYPE_SYMTAB_IS_DIE /* tree_type_symtab_field */
2694 /* NOTE: In the comments in this file, many references are made to
2695 "Debugging Information Entries". This term is abbreviated as `DIE'
2696 throughout the remainder of this file. */
2698 /* An internal representation of the DWARF output is built, and then
2699 walked to generate the DWARF debugging info. The walk of the internal
2700 representation is done after the entire program has been compiled.
2701 The types below are used to describe the internal representation. */
2703 /* Whether to put type DIEs into their own section .debug_types instead
2704 of making them part of the .debug_info section. Only supported for
2705 Dwarf V4 or higher and the user didn't disable them through
2706 -fno-debug-types-section. It is more efficient to put them in a
2707 separate comdat sections since the linker will then be able to
2708 remove duplicates. But not all tools support .debug_types sections
2711 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2713 /* Various DIE's use offsets relative to the beginning of the
2714 .debug_info section to refer to each other. */
2716 typedef long int dw_offset;
2718 /* Define typedefs here to avoid circular dependencies. */
2720 typedef struct dw_attr_struct *dw_attr_ref;
2721 typedef struct dw_line_info_struct *dw_line_info_ref;
2722 typedef struct pubname_struct *pubname_ref;
2723 typedef struct dw_ranges_struct *dw_ranges_ref;
2724 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
2725 typedef struct comdat_type_struct *comdat_type_node_ref;
2727 /* The entries in the line_info table more-or-less mirror the opcodes
2728 that are used in the real dwarf line table. Arrays of these entries
2729 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2732 enum dw_line_info_opcode {
2733 /* Emit DW_LNE_set_address; the operand is the label index. */
2736 /* Emit a row to the matrix with the given line. This may be done
2737 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2741 /* Emit a DW_LNS_set_file. */
2744 /* Emit a DW_LNS_set_column. */
2747 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2750 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2751 LI_set_prologue_end,
2752 LI_set_epilogue_begin,
2754 /* Emit a DW_LNE_set_discriminator. */
2755 LI_set_discriminator
2758 typedef struct GTY(()) dw_line_info_struct {
2759 enum dw_line_info_opcode opcode;
2761 } dw_line_info_entry;
2763 DEF_VEC_O(dw_line_info_entry);
2764 DEF_VEC_ALLOC_O(dw_line_info_entry, gc);
2766 typedef struct GTY(()) dw_line_info_table_struct {
2767 /* The label that marks the end of this section. */
2768 const char *end_label;
2770 /* The values for the last row of the matrix, as collected in the table.
2771 These are used to minimize the changes to the next row. */
2772 unsigned int file_num;
2773 unsigned int line_num;
2774 unsigned int column_num;
2779 VEC(dw_line_info_entry, gc) *entries;
2780 } dw_line_info_table;
2782 typedef dw_line_info_table *dw_line_info_table_p;
2784 DEF_VEC_P(dw_line_info_table_p);
2785 DEF_VEC_ALLOC_P(dw_line_info_table_p, gc);
2787 /* Each DIE attribute has a field specifying the attribute kind,
2788 a link to the next attribute in the chain, and an attribute value.
2789 Attributes are typically linked below the DIE they modify. */
2791 typedef struct GTY(()) dw_attr_struct {
2792 enum dwarf_attribute dw_attr;
2793 dw_val_node dw_attr_val;
2797 DEF_VEC_O(dw_attr_node);
2798 DEF_VEC_ALLOC_O(dw_attr_node,gc);
2800 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2801 The children of each node form a circular list linked by
2802 die_sib. die_child points to the node *before* the "first" child node. */
2804 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
2805 union die_symbol_or_type_node
2807 char * GTY ((tag ("0"))) die_symbol;
2808 comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
2810 GTY ((desc ("use_debug_types"))) die_id;
2811 VEC(dw_attr_node,gc) * die_attr;
2812 dw_die_ref die_parent;
2813 dw_die_ref die_child;
2815 dw_die_ref die_definition; /* ref from a specification to its definition */
2816 dw_offset die_offset;
2817 unsigned long die_abbrev;
2819 /* Die is used and must not be pruned as unused. */
2820 int die_perennial_p;
2821 unsigned int decl_id;
2822 enum dwarf_tag die_tag;
2826 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2827 #define FOR_EACH_CHILD(die, c, expr) do { \
2828 c = die->die_child; \
2832 } while (c != die->die_child); \
2835 /* The pubname structure */
2837 typedef struct GTY(()) pubname_struct {
2843 DEF_VEC_O(pubname_entry);
2844 DEF_VEC_ALLOC_O(pubname_entry, gc);
2846 struct GTY(()) dw_ranges_struct {
2847 /* If this is positive, it's a block number, otherwise it's a
2848 bitwise-negated index into dw_ranges_by_label. */
2852 /* A structure to hold a macinfo entry. */
2854 typedef struct GTY(()) macinfo_struct {
2856 unsigned HOST_WIDE_INT lineno;
2861 DEF_VEC_O(macinfo_entry);
2862 DEF_VEC_ALLOC_O(macinfo_entry, gc);
2864 struct GTY(()) dw_ranges_by_label_struct {
2869 /* The comdat type node structure. */
2870 typedef struct GTY(()) comdat_type_struct
2872 dw_die_ref root_die;
2873 dw_die_ref type_die;
2874 char signature[DWARF_TYPE_SIGNATURE_SIZE];
2875 struct comdat_type_struct *next;
2879 /* The limbo die list structure. */
2880 typedef struct GTY(()) limbo_die_struct {
2883 struct limbo_die_struct *next;
2887 typedef struct skeleton_chain_struct
2891 struct skeleton_chain_struct *parent;
2893 skeleton_chain_node;
2895 /* Define a macro which returns nonzero for a TYPE_DECL which was
2896 implicitly generated for a type.
2898 Note that, unlike the C front-end (which generates a NULL named
2899 TYPE_DECL node for each complete tagged type, each array type,
2900 and each function type node created) the C++ front-end generates
2901 a _named_ TYPE_DECL node for each tagged type node created.
2902 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2903 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2904 front-end, but for each type, tagged or not. */
2906 #define TYPE_DECL_IS_STUB(decl) \
2907 (DECL_NAME (decl) == NULL_TREE \
2908 || (DECL_ARTIFICIAL (decl) \
2909 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2910 /* This is necessary for stub decls that \
2911 appear in nested inline functions. */ \
2912 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2913 && (decl_ultimate_origin (decl) \
2914 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2916 /* Information concerning the compilation unit's programming
2917 language, and compiler version. */
2919 /* Fixed size portion of the DWARF compilation unit header. */
2920 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2921 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2923 /* Fixed size portion of the DWARF comdat type unit header. */
2924 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2925 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2926 + DWARF_OFFSET_SIZE)
2928 /* Fixed size portion of public names info. */
2929 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2931 /* Fixed size portion of the address range info. */
2932 #define DWARF_ARANGES_HEADER_SIZE \
2933 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2934 DWARF2_ADDR_SIZE * 2) \
2935 - DWARF_INITIAL_LENGTH_SIZE)
2937 /* Size of padding portion in the address range info. It must be
2938 aligned to twice the pointer size. */
2939 #define DWARF_ARANGES_PAD_SIZE \
2940 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2941 DWARF2_ADDR_SIZE * 2) \
2942 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2944 /* Use assembler line directives if available. */
2945 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2946 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2947 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2949 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2953 /* Minimum line offset in a special line info. opcode.
2954 This value was chosen to give a reasonable range of values. */
2955 #define DWARF_LINE_BASE -10
2957 /* First special line opcode - leave room for the standard opcodes. */
2958 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2960 /* Range of line offsets in a special line info. opcode. */
2961 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2963 /* Flag that indicates the initial value of the is_stmt_start flag.
2964 In the present implementation, we do not mark any lines as
2965 the beginning of a source statement, because that information
2966 is not made available by the GCC front-end. */
2967 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2969 /* Maximum number of operations per instruction bundle. */
2970 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2971 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2974 /* This location is used by calc_die_sizes() to keep track
2975 the offset of each DIE within the .debug_info section. */
2976 static unsigned long next_die_offset;
2978 /* Record the root of the DIE's built for the current compilation unit. */
2979 static GTY(()) dw_die_ref single_comp_unit_die;
2981 /* A list of type DIEs that have been separated into comdat sections. */
2982 static GTY(()) comdat_type_node *comdat_type_list;
2984 /* A list of DIEs with a NULL parent waiting to be relocated. */
2985 static GTY(()) limbo_die_node *limbo_die_list;
2987 /* A list of DIEs for which we may have to generate
2988 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2989 static GTY(()) limbo_die_node *deferred_asm_name;
2991 /* Filenames referenced by this compilation unit. */
2992 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
2994 /* A hash table of references to DIE's that describe declarations.
2995 The key is a DECL_UID() which is a unique number identifying each decl. */
2996 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
2998 /* A hash table of references to DIE's that describe COMMON blocks.
2999 The key is DECL_UID() ^ die_parent. */
3000 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
3002 typedef struct GTY(()) die_arg_entry_struct {
3007 DEF_VEC_O(die_arg_entry);
3008 DEF_VEC_ALLOC_O(die_arg_entry,gc);
3010 /* Node of the variable location list. */
3011 struct GTY ((chain_next ("%h.next"))) var_loc_node {
3012 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3013 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3014 in mode of the EXPR_LIST node and first EXPR_LIST operand
3015 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3016 location or NULL for padding. For larger bitsizes,
3017 mode is 0 and first operand is a CONCAT with bitsize
3018 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3019 NULL as second operand. */
3021 const char * GTY (()) label;
3022 struct var_loc_node * GTY (()) next;
3025 /* Variable location list. */
3026 struct GTY (()) var_loc_list_def {
3027 struct var_loc_node * GTY (()) first;
3029 /* Pointer to the last but one or last element of the
3030 chained list. If the list is empty, both first and
3031 last are NULL, if the list contains just one node
3032 or the last node certainly is not redundant, it points
3033 to the last node, otherwise points to the last but one.
3034 Do not mark it for GC because it is marked through the chain. */
3035 struct var_loc_node * GTY ((skip ("%h"))) last;
3037 /* Pointer to the last element before section switch,
3038 if NULL, either sections weren't switched or first
3039 is after section switch. */
3040 struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
3042 /* DECL_UID of the variable decl. */
3043 unsigned int decl_id;
3045 typedef struct var_loc_list_def var_loc_list;
3047 /* Call argument location list. */
3048 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
3049 rtx GTY (()) call_arg_loc_note;
3050 const char * GTY (()) label;
3051 tree GTY (()) block;
3053 rtx GTY (()) symbol_ref;
3054 struct call_arg_loc_node * GTY (()) next;
3058 /* Table of decl location linked lists. */
3059 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3061 /* Head and tail of call_arg_loc chain. */
3062 static GTY (()) struct call_arg_loc_node *call_arg_locations;
3063 static struct call_arg_loc_node *call_arg_loc_last;
3065 /* Number of call sites in the current function. */
3066 static int call_site_count = -1;
3067 /* Number of tail call sites in the current function. */
3068 static int tail_call_site_count = -1;
3070 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
3072 static VEC (dw_die_ref, heap) *block_map;
3074 /* A cached location list. */
3075 struct GTY (()) cached_dw_loc_list_def {
3076 /* The DECL_UID of the decl that this entry describes. */
3077 unsigned int decl_id;
3079 /* The cached location list. */
3080 dw_loc_list_ref loc_list;
3082 typedef struct cached_dw_loc_list_def cached_dw_loc_list;
3084 /* Table of cached location lists. */
3085 static GTY ((param_is (cached_dw_loc_list))) htab_t cached_dw_loc_list_table;
3087 /* A pointer to the base of a list of references to DIE's that
3088 are uniquely identified by their tag, presence/absence of
3089 children DIE's, and list of attribute/value pairs. */
3090 static GTY((length ("abbrev_die_table_allocated")))
3091 dw_die_ref *abbrev_die_table;
3093 /* Number of elements currently allocated for abbrev_die_table. */
3094 static GTY(()) unsigned abbrev_die_table_allocated;
3096 /* Number of elements in type_die_table currently in use. */
3097 static GTY(()) unsigned abbrev_die_table_in_use;
3099 /* Size (in elements) of increments by which we may expand the
3100 abbrev_die_table. */
3101 #define ABBREV_DIE_TABLE_INCREMENT 256
3103 /* A global counter for generating labels for line number data. */
3104 static unsigned int line_info_label_num;
3106 /* The current table to which we should emit line number information
3107 for the current function. This will be set up at the beginning of
3108 assembly for the function. */
3109 static dw_line_info_table *cur_line_info_table;
3111 /* The two default tables of line number info. */
3112 static GTY(()) dw_line_info_table *text_section_line_info;
3113 static GTY(()) dw_line_info_table *cold_text_section_line_info;
3115 /* The set of all non-default tables of line number info. */
3116 static GTY(()) VEC (dw_line_info_table_p, gc) *separate_line_info;
3118 /* A flag to tell pubnames/types export if there is an info section to
3120 static bool info_section_emitted;
3122 /* A pointer to the base of a table that contains a list of publicly
3123 accessible names. */
3124 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
3126 /* A pointer to the base of a table that contains a list of publicly
3127 accessible types. */
3128 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
3130 /* A pointer to the base of a table that contains a list of macro
3131 defines/undefines (and file start/end markers). */
3132 static GTY (()) VEC (macinfo_entry, gc) * macinfo_table;
3134 /* Array of dies for which we should generate .debug_ranges info. */
3135 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3137 /* Number of elements currently allocated for ranges_table. */
3138 static GTY(()) unsigned ranges_table_allocated;
3140 /* Number of elements in ranges_table currently in use. */
3141 static GTY(()) unsigned ranges_table_in_use;
3143 /* Array of pairs of labels referenced in ranges_table. */
3144 static GTY ((length ("ranges_by_label_allocated")))
3145 dw_ranges_by_label_ref ranges_by_label;
3147 /* Number of elements currently allocated for ranges_by_label. */
3148 static GTY(()) unsigned ranges_by_label_allocated;
3150 /* Number of elements in ranges_by_label currently in use. */
3151 static GTY(()) unsigned ranges_by_label_in_use;
3153 /* Size (in elements) of increments by which we may expand the
3155 #define RANGES_TABLE_INCREMENT 64
3157 /* Whether we have location lists that need outputting */
3158 static GTY(()) bool have_location_lists;
3160 /* Unique label counter. */
3161 static GTY(()) unsigned int loclabel_num;
3163 /* Unique label counter for point-of-call tables. */
3164 static GTY(()) unsigned int poc_label_num;
3166 /* Record whether the function being analyzed contains inlined functions. */
3167 static int current_function_has_inlines;
3169 /* The last file entry emitted by maybe_emit_file(). */
3170 static GTY(()) struct dwarf_file_data * last_emitted_file;
3172 /* Number of internal labels generated by gen_internal_sym(). */
3173 static GTY(()) int label_num;
3175 /* Cached result of previous call to lookup_filename. */
3176 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
3178 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
3180 /* Instances of generic types for which we need to generate debug
3181 info that describe their generic parameters and arguments. That
3182 generation needs to happen once all types are properly laid out so
3183 we do it at the end of compilation. */
3184 static GTY(()) VEC(tree,gc) *generic_type_instances;
3186 /* Offset from the "steady-state frame pointer" to the frame base,
3187 within the current function. */
3188 static HOST_WIDE_INT frame_pointer_fb_offset;
3189 static bool frame_pointer_fb_offset_valid;
3191 static VEC (dw_die_ref, heap) *base_types;
3193 /* Forward declarations for functions defined in this file. */
3195 static int is_pseudo_reg (const_rtx);
3196 static tree type_main_variant (tree);
3197 static int is_tagged_type (const_tree);
3198 static const char *dwarf_tag_name (unsigned);
3199 static const char *dwarf_attr_name (unsigned);
3200 static const char *dwarf_form_name (unsigned);
3201 static tree decl_ultimate_origin (const_tree);
3202 static tree decl_class_context (tree);
3203 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3204 static inline enum dw_val_class AT_class (dw_attr_ref);
3205 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3206 static inline unsigned AT_flag (dw_attr_ref);
3207 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3208 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3209 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3210 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3211 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
3212 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
3213 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3214 unsigned int, unsigned char *);
3215 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
3216 static hashval_t debug_str_do_hash (const void *);
3217 static int debug_str_eq (const void *, const void *);
3218 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3219 static inline const char *AT_string (dw_attr_ref);
3220 static enum dwarf_form AT_string_form (dw_attr_ref);
3221 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3222 static void add_AT_specification (dw_die_ref, dw_die_ref);
3223 static inline dw_die_ref AT_ref (dw_attr_ref);
3224 static inline int AT_ref_external (dw_attr_ref);
3225 static inline void set_AT_ref_external (dw_attr_ref, int);
3226 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3227 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3228 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3229 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3231 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3232 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3233 static inline rtx AT_addr (dw_attr_ref);
3234 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3235 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
3236 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
3237 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3238 unsigned HOST_WIDE_INT);
3239 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3241 static inline const char *AT_lbl (dw_attr_ref);
3242 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3243 static const char *get_AT_low_pc (dw_die_ref);
3244 static const char *get_AT_hi_pc (dw_die_ref);
3245 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3246 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3247 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3248 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3249 static bool is_cxx (void);
3250 static bool is_fortran (void);
3251 static bool is_ada (void);
3252 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3253 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3254 static void add_child_die (dw_die_ref, dw_die_ref);
3255 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3256 static dw_die_ref lookup_type_die (tree);
3257 static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
3258 static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
3259 static void equate_type_number_to_die (tree, dw_die_ref);
3260 static hashval_t decl_die_table_hash (const void *);
3261 static int decl_die_table_eq (const void *, const void *);
3262 static dw_die_ref lookup_decl_die (tree);
3263 static hashval_t common_block_die_table_hash (const void *);
3264 static int common_block_die_table_eq (const void *, const void *);
3265 static hashval_t decl_loc_table_hash (const void *);
3266 static int decl_loc_table_eq (const void *, const void *);
3267 static var_loc_list *lookup_decl_loc (const_tree);
3268 static void equate_decl_number_to_die (tree, dw_die_ref);
3269 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
3270 static void print_spaces (FILE *);
3271 static void print_die (dw_die_ref, FILE *);
3272 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3273 static dw_die_ref pop_compile_unit (dw_die_ref);
3274 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3275 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3276 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3277 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
3278 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
3279 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
3280 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
3281 struct md5_ctx *, int *);
3282 struct checksum_attributes;
3283 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
3284 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
3285 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
3286 static void generate_type_signature (dw_die_ref, comdat_type_node *);
3287 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3288 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
3289 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3290 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3291 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3292 static void compute_section_prefix (dw_die_ref);
3293 static int is_type_die (dw_die_ref);
3294 static int is_comdat_die (dw_die_ref);
3295 static int is_symbol_die (dw_die_ref);
3296 static void assign_symbol_names (dw_die_ref);
3297 static void break_out_includes (dw_die_ref);
3298 static int is_declaration_die (dw_die_ref);
3299 static int should_move_die_to_comdat (dw_die_ref);
3300 static dw_die_ref clone_as_declaration (dw_die_ref);
3301 static dw_die_ref clone_die (dw_die_ref);
3302 static dw_die_ref clone_tree (dw_die_ref);
3303 static void copy_declaration_context (dw_die_ref, dw_die_ref);
3304 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
3305 static void generate_skeleton_bottom_up (skeleton_chain_node *);
3306 static dw_die_ref generate_skeleton (dw_die_ref);
3307 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
3309 static void break_out_comdat_types (dw_die_ref);
3310 static dw_die_ref copy_ancestor_tree (dw_die_ref, dw_die_ref, htab_t);
3311 static void copy_decls_walk (dw_die_ref, dw_die_ref, htab_t);
3312 static void copy_decls_for_unworthy_types (dw_die_ref);
3314 static hashval_t htab_cu_hash (const void *);
3315 static int htab_cu_eq (const void *, const void *);
3316 static void htab_cu_del (void *);
3317 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
3318 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
3319 static void add_sibling_attributes (dw_die_ref);
3320 static void build_abbrev_table (dw_die_ref);
3321 static void output_location_lists (dw_die_ref);
3322 static int constant_size (unsigned HOST_WIDE_INT);
3323 static unsigned long size_of_die (dw_die_ref);
3324 static void calc_die_sizes (dw_die_ref);
3325 static void calc_base_type_die_sizes (void);
3326 static void mark_dies (dw_die_ref);
3327 static void unmark_dies (dw_die_ref);
3328 static void unmark_all_dies (dw_die_ref);
3329 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
3330 static unsigned long size_of_aranges (void);
3331 static enum dwarf_form value_format (dw_attr_ref);
3332 static void output_value_format (dw_attr_ref);
3333 static void output_abbrev_section (void);
3334 static void output_die_symbol (dw_die_ref);
3335 static void output_die (dw_die_ref);
3336 static void output_compilation_unit_header (void);
3337 static void output_comp_unit (dw_die_ref, int);
3338 static void output_comdat_type_unit (comdat_type_node *);
3339 static const char *dwarf2_name (tree, int);
3340 static void add_pubname (tree, dw_die_ref);
3341 static void add_pubname_string (const char *, dw_die_ref);
3342 static void add_pubtype (tree, dw_die_ref);
3343 static void output_pubnames (VEC (pubname_entry,gc) *);
3344 static void output_aranges (unsigned long);
3345 static unsigned int add_ranges_num (int);
3346 static unsigned int add_ranges (const_tree);
3347 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
3349 static void output_ranges (void);
3350 static dw_line_info_table *new_line_info_table (void);
3351 static void output_line_info (void);
3352 static void output_file_names (void);
3353 static dw_die_ref base_type_die (tree);
3354 static int is_base_type (tree);
3355 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
3356 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
3357 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
3358 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
3359 static int type_is_enum (const_tree);
3360 static unsigned int dbx_reg_number (const_rtx);
3361 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
3362 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
3363 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
3364 enum var_init_status);
3365 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
3366 enum var_init_status);
3367 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
3368 enum var_init_status);
3369 static int is_based_loc (const_rtx);
3370 static int resolve_one_addr (rtx *, void *);
3371 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
3372 enum var_init_status);
3373 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
3374 enum var_init_status);
3375 static dw_loc_list_ref loc_list_from_tree (tree, int);
3376 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
3377 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3378 static tree field_type (const_tree);
3379 static unsigned int simple_type_align_in_bits (const_tree);
3380 static unsigned int simple_decl_align_in_bits (const_tree);
3381 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
3382 static HOST_WIDE_INT field_byte_offset (const_tree);
3383 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3385 static void add_data_member_location_attribute (dw_die_ref, tree);
3386 static bool add_const_value_attribute (dw_die_ref, rtx);
3387 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
3388 static void insert_double (double_int, unsigned char *);
3389 static void insert_float (const_rtx, unsigned char *);
3390 static rtx rtl_for_decl_location (tree);
3391 static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool,
3392 enum dwarf_attribute);
3393 static bool tree_add_const_value_attribute (dw_die_ref, tree);
3394 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
3395 static void add_name_attribute (dw_die_ref, const char *);
3396 static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
3397 static void add_comp_dir_attribute (dw_die_ref);
3398 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
3399 static void add_subscript_info (dw_die_ref, tree, bool);
3400 static void add_byte_size_attribute (dw_die_ref, tree);
3401 static void add_bit_offset_attribute (dw_die_ref, tree);
3402 static void add_bit_size_attribute (dw_die_ref, tree);
3403 static void add_prototyped_attribute (dw_die_ref, tree);
3404 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
3405 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3406 static void add_src_coords_attributes (dw_die_ref, tree);
3407 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
3408 static void push_decl_scope (tree);
3409 static void pop_decl_scope (void);
3410 static dw_die_ref scope_die_for (tree, dw_die_ref);
3411 static inline int local_scope_p (dw_die_ref);
3412 static inline int class_scope_p (dw_die_ref);
3413 static inline int class_or_namespace_scope_p (dw_die_ref);
3414 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
3415 static void add_calling_convention_attribute (dw_die_ref, tree);
3416 static const char *type_tag (const_tree);
3417 static tree member_declared_type (const_tree);
3419 static const char *decl_start_label (tree);
3421 static void gen_array_type_die (tree, dw_die_ref);
3422 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
3424 static void gen_entry_point_die (tree, dw_die_ref);
3426 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
3427 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
3428 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
3429 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3430 static void gen_formal_types_die (tree, dw_die_ref);
3431 static void gen_subprogram_die (tree, dw_die_ref);
3432 static void gen_variable_die (tree, tree, dw_die_ref);
3433 static void gen_const_die (tree, dw_die_ref);
3434 static void gen_label_die (tree, dw_die_ref);
3435 static void gen_lexical_block_die (tree, dw_die_ref, int);
3436 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
3437 static void gen_field_die (tree, dw_die_ref);
3438 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3439 static dw_die_ref gen_compile_unit_die (const char *);
3440 static void gen_inheritance_die (tree, tree, dw_die_ref);
3441 static void gen_member_die (tree, dw_die_ref);
3442 static void gen_struct_or_union_type_die (tree, dw_die_ref,
3443 enum debug_info_usage);
3444 static void gen_subroutine_type_die (tree, dw_die_ref);
3445 static void gen_typedef_die (tree, dw_die_ref);
3446 static void gen_type_die (tree, dw_die_ref);
3447 static void gen_block_die (tree, dw_die_ref, int);
3448 static void decls_for_scope (tree, dw_die_ref, int);
3449 static inline int is_redundant_typedef (const_tree);
3450 static bool is_naming_typedef_decl (const_tree);
3451 static inline dw_die_ref get_context_die (tree);
3452 static void gen_namespace_die (tree, dw_die_ref);
3453 static dw_die_ref gen_decl_die (tree, tree, dw_die_ref);
3454 static dw_die_ref force_decl_die (tree);
3455 static dw_die_ref force_type_die (tree);
3456 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
3457 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
3458 static struct dwarf_file_data * lookup_filename (const char *);
3459 static void retry_incomplete_types (void);
3460 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3461 static void gen_generic_params_dies (tree);
3462 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
3463 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
3464 static void splice_child_die (dw_die_ref, dw_die_ref);
3465 static int file_info_cmp (const void *, const void *);
3466 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
3467 const char *, const char *);
3468 static void output_loc_list (dw_loc_list_ref);
3469 static char *gen_internal_sym (const char *);
3471 static void prune_unmark_dies (dw_die_ref);
3472 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
3473 static void prune_unused_types_mark (dw_die_ref, int);
3474 static void prune_unused_types_walk (dw_die_ref);
3475 static void prune_unused_types_walk_attribs (dw_die_ref);
3476 static void prune_unused_types_prune (dw_die_ref);
3477 static void prune_unused_types (void);
3478 static int maybe_emit_file (struct dwarf_file_data *fd);
3479 static inline const char *AT_vms_delta1 (dw_attr_ref);
3480 static inline const char *AT_vms_delta2 (dw_attr_ref);
3481 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
3482 const char *, const char *);
3483 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
3484 static void gen_remaining_tmpl_value_param_die_attribute (void);
3485 static bool generic_type_p (tree);
3486 static void schedule_generic_params_dies_gen (tree t);
3487 static void gen_scheduled_generic_parms_dies (void);
3489 /* Section names used to hold DWARF debugging information. */
3490 #ifndef DEBUG_INFO_SECTION
3491 #define DEBUG_INFO_SECTION ".debug_info"
3493 #ifndef DEBUG_ABBREV_SECTION
3494 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3496 #ifndef DEBUG_ARANGES_SECTION
3497 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3499 #ifndef DEBUG_MACINFO_SECTION
3500 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
3502 #ifndef DEBUG_MACRO_SECTION
3503 #define DEBUG_MACRO_SECTION ".debug_macro"
3505 #ifndef DEBUG_LINE_SECTION
3506 #define DEBUG_LINE_SECTION ".debug_line"
3508 #ifndef DEBUG_LOC_SECTION
3509 #define DEBUG_LOC_SECTION ".debug_loc"
3511 #ifndef DEBUG_PUBNAMES_SECTION
3512 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
3514 #ifndef DEBUG_PUBTYPES_SECTION
3515 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
3517 #ifndef DEBUG_STR_SECTION
3518 #define DEBUG_STR_SECTION ".debug_str"
3520 #ifndef DEBUG_RANGES_SECTION
3521 #define DEBUG_RANGES_SECTION ".debug_ranges"
3524 /* Standard ELF section names for compiled code and data. */
3525 #ifndef TEXT_SECTION_NAME
3526 #define TEXT_SECTION_NAME ".text"
3529 /* Section flags for .debug_str section. */
3530 #define DEBUG_STR_SECTION_FLAGS \
3531 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3532 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3535 /* Labels we insert at beginning sections we can reference instead of
3536 the section names themselves. */
3538 #ifndef TEXT_SECTION_LABEL
3539 #define TEXT_SECTION_LABEL "Ltext"
3541 #ifndef COLD_TEXT_SECTION_LABEL
3542 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3544 #ifndef DEBUG_LINE_SECTION_LABEL
3545 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3547 #ifndef DEBUG_INFO_SECTION_LABEL
3548 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3550 #ifndef DEBUG_ABBREV_SECTION_LABEL
3551 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3553 #ifndef DEBUG_LOC_SECTION_LABEL
3554 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3556 #ifndef DEBUG_RANGES_SECTION_LABEL
3557 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3559 #ifndef DEBUG_MACINFO_SECTION_LABEL
3560 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3562 #ifndef DEBUG_MACRO_SECTION_LABEL
3563 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3567 /* Definitions of defaults for formats and names of various special
3568 (artificial) labels which may be generated within this file (when the -g
3569 options is used and DWARF2_DEBUGGING_INFO is in effect.
3570 If necessary, these may be overridden from within the tm.h file, but
3571 typically, overriding these defaults is unnecessary. */
3573 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3574 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3575 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3576 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3577 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3578 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3579 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3580 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3581 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3582 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3584 #ifndef TEXT_END_LABEL
3585 #define TEXT_END_LABEL "Letext"
3587 #ifndef COLD_END_LABEL
3588 #define COLD_END_LABEL "Letext_cold"
3590 #ifndef BLOCK_BEGIN_LABEL
3591 #define BLOCK_BEGIN_LABEL "LBB"
3593 #ifndef BLOCK_END_LABEL
3594 #define BLOCK_END_LABEL "LBE"
3596 #ifndef LINE_CODE_LABEL
3597 #define LINE_CODE_LABEL "LM"
3601 /* Return the root of the DIE's built for the current compilation unit. */
3603 comp_unit_die (void)
3605 if (!single_comp_unit_die)
3606 single_comp_unit_die = gen_compile_unit_die (NULL);
3607 return single_comp_unit_die;
3610 /* We allow a language front-end to designate a function that is to be
3611 called to "demangle" any name before it is put into a DIE. */
3613 static const char *(*demangle_name_func) (const char *);
3616 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
3618 demangle_name_func = func;
3621 /* Test if rtl node points to a pseudo register. */
3624 is_pseudo_reg (const_rtx rtl)
3626 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
3627 || (GET_CODE (rtl) == SUBREG
3628 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
3631 /* Return a reference to a type, with its const and volatile qualifiers
3635 type_main_variant (tree type)
3637 type = TYPE_MAIN_VARIANT (type);
3639 /* ??? There really should be only one main variant among any group of
3640 variants of a given type (and all of the MAIN_VARIANT values for all
3641 members of the group should point to that one type) but sometimes the C
3642 front-end messes this up for array types, so we work around that bug
3644 if (TREE_CODE (type) == ARRAY_TYPE)
3645 while (type != TYPE_MAIN_VARIANT (type))
3646 type = TYPE_MAIN_VARIANT (type);
3651 /* Return nonzero if the given type node represents a tagged type. */
3654 is_tagged_type (const_tree type)
3656 enum tree_code code = TREE_CODE (type);
3658 return (code == RECORD_TYPE || code == UNION_TYPE
3659 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
3662 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3665 get_ref_die_offset_label (char *label, dw_die_ref ref)
3667 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
3670 /* Return die_offset of a DIE reference to a base type. */
3672 static unsigned long int
3673 get_base_type_offset (dw_die_ref ref)
3675 if (ref->die_offset)
3676 return ref->die_offset;
3677 if (comp_unit_die ()->die_abbrev)
3679 calc_base_type_die_sizes ();
3680 gcc_assert (ref->die_offset);
3682 return ref->die_offset;
3685 /* Return die_offset of a DIE reference other than base type. */
3687 static unsigned long int
3688 get_ref_die_offset (dw_die_ref ref)
3690 gcc_assert (ref->die_offset);
3691 return ref->die_offset;
3694 /* Convert a DIE tag into its string name. */
3697 dwarf_tag_name (unsigned int tag)
3701 case DW_TAG_padding:
3702 return "DW_TAG_padding";
3703 case DW_TAG_array_type:
3704 return "DW_TAG_array_type";
3705 case DW_TAG_class_type:
3706 return "DW_TAG_class_type";
3707 case DW_TAG_entry_point:
3708 return "DW_TAG_entry_point";
3709 case DW_TAG_enumeration_type:
3710 return "DW_TAG_enumeration_type";
3711 case DW_TAG_formal_parameter:
3712 return "DW_TAG_formal_parameter";
3713 case DW_TAG_imported_declaration:
3714 return "DW_TAG_imported_declaration";
3716 return "DW_TAG_label";
3717 case DW_TAG_lexical_block:
3718 return "DW_TAG_lexical_block";
3720 return "DW_TAG_member";
3721 case DW_TAG_pointer_type:
3722 return "DW_TAG_pointer_type";
3723 case DW_TAG_reference_type:
3724 return "DW_TAG_reference_type";
3725 case DW_TAG_compile_unit:
3726 return "DW_TAG_compile_unit";
3727 case DW_TAG_string_type:
3728 return "DW_TAG_string_type";
3729 case DW_TAG_structure_type:
3730 return "DW_TAG_structure_type";
3731 case DW_TAG_subroutine_type:
3732 return "DW_TAG_subroutine_type";
3733 case DW_TAG_typedef:
3734 return "DW_TAG_typedef";
3735 case DW_TAG_union_type:
3736 return "DW_TAG_union_type";
3737 case DW_TAG_unspecified_parameters:
3738 return "DW_TAG_unspecified_parameters";
3739 case DW_TAG_variant:
3740 return "DW_TAG_variant";
3741 case DW_TAG_common_block:
3742 return "DW_TAG_common_block";
3743 case DW_TAG_common_inclusion:
3744 return "DW_TAG_common_inclusion";
3745 case DW_TAG_inheritance:
3746 return "DW_TAG_inheritance";
3747 case DW_TAG_inlined_subroutine:
3748 return "DW_TAG_inlined_subroutine";
3750 return "DW_TAG_module";
3751 case DW_TAG_ptr_to_member_type:
3752 return "DW_TAG_ptr_to_member_type";
3753 case DW_TAG_set_type:
3754 return "DW_TAG_set_type";
3755 case DW_TAG_subrange_type:
3756 return "DW_TAG_subrange_type";
3757 case DW_TAG_with_stmt:
3758 return "DW_TAG_with_stmt";
3759 case DW_TAG_access_declaration:
3760 return "DW_TAG_access_declaration";
3761 case DW_TAG_base_type:
3762 return "DW_TAG_base_type";
3763 case DW_TAG_catch_block:
3764 return "DW_TAG_catch_block";
3765 case DW_TAG_const_type:
3766 return "DW_TAG_const_type";
3767 case DW_TAG_constant:
3768 return "DW_TAG_constant";
3769 case DW_TAG_enumerator:
3770 return "DW_TAG_enumerator";
3771 case DW_TAG_file_type:
3772 return "DW_TAG_file_type";
3774 return "DW_TAG_friend";
3775 case DW_TAG_namelist:
3776 return "DW_TAG_namelist";
3777 case DW_TAG_namelist_item:
3778 return "DW_TAG_namelist_item";
3779 case DW_TAG_packed_type:
3780 return "DW_TAG_packed_type";
3781 case DW_TAG_subprogram:
3782 return "DW_TAG_subprogram";
3783 case DW_TAG_template_type_param:
3784 return "DW_TAG_template_type_param";
3785 case DW_TAG_template_value_param:
3786 return "DW_TAG_template_value_param";
3787 case DW_TAG_thrown_type:
3788 return "DW_TAG_thrown_type";
3789 case DW_TAG_try_block:
3790 return "DW_TAG_try_block";
3791 case DW_TAG_variant_part:
3792 return "DW_TAG_variant_part";
3793 case DW_TAG_variable:
3794 return "DW_TAG_variable";
3795 case DW_TAG_volatile_type:
3796 return "DW_TAG_volatile_type";
3797 case DW_TAG_dwarf_procedure:
3798 return "DW_TAG_dwarf_procedure";
3799 case DW_TAG_restrict_type:
3800 return "DW_TAG_restrict_type";
3801 case DW_TAG_interface_type:
3802 return "DW_TAG_interface_type";
3803 case DW_TAG_namespace:
3804 return "DW_TAG_namespace";
3805 case DW_TAG_imported_module:
3806 return "DW_TAG_imported_module";
3807 case DW_TAG_unspecified_type:
3808 return "DW_TAG_unspecified_type";
3809 case DW_TAG_partial_unit:
3810 return "DW_TAG_partial_unit";
3811 case DW_TAG_imported_unit:
3812 return "DW_TAG_imported_unit";
3813 case DW_TAG_condition:
3814 return "DW_TAG_condition";
3815 case DW_TAG_shared_type:
3816 return "DW_TAG_shared_type";
3817 case DW_TAG_type_unit:
3818 return "DW_TAG_type_unit";
3819 case DW_TAG_rvalue_reference_type:
3820 return "DW_TAG_rvalue_reference_type";
3821 case DW_TAG_template_alias:
3822 return "DW_TAG_template_alias";
3823 case DW_TAG_GNU_template_parameter_pack:
3824 return "DW_TAG_GNU_template_parameter_pack";
3825 case DW_TAG_GNU_formal_parameter_pack:
3826 return "DW_TAG_GNU_formal_parameter_pack";
3827 case DW_TAG_MIPS_loop:
3828 return "DW_TAG_MIPS_loop";
3829 case DW_TAG_format_label:
3830 return "DW_TAG_format_label";
3831 case DW_TAG_function_template:
3832 return "DW_TAG_function_template";
3833 case DW_TAG_class_template:
3834 return "DW_TAG_class_template";
3835 case DW_TAG_GNU_BINCL:
3836 return "DW_TAG_GNU_BINCL";
3837 case DW_TAG_GNU_EINCL:
3838 return "DW_TAG_GNU_EINCL";
3839 case DW_TAG_GNU_template_template_param:
3840 return "DW_TAG_GNU_template_template_param";
3841 case DW_TAG_GNU_call_site:
3842 return "DW_TAG_GNU_call_site";
3843 case DW_TAG_GNU_call_site_parameter:
3844 return "DW_TAG_GNU_call_site_parameter";
3846 return "DW_TAG_<unknown>";
3850 /* Convert a DWARF attribute code into its string name. */
3853 dwarf_attr_name (unsigned int attr)
3858 return "DW_AT_sibling";
3859 case DW_AT_location:
3860 return "DW_AT_location";
3862 return "DW_AT_name";
3863 case DW_AT_ordering:
3864 return "DW_AT_ordering";
3865 case DW_AT_subscr_data:
3866 return "DW_AT_subscr_data";
3867 case DW_AT_byte_size:
3868 return "DW_AT_byte_size";
3869 case DW_AT_bit_offset:
3870 return "DW_AT_bit_offset";
3871 case DW_AT_bit_size:
3872 return "DW_AT_bit_size";
3873 case DW_AT_element_list:
3874 return "DW_AT_element_list";
3875 case DW_AT_stmt_list:
3876 return "DW_AT_stmt_list";
3878 return "DW_AT_low_pc";
3880 return "DW_AT_high_pc";
3881 case DW_AT_language:
3882 return "DW_AT_language";
3884 return "DW_AT_member";
3886 return "DW_AT_discr";
3887 case DW_AT_discr_value:
3888 return "DW_AT_discr_value";
3889 case DW_AT_visibility:
3890 return "DW_AT_visibility";
3892 return "DW_AT_import";
3893 case DW_AT_string_length:
3894 return "DW_AT_string_length";
3895 case DW_AT_common_reference:
3896 return "DW_AT_common_reference";
3897 case DW_AT_comp_dir:
3898 return "DW_AT_comp_dir";
3899 case DW_AT_const_value:
3900 return "DW_AT_const_value";
3901 case DW_AT_containing_type:
3902 return "DW_AT_containing_type";
3903 case DW_AT_default_value:
3904 return "DW_AT_default_value";
3906 return "DW_AT_inline";
3907 case DW_AT_is_optional:
3908 return "DW_AT_is_optional";
3909 case DW_AT_lower_bound:
3910 return "DW_AT_lower_bound";
3911 case DW_AT_producer:
3912 return "DW_AT_producer";
3913 case DW_AT_prototyped:
3914 return "DW_AT_prototyped";
3915 case DW_AT_return_addr:
3916 return "DW_AT_return_addr";
3917 case DW_AT_start_scope:
3918 return "DW_AT_start_scope";
3919 case DW_AT_bit_stride:
3920 return "DW_AT_bit_stride";
3921 case DW_AT_upper_bound:
3922 return "DW_AT_upper_bound";
3923 case DW_AT_abstract_origin:
3924 return "DW_AT_abstract_origin";
3925 case DW_AT_accessibility:
3926 return "DW_AT_accessibility";
3927 case DW_AT_address_class:
3928 return "DW_AT_address_class";
3929 case DW_AT_artificial:
3930 return "DW_AT_artificial";
3931 case DW_AT_base_types:
3932 return "DW_AT_base_types";
3933 case DW_AT_calling_convention:
3934 return "DW_AT_calling_convention";
3936 return "DW_AT_count";
3937 case DW_AT_data_member_location:
3938 return "DW_AT_data_member_location";
3939 case DW_AT_decl_column:
3940 return "DW_AT_decl_column";
3941 case DW_AT_decl_file:
3942 return "DW_AT_decl_file";
3943 case DW_AT_decl_line:
3944 return "DW_AT_decl_line";
3945 case DW_AT_declaration:
3946 return "DW_AT_declaration";
3947 case DW_AT_discr_list:
3948 return "DW_AT_discr_list";
3949 case DW_AT_encoding:
3950 return "DW_AT_encoding";
3951 case DW_AT_external:
3952 return "DW_AT_external";
3953 case DW_AT_explicit:
3954 return "DW_AT_explicit";
3955 case DW_AT_frame_base:
3956 return "DW_AT_frame_base";
3958 return "DW_AT_friend";
3959 case DW_AT_identifier_case:
3960 return "DW_AT_identifier_case";
3961 case DW_AT_macro_info:
3962 return "DW_AT_macro_info";
3963 case DW_AT_namelist_items:
3964 return "DW_AT_namelist_items";
3965 case DW_AT_priority:
3966 return "DW_AT_priority";
3968 return "DW_AT_segment";
3969 case DW_AT_specification:
3970 return "DW_AT_specification";
3971 case DW_AT_static_link:
3972 return "DW_AT_static_link";
3974 return "DW_AT_type";
3975 case DW_AT_use_location:
3976 return "DW_AT_use_location";
3977 case DW_AT_variable_parameter:
3978 return "DW_AT_variable_parameter";
3979 case DW_AT_virtuality:
3980 return "DW_AT_virtuality";
3981 case DW_AT_vtable_elem_location:
3982 return "DW_AT_vtable_elem_location";
3984 case DW_AT_allocated:
3985 return "DW_AT_allocated";
3986 case DW_AT_associated:
3987 return "DW_AT_associated";
3988 case DW_AT_data_location:
3989 return "DW_AT_data_location";
3990 case DW_AT_byte_stride:
3991 return "DW_AT_byte_stride";
3992 case DW_AT_entry_pc:
3993 return "DW_AT_entry_pc";
3994 case DW_AT_use_UTF8:
3995 return "DW_AT_use_UTF8";
3996 case DW_AT_extension:
3997 return "DW_AT_extension";
3999 return "DW_AT_ranges";
4000 case DW_AT_trampoline:
4001 return "DW_AT_trampoline";
4002 case DW_AT_call_column:
4003 return "DW_AT_call_column";
4004 case DW_AT_call_file:
4005 return "DW_AT_call_file";
4006 case DW_AT_call_line:
4007 return "DW_AT_call_line";
4008 case DW_AT_object_pointer:
4009 return "DW_AT_object_pointer";
4011 case DW_AT_signature:
4012 return "DW_AT_signature";
4013 case DW_AT_main_subprogram:
4014 return "DW_AT_main_subprogram";
4015 case DW_AT_data_bit_offset:
4016 return "DW_AT_data_bit_offset";
4017 case DW_AT_const_expr:
4018 return "DW_AT_const_expr";
4019 case DW_AT_enum_class:
4020 return "DW_AT_enum_class";
4021 case DW_AT_linkage_name:
4022 return "DW_AT_linkage_name";
4024 case DW_AT_MIPS_fde:
4025 return "DW_AT_MIPS_fde";
4026 case DW_AT_MIPS_loop_begin:
4027 return "DW_AT_MIPS_loop_begin";
4028 case DW_AT_MIPS_tail_loop_begin:
4029 return "DW_AT_MIPS_tail_loop_begin";
4030 case DW_AT_MIPS_epilog_begin:
4031 return "DW_AT_MIPS_epilog_begin";
4032 #if VMS_DEBUGGING_INFO
4033 case DW_AT_HP_prologue:
4034 return "DW_AT_HP_prologue";
4036 case DW_AT_MIPS_loop_unroll_factor:
4037 return "DW_AT_MIPS_loop_unroll_factor";
4039 case DW_AT_MIPS_software_pipeline_depth:
4040 return "DW_AT_MIPS_software_pipeline_depth";
4041 case DW_AT_MIPS_linkage_name:
4042 return "DW_AT_MIPS_linkage_name";
4043 #if VMS_DEBUGGING_INFO
4044 case DW_AT_HP_epilogue:
4045 return "DW_AT_HP_epilogue";
4047 case DW_AT_MIPS_stride:
4048 return "DW_AT_MIPS_stride";
4050 case DW_AT_MIPS_abstract_name:
4051 return "DW_AT_MIPS_abstract_name";
4052 case DW_AT_MIPS_clone_origin:
4053 return "DW_AT_MIPS_clone_origin";
4054 case DW_AT_MIPS_has_inlines:
4055 return "DW_AT_MIPS_has_inlines";
4057 case DW_AT_sf_names:
4058 return "DW_AT_sf_names";
4059 case DW_AT_src_info:
4060 return "DW_AT_src_info";
4061 case DW_AT_mac_info:
4062 return "DW_AT_mac_info";
4063 case DW_AT_src_coords:
4064 return "DW_AT_src_coords";
4065 case DW_AT_body_begin:
4066 return "DW_AT_body_begin";
4067 case DW_AT_body_end:
4068 return "DW_AT_body_end";
4070 case DW_AT_GNU_vector:
4071 return "DW_AT_GNU_vector";
4072 case DW_AT_GNU_guarded_by:
4073 return "DW_AT_GNU_guarded_by";
4074 case DW_AT_GNU_pt_guarded_by:
4075 return "DW_AT_GNU_pt_guarded_by";
4076 case DW_AT_GNU_guarded:
4077 return "DW_AT_GNU_guarded";
4078 case DW_AT_GNU_pt_guarded:
4079 return "DW_AT_GNU_pt_guarded";
4080 case DW_AT_GNU_locks_excluded:
4081 return "DW_AT_GNU_locks_excluded";
4082 case DW_AT_GNU_exclusive_locks_required:
4083 return "DW_AT_GNU_exclusive_locks_required";
4084 case DW_AT_GNU_shared_locks_required:
4085 return "DW_AT_GNU_shared_locks_required";
4086 case DW_AT_GNU_odr_signature:
4087 return "DW_AT_GNU_odr_signature";
4088 case DW_AT_GNU_template_name:
4089 return "DW_AT_GNU_template_name";
4090 case DW_AT_GNU_call_site_value:
4091 return "DW_AT_GNU_call_site_value";
4092 case DW_AT_GNU_call_site_data_value:
4093 return "DW_AT_GNU_call_site_data_value";
4094 case DW_AT_GNU_call_site_target:
4095 return "DW_AT_GNU_call_site_target";
4096 case DW_AT_GNU_call_site_target_clobbered:
4097 return "DW_AT_GNU_call_site_target_clobbered";
4098 case DW_AT_GNU_tail_call:
4099 return "DW_AT_GNU_tail_call";
4100 case DW_AT_GNU_all_tail_call_sites:
4101 return "DW_AT_GNU_all_tail_call_sites";
4102 case DW_AT_GNU_all_call_sites:
4103 return "DW_AT_GNU_all_call_sites";
4104 case DW_AT_GNU_all_source_call_sites:
4105 return "DW_AT_GNU_all_source_call_sites";
4106 case DW_AT_GNU_macros:
4107 return "DW_AT_GNU_macros";
4109 case DW_AT_GNAT_descriptive_type:
4110 return "DW_AT_GNAT_descriptive_type";
4112 case DW_AT_VMS_rtnbeg_pd_address:
4113 return "DW_AT_VMS_rtnbeg_pd_address";
4116 return "DW_AT_<unknown>";
4120 /* Convert a DWARF value form code into its string name. */
4123 dwarf_form_name (unsigned int form)
4128 return "DW_FORM_addr";
4129 case DW_FORM_block2:
4130 return "DW_FORM_block2";
4131 case DW_FORM_block4:
4132 return "DW_FORM_block4";
4134 return "DW_FORM_data2";
4136 return "DW_FORM_data4";
4138 return "DW_FORM_data8";
4139 case DW_FORM_string:
4140 return "DW_FORM_string";
4142 return "DW_FORM_block";
4143 case DW_FORM_block1:
4144 return "DW_FORM_block1";
4146 return "DW_FORM_data1";
4148 return "DW_FORM_flag";
4150 return "DW_FORM_sdata";
4152 return "DW_FORM_strp";
4154 return "DW_FORM_udata";
4155 case DW_FORM_ref_addr:
4156 return "DW_FORM_ref_addr";
4158 return "DW_FORM_ref1";
4160 return "DW_FORM_ref2";
4162 return "DW_FORM_ref4";
4164 return "DW_FORM_ref8";
4165 case DW_FORM_ref_udata:
4166 return "DW_FORM_ref_udata";
4167 case DW_FORM_indirect:
4168 return "DW_FORM_indirect";
4169 case DW_FORM_sec_offset:
4170 return "DW_FORM_sec_offset";
4171 case DW_FORM_exprloc:
4172 return "DW_FORM_exprloc";
4173 case DW_FORM_flag_present:
4174 return "DW_FORM_flag_present";
4175 case DW_FORM_ref_sig8:
4176 return "DW_FORM_ref_sig8";
4178 return "DW_FORM_<unknown>";
4182 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4183 instance of an inlined instance of a decl which is local to an inline
4184 function, so we have to trace all of the way back through the origin chain
4185 to find out what sort of node actually served as the original seed for the
4189 decl_ultimate_origin (const_tree decl)
4191 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4194 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4195 nodes in the function to point to themselves; ignore that if
4196 we're trying to output the abstract instance of this function. */
4197 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4200 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4201 most distant ancestor, this should never happen. */
4202 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4204 return DECL_ABSTRACT_ORIGIN (decl);
4207 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4208 of a virtual function may refer to a base class, so we check the 'this'
4212 decl_class_context (tree decl)
4214 tree context = NULL_TREE;
4216 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4217 context = DECL_CONTEXT (decl);
4219 context = TYPE_MAIN_VARIANT
4220 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4222 if (context && !TYPE_P (context))
4223 context = NULL_TREE;
4228 /* Add an attribute/value pair to a DIE. */
4231 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4233 /* Maybe this should be an assert? */
4237 if (die->die_attr == NULL)
4238 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
4239 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
4242 static inline enum dw_val_class
4243 AT_class (dw_attr_ref a)
4245 return a->dw_attr_val.val_class;
4248 /* Add a flag value attribute to a DIE. */
4251 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4255 attr.dw_attr = attr_kind;
4256 attr.dw_attr_val.val_class = dw_val_class_flag;
4257 attr.dw_attr_val.v.val_flag = flag;
4258 add_dwarf_attr (die, &attr);
4261 static inline unsigned
4262 AT_flag (dw_attr_ref a)
4264 gcc_assert (a && AT_class (a) == dw_val_class_flag);
4265 return a->dw_attr_val.v.val_flag;
4268 /* Add a signed integer attribute value to a DIE. */
4271 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4275 attr.dw_attr = attr_kind;
4276 attr.dw_attr_val.val_class = dw_val_class_const;
4277 attr.dw_attr_val.v.val_int = int_val;
4278 add_dwarf_attr (die, &attr);
4281 static inline HOST_WIDE_INT
4282 AT_int (dw_attr_ref a)
4284 gcc_assert (a && AT_class (a) == dw_val_class_const);
4285 return a->dw_attr_val.v.val_int;
4288 /* Add an unsigned integer attribute value to a DIE. */
4291 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4292 unsigned HOST_WIDE_INT unsigned_val)
4296 attr.dw_attr = attr_kind;
4297 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
4298 attr.dw_attr_val.v.val_unsigned = unsigned_val;
4299 add_dwarf_attr (die, &attr);
4302 static inline unsigned HOST_WIDE_INT
4303 AT_unsigned (dw_attr_ref a)
4305 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4306 return a->dw_attr_val.v.val_unsigned;
4309 /* Add an unsigned double integer attribute value to a DIE. */
4312 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
4313 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
4317 attr.dw_attr = attr_kind;
4318 attr.dw_attr_val.val_class = dw_val_class_const_double;
4319 attr.dw_attr_val.v.val_double.high = high;
4320 attr.dw_attr_val.v.val_double.low = low;
4321 add_dwarf_attr (die, &attr);
4324 /* Add a floating point attribute value to a DIE and return it. */
4327 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4328 unsigned int length, unsigned int elt_size, unsigned char *array)
4332 attr.dw_attr = attr_kind;
4333 attr.dw_attr_val.val_class = dw_val_class_vec;
4334 attr.dw_attr_val.v.val_vec.length = length;
4335 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
4336 attr.dw_attr_val.v.val_vec.array = array;
4337 add_dwarf_attr (die, &attr);
4340 /* Add an 8-byte data attribute value to a DIE. */
4343 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
4344 unsigned char data8[8])
4348 attr.dw_attr = attr_kind;
4349 attr.dw_attr_val.val_class = dw_val_class_data8;
4350 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
4351 add_dwarf_attr (die, &attr);
4354 /* Hash and equality functions for debug_str_hash. */
4357 debug_str_do_hash (const void *x)
4359 return htab_hash_string (((const struct indirect_string_node *)x)->str);
4363 debug_str_eq (const void *x1, const void *x2)
4365 return strcmp ((((const struct indirect_string_node *)x1)->str),
4366 (const char *)x2) == 0;
4369 /* Add STR to the indirect string hash table. */
4371 static struct indirect_string_node *
4372 find_AT_string (const char *str)
4374 struct indirect_string_node *node;
4377 if (! debug_str_hash)
4378 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
4379 debug_str_eq, NULL);
4381 slot = htab_find_slot_with_hash (debug_str_hash, str,
4382 htab_hash_string (str), INSERT);
4385 node = ggc_alloc_cleared_indirect_string_node ();
4386 node->str = ggc_strdup (str);
4390 node = (struct indirect_string_node *) *slot;
4396 /* Add a string attribute value to a DIE. */
4399 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4402 struct indirect_string_node *node;
4404 node = find_AT_string (str);
4406 attr.dw_attr = attr_kind;
4407 attr.dw_attr_val.val_class = dw_val_class_str;
4408 attr.dw_attr_val.v.val_str = node;
4409 add_dwarf_attr (die, &attr);
4412 static inline const char *
4413 AT_string (dw_attr_ref a)
4415 gcc_assert (a && AT_class (a) == dw_val_class_str);
4416 return a->dw_attr_val.v.val_str->str;
4419 /* Find out whether a string should be output inline in DIE
4420 or out-of-line in .debug_str section. */
4422 static enum dwarf_form
4423 AT_string_form (dw_attr_ref a)
4425 struct indirect_string_node *node;
4429 gcc_assert (a && AT_class (a) == dw_val_class_str);
4431 node = a->dw_attr_val.v.val_str;
4435 len = strlen (node->str) + 1;
4437 /* If the string is shorter or equal to the size of the reference, it is
4438 always better to put it inline. */
4439 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4440 return node->form = DW_FORM_string;
4442 /* If we cannot expect the linker to merge strings in .debug_str
4443 section, only put it into .debug_str if it is worth even in this
4445 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4446 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
4447 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
4448 return node->form = DW_FORM_string;
4450 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4451 ++dw2_string_counter;
4452 node->label = xstrdup (label);
4454 return node->form = DW_FORM_strp;
4457 /* Add a DIE reference attribute value to a DIE. */
4460 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
4464 #ifdef ENABLE_CHECKING
4465 gcc_assert (targ_die != NULL);
4467 /* With LTO we can end up trying to reference something we didn't create
4468 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4469 if (targ_die == NULL)
4473 attr.dw_attr = attr_kind;
4474 attr.dw_attr_val.val_class = dw_val_class_die_ref;
4475 attr.dw_attr_val.v.val_die_ref.die = targ_die;
4476 attr.dw_attr_val.v.val_die_ref.external = 0;
4477 add_dwarf_attr (die, &attr);
4480 /* Add an AT_specification attribute to a DIE, and also make the back
4481 pointer from the specification to the definition. */
4484 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
4486 add_AT_die_ref (die, DW_AT_specification, targ_die);
4487 gcc_assert (!targ_die->die_definition);
4488 targ_die->die_definition = die;
4491 static inline dw_die_ref
4492 AT_ref (dw_attr_ref a)
4494 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4495 return a->dw_attr_val.v.val_die_ref.die;
4499 AT_ref_external (dw_attr_ref a)
4501 if (a && AT_class (a) == dw_val_class_die_ref)
4502 return a->dw_attr_val.v.val_die_ref.external;
4508 set_AT_ref_external (dw_attr_ref a, int i)
4510 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4511 a->dw_attr_val.v.val_die_ref.external = i;
4514 /* Add an FDE reference attribute value to a DIE. */
4517 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
4521 attr.dw_attr = attr_kind;
4522 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
4523 attr.dw_attr_val.v.val_fde_index = targ_fde;
4524 add_dwarf_attr (die, &attr);
4527 /* Add a location description attribute value to a DIE. */
4530 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
4534 attr.dw_attr = attr_kind;
4535 attr.dw_attr_val.val_class = dw_val_class_loc;
4536 attr.dw_attr_val.v.val_loc = loc;
4537 add_dwarf_attr (die, &attr);
4540 static inline dw_loc_descr_ref
4541 AT_loc (dw_attr_ref a)
4543 gcc_assert (a && AT_class (a) == dw_val_class_loc);
4544 return a->dw_attr_val.v.val_loc;
4548 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
4552 attr.dw_attr = attr_kind;
4553 attr.dw_attr_val.val_class = dw_val_class_loc_list;
4554 attr.dw_attr_val.v.val_loc_list = loc_list;
4555 add_dwarf_attr (die, &attr);
4556 have_location_lists = true;
4559 static inline dw_loc_list_ref
4560 AT_loc_list (dw_attr_ref a)
4562 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4563 return a->dw_attr_val.v.val_loc_list;
4566 static inline dw_loc_list_ref *
4567 AT_loc_list_ptr (dw_attr_ref a)
4569 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4570 return &a->dw_attr_val.v.val_loc_list;
4573 /* Add an address constant attribute value to a DIE. */
4576 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
4580 attr.dw_attr = attr_kind;
4581 attr.dw_attr_val.val_class = dw_val_class_addr;
4582 attr.dw_attr_val.v.val_addr = addr;
4583 add_dwarf_attr (die, &attr);
4586 /* Get the RTX from to an address DIE attribute. */
4589 AT_addr (dw_attr_ref a)
4591 gcc_assert (a && AT_class (a) == dw_val_class_addr);
4592 return a->dw_attr_val.v.val_addr;
4595 /* Add a file attribute value to a DIE. */
4598 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
4599 struct dwarf_file_data *fd)
4603 attr.dw_attr = attr_kind;
4604 attr.dw_attr_val.val_class = dw_val_class_file;
4605 attr.dw_attr_val.v.val_file = fd;
4606 add_dwarf_attr (die, &attr);
4609 /* Get the dwarf_file_data from a file DIE attribute. */
4611 static inline struct dwarf_file_data *
4612 AT_file (dw_attr_ref a)
4614 gcc_assert (a && AT_class (a) == dw_val_class_file);
4615 return a->dw_attr_val.v.val_file;
4618 /* Add a vms delta attribute value to a DIE. */
4621 add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
4622 const char *lbl1, const char *lbl2)
4626 attr.dw_attr = attr_kind;
4627 attr.dw_attr_val.val_class = dw_val_class_vms_delta;
4628 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
4629 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
4630 add_dwarf_attr (die, &attr);
4633 /* Add a label identifier attribute value to a DIE. */
4636 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
4640 attr.dw_attr = attr_kind;
4641 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
4642 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
4643 add_dwarf_attr (die, &attr);
4646 /* Add a section offset attribute value to a DIE, an offset into the
4647 debug_line section. */
4650 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
4655 attr.dw_attr = attr_kind;
4656 attr.dw_attr_val.val_class = dw_val_class_lineptr;
4657 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
4658 add_dwarf_attr (die, &attr);
4661 /* Add a section offset attribute value to a DIE, an offset into the
4662 debug_macinfo section. */
4665 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
4670 attr.dw_attr = attr_kind;
4671 attr.dw_attr_val.val_class = dw_val_class_macptr;
4672 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
4673 add_dwarf_attr (die, &attr);
4676 /* Add an offset attribute value to a DIE. */
4679 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
4680 unsigned HOST_WIDE_INT offset)
4684 attr.dw_attr = attr_kind;
4685 attr.dw_attr_val.val_class = dw_val_class_offset;
4686 attr.dw_attr_val.v.val_offset = offset;
4687 add_dwarf_attr (die, &attr);
4690 /* Add an range_list attribute value to a DIE. */
4693 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
4694 long unsigned int offset)
4698 attr.dw_attr = attr_kind;
4699 attr.dw_attr_val.val_class = dw_val_class_range_list;
4700 attr.dw_attr_val.v.val_offset = offset;
4701 add_dwarf_attr (die, &attr);
4704 /* Return the start label of a delta attribute. */
4706 static inline const char *
4707 AT_vms_delta1 (dw_attr_ref a)
4709 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
4710 return a->dw_attr_val.v.val_vms_delta.lbl1;
4713 /* Return the end label of a delta attribute. */
4715 static inline const char *
4716 AT_vms_delta2 (dw_attr_ref a)
4718 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
4719 return a->dw_attr_val.v.val_vms_delta.lbl2;
4722 static inline const char *
4723 AT_lbl (dw_attr_ref a)
4725 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
4726 || AT_class (a) == dw_val_class_lineptr
4727 || AT_class (a) == dw_val_class_macptr));
4728 return a->dw_attr_val.v.val_lbl_id;
4731 /* Get the attribute of type attr_kind. */
4734 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4738 dw_die_ref spec = NULL;
4743 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
4744 if (a->dw_attr == attr_kind)
4746 else if (a->dw_attr == DW_AT_specification
4747 || a->dw_attr == DW_AT_abstract_origin)
4751 return get_AT (spec, attr_kind);
4756 /* Return the "low pc" attribute value, typically associated with a subprogram
4757 DIE. Return null if the "low pc" attribute is either not present, or if it
4758 cannot be represented as an assembler label identifier. */
4760 static inline const char *
4761 get_AT_low_pc (dw_die_ref die)
4763 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
4765 return a ? AT_lbl (a) : NULL;
4768 /* Return the "high pc" attribute value, typically associated with a subprogram
4769 DIE. Return null if the "high pc" attribute is either not present, or if it
4770 cannot be represented as an assembler label identifier. */
4772 static inline const char *
4773 get_AT_hi_pc (dw_die_ref die)
4775 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4777 return a ? AT_lbl (a) : NULL;
4780 /* Return the value of the string attribute designated by ATTR_KIND, or
4781 NULL if it is not present. */
4783 static inline const char *
4784 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
4786 dw_attr_ref a = get_AT (die, attr_kind);
4788 return a ? AT_string (a) : NULL;
4791 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4792 if it is not present. */
4795 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
4797 dw_attr_ref a = get_AT (die, attr_kind);
4799 return a ? AT_flag (a) : 0;
4802 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4803 if it is not present. */
4805 static inline unsigned
4806 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
4808 dw_attr_ref a = get_AT (die, attr_kind);
4810 return a ? AT_unsigned (a) : 0;
4813 static inline dw_die_ref
4814 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
4816 dw_attr_ref a = get_AT (die, attr_kind);
4818 return a ? AT_ref (a) : NULL;
4821 static inline struct dwarf_file_data *
4822 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
4824 dw_attr_ref a = get_AT (die, attr_kind);
4826 return a ? AT_file (a) : NULL;
4829 /* Return TRUE if the language is C++. */
4834 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4836 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
4839 /* Return TRUE if the language is Fortran. */
4844 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4846 return (lang == DW_LANG_Fortran77
4847 || lang == DW_LANG_Fortran90
4848 || lang == DW_LANG_Fortran95);
4851 /* Return TRUE if the language is Ada. */
4856 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4858 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
4861 /* Remove the specified attribute if present. */
4864 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4872 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
4873 if (a->dw_attr == attr_kind)
4875 if (AT_class (a) == dw_val_class_str)
4876 if (a->dw_attr_val.v.val_str->refcount)
4877 a->dw_attr_val.v.val_str->refcount--;
4879 /* VEC_ordered_remove should help reduce the number of abbrevs
4881 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
4886 /* Remove CHILD from its parent. PREV must have the property that
4887 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4890 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
4892 gcc_assert (child->die_parent == prev->die_parent);
4893 gcc_assert (prev->die_sib == child);
4896 gcc_assert (child->die_parent->die_child == child);
4900 prev->die_sib = child->die_sib;
4901 if (child->die_parent->die_child == child)
4902 child->die_parent->die_child = prev;
4905 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4906 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4909 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
4911 dw_die_ref parent = old_child->die_parent;
4913 gcc_assert (parent == prev->die_parent);
4914 gcc_assert (prev->die_sib == old_child);
4916 new_child->die_parent = parent;
4917 if (prev == old_child)
4919 gcc_assert (parent->die_child == old_child);
4920 new_child->die_sib = new_child;
4924 prev->die_sib = new_child;
4925 new_child->die_sib = old_child->die_sib;
4927 if (old_child->die_parent->die_child == old_child)
4928 old_child->die_parent->die_child = new_child;
4931 /* Move all children from OLD_PARENT to NEW_PARENT. */
4934 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
4937 new_parent->die_child = old_parent->die_child;
4938 old_parent->die_child = NULL;
4939 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
4942 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4946 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
4952 dw_die_ref prev = c;
4954 while (c->die_tag == tag)
4956 remove_child_with_prev (c, prev);
4957 /* Might have removed every child. */
4958 if (c == c->die_sib)
4962 } while (c != die->die_child);
4965 /* Add a CHILD_DIE as the last child of DIE. */
4968 add_child_die (dw_die_ref die, dw_die_ref child_die)
4970 /* FIXME this should probably be an assert. */
4971 if (! die || ! child_die)
4973 gcc_assert (die != child_die);
4975 child_die->die_parent = die;
4978 child_die->die_sib = die->die_child->die_sib;
4979 die->die_child->die_sib = child_die;
4982 child_die->die_sib = child_die;
4983 die->die_child = child_die;
4986 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4987 is the specification, to the end of PARENT's list of children.
4988 This is done by removing and re-adding it. */
4991 splice_child_die (dw_die_ref parent, dw_die_ref child)
4995 /* We want the declaration DIE from inside the class, not the
4996 specification DIE at toplevel. */
4997 if (child->die_parent != parent)
4999 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5005 gcc_assert (child->die_parent == parent
5006 || (child->die_parent
5007 == get_AT_ref (parent, DW_AT_specification)));
5009 for (p = child->die_parent->die_child; ; p = p->die_sib)
5010 if (p->die_sib == child)
5012 remove_child_with_prev (child, p);
5016 add_child_die (parent, child);
5019 /* Return a pointer to a newly created DIE node. */
5021 static inline dw_die_ref
5022 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5024 dw_die_ref die = ggc_alloc_cleared_die_node ();
5026 die->die_tag = tag_value;
5028 if (parent_die != NULL)
5029 add_child_die (parent_die, die);
5032 limbo_die_node *limbo_node;
5034 limbo_node = ggc_alloc_cleared_limbo_die_node ();
5035 limbo_node->die = die;
5036 limbo_node->created_for = t;
5037 limbo_node->next = limbo_die_list;
5038 limbo_die_list = limbo_node;
5044 /* Return the DIE associated with the given type specifier. */
5046 static inline dw_die_ref
5047 lookup_type_die (tree type)
5049 return TYPE_SYMTAB_DIE (type);
5052 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5053 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5054 anonymous type instead the one of the naming typedef. */
5056 static inline dw_die_ref
5057 strip_naming_typedef (tree type, dw_die_ref type_die)
5060 && TREE_CODE (type) == RECORD_TYPE
5062 && type_die->die_tag == DW_TAG_typedef
5063 && is_naming_typedef_decl (TYPE_NAME (type)))
5064 type_die = get_AT_ref (type_die, DW_AT_type);
5068 /* Like lookup_type_die, but if type is an anonymous type named by a
5069 typedef[1], return the DIE of the anonymous type instead the one of
5070 the naming typedef. This is because in gen_typedef_die, we did
5071 equate the anonymous struct named by the typedef with the DIE of
5072 the naming typedef. So by default, lookup_type_die on an anonymous
5073 struct yields the DIE of the naming typedef.
5075 [1]: Read the comment of is_naming_typedef_decl to learn about what
5076 a naming typedef is. */
5078 static inline dw_die_ref
5079 lookup_type_die_strip_naming_typedef (tree type)
5081 dw_die_ref die = lookup_type_die (type);
5082 return strip_naming_typedef (type, die);
5085 /* Equate a DIE to a given type specifier. */
5088 equate_type_number_to_die (tree type, dw_die_ref type_die)
5090 TYPE_SYMTAB_DIE (type) = type_die;
5093 /* Returns a hash value for X (which really is a die_struct). */
5096 decl_die_table_hash (const void *x)
5098 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
5101 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5104 decl_die_table_eq (const void *x, const void *y)
5106 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
5109 /* Return the DIE associated with a given declaration. */
5111 static inline dw_die_ref
5112 lookup_decl_die (tree decl)
5114 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5117 /* Returns a hash value for X (which really is a var_loc_list). */
5120 decl_loc_table_hash (const void *x)
5122 return (hashval_t) ((const var_loc_list *) x)->decl_id;
5125 /* Return nonzero if decl_id of var_loc_list X is the same as
5129 decl_loc_table_eq (const void *x, const void *y)
5131 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
5134 /* Return the var_loc list associated with a given declaration. */
5136 static inline var_loc_list *
5137 lookup_decl_loc (const_tree decl)
5139 if (!decl_loc_table)
5141 return (var_loc_list *)
5142 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5145 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
5148 cached_dw_loc_list_table_hash (const void *x)
5150 return (hashval_t) ((const cached_dw_loc_list *) x)->decl_id;
5153 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
5157 cached_dw_loc_list_table_eq (const void *x, const void *y)
5159 return (((const cached_dw_loc_list *) x)->decl_id
5160 == DECL_UID ((const_tree) y));
5163 /* Equate a DIE to a particular declaration. */
5166 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5168 unsigned int decl_id = DECL_UID (decl);
5171 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5173 decl_die->decl_id = decl_id;
5176 /* Return how many bits covers PIECE EXPR_LIST. */
5179 decl_piece_bitsize (rtx piece)
5181 int ret = (int) GET_MODE (piece);
5184 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
5185 && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
5186 return INTVAL (XEXP (XEXP (piece, 0), 0));
5189 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5192 decl_piece_varloc_ptr (rtx piece)
5194 if ((int) GET_MODE (piece))
5195 return &XEXP (piece, 0);
5197 return &XEXP (XEXP (piece, 0), 1);
5200 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5201 Next is the chain of following piece nodes. */
5204 decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
5206 if (bitsize <= (int) MAX_MACHINE_MODE)
5207 return alloc_EXPR_LIST (bitsize, loc_note, next);
5209 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
5214 /* Return rtx that should be stored into loc field for
5215 LOC_NOTE and BITPOS/BITSIZE. */
5218 construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
5219 HOST_WIDE_INT bitsize)
5223 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
5225 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
5230 /* This function either modifies location piece list *DEST in
5231 place (if SRC and INNER is NULL), or copies location piece list
5232 *SRC to *DEST while modifying it. Location BITPOS is modified
5233 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5234 not copied and if needed some padding around it is added.
5235 When modifying in place, DEST should point to EXPR_LIST where
5236 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5237 to the start of the whole list and INNER points to the EXPR_LIST
5238 where earlier pieces cover PIECE_BITPOS bits. */
5241 adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
5242 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
5243 HOST_WIDE_INT bitsize, rtx loc_note)
5246 bool copy = inner != NULL;
5250 /* First copy all nodes preceeding the current bitpos. */
5251 while (src != inner)
5253 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
5254 decl_piece_bitsize (*src), NULL_RTX);
5255 dest = &XEXP (*dest, 1);
5256 src = &XEXP (*src, 1);
5259 /* Add padding if needed. */
5260 if (bitpos != piece_bitpos)
5262 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
5263 copy ? NULL_RTX : *dest);
5264 dest = &XEXP (*dest, 1);
5266 else if (*dest && decl_piece_bitsize (*dest) == bitsize)
5269 /* A piece with correct bitpos and bitsize already exist,
5270 just update the location for it and return. */
5271 *decl_piece_varloc_ptr (*dest) = loc_note;
5274 /* Add the piece that changed. */
5275 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
5276 dest = &XEXP (*dest, 1);
5277 /* Skip over pieces that overlap it. */
5278 diff = bitpos - piece_bitpos + bitsize;
5281 while (diff > 0 && *src)
5284 diff -= decl_piece_bitsize (piece);
5286 src = &XEXP (piece, 1);
5289 *src = XEXP (piece, 1);
5290 free_EXPR_LIST_node (piece);
5293 /* Add padding if needed. */
5294 if (diff < 0 && *src)
5298 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
5299 dest = &XEXP (*dest, 1);
5303 /* Finally copy all nodes following it. */
5306 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
5307 decl_piece_bitsize (*src), NULL_RTX);
5308 dest = &XEXP (*dest, 1);
5309 src = &XEXP (*src, 1);
5313 /* Add a variable location node to the linked list for DECL. */
5315 static struct var_loc_node *
5316 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label)
5318 unsigned int decl_id;
5321 struct var_loc_node *loc = NULL;
5322 HOST_WIDE_INT bitsize = -1, bitpos = -1;
5324 if (DECL_DEBUG_EXPR_IS_FROM (decl))
5326 tree realdecl = DECL_DEBUG_EXPR (decl);
5327 if (realdecl && handled_component_p (realdecl))
5329 HOST_WIDE_INT maxsize;
5332 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize);
5333 if (!DECL_P (innerdecl)
5334 || DECL_IGNORED_P (innerdecl)
5335 || TREE_STATIC (innerdecl)
5337 || bitpos + bitsize > 256
5338 || bitsize != maxsize)
5344 decl_id = DECL_UID (decl);
5345 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5348 temp = ggc_alloc_cleared_var_loc_list ();
5349 temp->decl_id = decl_id;
5353 temp = (var_loc_list *) *slot;
5355 /* For PARM_DECLs try to keep around the original incoming value,
5356 even if that means we'll emit a zero-range .debug_loc entry. */
5358 && temp->first == temp->last
5359 && TREE_CODE (decl) == PARM_DECL
5360 && GET_CODE (temp->first->loc) == NOTE
5361 && NOTE_VAR_LOCATION_DECL (temp->first->loc) == decl
5362 && DECL_INCOMING_RTL (decl)
5363 && NOTE_VAR_LOCATION_LOC (temp->first->loc)
5364 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp->first->loc))
5365 == GET_CODE (DECL_INCOMING_RTL (decl))
5366 && prev_real_insn (temp->first->loc) == NULL_RTX
5368 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->first->loc),
5369 NOTE_VAR_LOCATION_LOC (loc_note))
5370 || (NOTE_VAR_LOCATION_STATUS (temp->first->loc)
5371 != NOTE_VAR_LOCATION_STATUS (loc_note))))
5373 loc = ggc_alloc_cleared_var_loc_node ();
5374 temp->first->next = loc;
5376 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5378 else if (temp->last)
5380 struct var_loc_node *last = temp->last, *unused = NULL;
5381 rtx *piece_loc = NULL, last_loc_note;
5382 int piece_bitpos = 0;
5386 gcc_assert (last->next == NULL);
5388 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
5390 piece_loc = &last->loc;
5393 int cur_bitsize = decl_piece_bitsize (*piece_loc);
5394 if (piece_bitpos + cur_bitsize > bitpos)
5396 piece_bitpos += cur_bitsize;
5397 piece_loc = &XEXP (*piece_loc, 1);
5401 /* TEMP->LAST here is either pointer to the last but one or
5402 last element in the chained list, LAST is pointer to the
5404 if (label && strcmp (last->label, label) == 0)
5406 /* For SRA optimized variables if there weren't any real
5407 insns since last note, just modify the last node. */
5408 if (piece_loc != NULL)
5410 adjust_piece_list (piece_loc, NULL, NULL,
5411 bitpos, piece_bitpos, bitsize, loc_note);
5414 /* If the last note doesn't cover any instructions, remove it. */
5415 if (temp->last != last)
5417 temp->last->next = NULL;
5420 gcc_assert (strcmp (last->label, label) != 0);
5424 gcc_assert (temp->first == temp->last
5425 || (temp->first->next == temp->last
5426 && TREE_CODE (decl) == PARM_DECL));
5427 memset (temp->last, '\0', sizeof (*temp->last));
5428 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
5432 if (bitsize == -1 && NOTE_P (last->loc))
5433 last_loc_note = last->loc;
5434 else if (piece_loc != NULL
5435 && *piece_loc != NULL_RTX
5436 && piece_bitpos == bitpos
5437 && decl_piece_bitsize (*piece_loc) == bitsize)
5438 last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
5440 last_loc_note = NULL_RTX;
5441 /* If the current location is the same as the end of the list,
5442 and either both or neither of the locations is uninitialized,
5443 we have nothing to do. */
5444 if (last_loc_note == NULL_RTX
5445 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
5446 NOTE_VAR_LOCATION_LOC (loc_note)))
5447 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
5448 != NOTE_VAR_LOCATION_STATUS (loc_note))
5449 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
5450 == VAR_INIT_STATUS_UNINITIALIZED)
5451 || (NOTE_VAR_LOCATION_STATUS (loc_note)
5452 == VAR_INIT_STATUS_UNINITIALIZED))))
5454 /* Add LOC to the end of list and update LAST. If the last
5455 element of the list has been removed above, reuse its
5456 memory for the new node, otherwise allocate a new one. */
5460 memset (loc, '\0', sizeof (*loc));
5463 loc = ggc_alloc_cleared_var_loc_node ();
5464 if (bitsize == -1 || piece_loc == NULL)
5465 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5467 adjust_piece_list (&loc->loc, &last->loc, piece_loc,
5468 bitpos, piece_bitpos, bitsize, loc_note);
5470 /* Ensure TEMP->LAST will point either to the new last but one
5471 element of the chain, or to the last element in it. */
5472 if (last != temp->last)
5480 loc = ggc_alloc_cleared_var_loc_node ();
5483 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5488 /* Keep track of the number of spaces used to indent the
5489 output of the debugging routines that print the structure of
5490 the DIE internal representation. */
5491 static int print_indent;
5493 /* Indent the line the number of spaces given by print_indent. */
5496 print_spaces (FILE *outfile)
5498 fprintf (outfile, "%*s", print_indent, "");
5501 /* Print a type signature in hex. */
5504 print_signature (FILE *outfile, char *sig)
5508 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
5509 fprintf (outfile, "%02x", sig[i] & 0xff);
5512 /* Print the information associated with a given DIE, and its children.
5513 This routine is a debugging aid only. */
5516 print_die (dw_die_ref die, FILE *outfile)
5522 print_spaces (outfile);
5523 fprintf (outfile, "DIE %4ld: %s (%p)\n",
5524 die->die_offset, dwarf_tag_name (die->die_tag),
5526 print_spaces (outfile);
5527 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5528 fprintf (outfile, " offset: %ld", die->die_offset);
5529 fprintf (outfile, " mark: %d\n", die->die_mark);
5531 if (use_debug_types && die->die_id.die_type_node)
5533 print_spaces (outfile);
5534 fprintf (outfile, " signature: ");
5535 print_signature (outfile, die->die_id.die_type_node->signature);
5536 fprintf (outfile, "\n");
5539 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
5541 print_spaces (outfile);
5542 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5544 switch (AT_class (a))
5546 case dw_val_class_addr:
5547 fprintf (outfile, "address");
5549 case dw_val_class_offset:
5550 fprintf (outfile, "offset");
5552 case dw_val_class_loc:
5553 fprintf (outfile, "location descriptor");
5555 case dw_val_class_loc_list:
5556 fprintf (outfile, "location list -> label:%s",
5557 AT_loc_list (a)->ll_symbol);
5559 case dw_val_class_range_list:
5560 fprintf (outfile, "range list");
5562 case dw_val_class_const:
5563 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5565 case dw_val_class_unsigned_const:
5566 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5568 case dw_val_class_const_double:
5569 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\
5570 HOST_WIDE_INT_PRINT_UNSIGNED")",
5571 a->dw_attr_val.v.val_double.high,
5572 a->dw_attr_val.v.val_double.low);
5574 case dw_val_class_vec:
5575 fprintf (outfile, "floating-point or vector constant");
5577 case dw_val_class_flag:
5578 fprintf (outfile, "%u", AT_flag (a));
5580 case dw_val_class_die_ref:
5581 if (AT_ref (a) != NULL)
5583 if (use_debug_types && AT_ref (a)->die_id.die_type_node)
5585 fprintf (outfile, "die -> signature: ");
5586 print_signature (outfile,
5587 AT_ref (a)->die_id.die_type_node->signature);
5589 else if (! use_debug_types && AT_ref (a)->die_id.die_symbol)
5590 fprintf (outfile, "die -> label: %s",
5591 AT_ref (a)->die_id.die_symbol);
5593 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
5594 fprintf (outfile, " (%p)", (void *) AT_ref (a));
5597 fprintf (outfile, "die -> <null>");
5599 case dw_val_class_vms_delta:
5600 fprintf (outfile, "delta: @slotcount(%s-%s)",
5601 AT_vms_delta2 (a), AT_vms_delta1 (a));
5603 case dw_val_class_lbl_id:
5604 case dw_val_class_lineptr:
5605 case dw_val_class_macptr:
5606 fprintf (outfile, "label: %s", AT_lbl (a));
5608 case dw_val_class_str:
5609 if (AT_string (a) != NULL)
5610 fprintf (outfile, "\"%s\"", AT_string (a));
5612 fprintf (outfile, "<null>");
5614 case dw_val_class_file:
5615 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
5616 AT_file (a)->emitted_number);
5618 case dw_val_class_data8:
5622 for (i = 0; i < 8; i++)
5623 fprintf (outfile, "%02x", a->dw_attr_val.v.val_data8[i]);
5630 fprintf (outfile, "\n");
5633 if (die->die_child != NULL)
5636 FOR_EACH_CHILD (die, c, print_die (c, outfile));
5639 if (print_indent == 0)
5640 fprintf (outfile, "\n");
5643 /* Print the information collected for a given DIE. */
5646 debug_dwarf_die (dw_die_ref die)
5648 print_die (die, stderr);
5651 /* Print all DWARF information collected for the compilation unit.
5652 This routine is a debugging aid only. */
5658 print_die (comp_unit_die (), stderr);
5661 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5662 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5663 DIE that marks the start of the DIEs for this include file. */
5666 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5668 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5669 dw_die_ref new_unit = gen_compile_unit_die (filename);
5671 new_unit->die_sib = old_unit;
5675 /* Close an include-file CU and reopen the enclosing one. */
5678 pop_compile_unit (dw_die_ref old_unit)
5680 dw_die_ref new_unit = old_unit->die_sib;
5682 old_unit->die_sib = NULL;
5686 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5687 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5689 /* Calculate the checksum of a location expression. */
5692 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5696 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
5698 CHECKSUM (loc->dw_loc_oprnd1);
5699 CHECKSUM (loc->dw_loc_oprnd2);
5702 /* Calculate the checksum of an attribute. */
5705 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5707 dw_loc_descr_ref loc;
5710 CHECKSUM (at->dw_attr);
5712 /* We don't care that this was compiled with a different compiler
5713 snapshot; if the output is the same, that's what matters. */
5714 if (at->dw_attr == DW_AT_producer)
5717 switch (AT_class (at))
5719 case dw_val_class_const:
5720 CHECKSUM (at->dw_attr_val.v.val_int);
5722 case dw_val_class_unsigned_const:
5723 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5725 case dw_val_class_const_double:
5726 CHECKSUM (at->dw_attr_val.v.val_double);
5728 case dw_val_class_vec:
5729 CHECKSUM (at->dw_attr_val.v.val_vec);
5731 case dw_val_class_flag:
5732 CHECKSUM (at->dw_attr_val.v.val_flag);
5734 case dw_val_class_str:
5735 CHECKSUM_STRING (AT_string (at));
5738 case dw_val_class_addr:
5740 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5741 CHECKSUM_STRING (XSTR (r, 0));
5744 case dw_val_class_offset:
5745 CHECKSUM (at->dw_attr_val.v.val_offset);
5748 case dw_val_class_loc:
5749 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5750 loc_checksum (loc, ctx);
5753 case dw_val_class_die_ref:
5754 die_checksum (AT_ref (at), ctx, mark);
5757 case dw_val_class_fde_ref:
5758 case dw_val_class_vms_delta:
5759 case dw_val_class_lbl_id:
5760 case dw_val_class_lineptr:
5761 case dw_val_class_macptr:
5764 case dw_val_class_file:
5765 CHECKSUM_STRING (AT_file (at)->filename);
5768 case dw_val_class_data8:
5769 CHECKSUM (at->dw_attr_val.v.val_data8);
5777 /* Calculate the checksum of a DIE. */
5780 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5786 /* To avoid infinite recursion. */
5789 CHECKSUM (die->die_mark);
5792 die->die_mark = ++(*mark);
5794 CHECKSUM (die->die_tag);
5796 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
5797 attr_checksum (a, ctx, mark);
5799 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
5803 #undef CHECKSUM_STRING
5805 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
5806 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5807 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
5808 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
5809 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
5810 #define CHECKSUM_ATTR(FOO) \
5811 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
5813 /* Calculate the checksum of a number in signed LEB128 format. */
5816 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
5823 byte = (value & 0x7f);
5825 more = !((value == 0 && (byte & 0x40) == 0)
5826 || (value == -1 && (byte & 0x40) != 0));
5835 /* Calculate the checksum of a number in unsigned LEB128 format. */
5838 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
5842 unsigned char byte = (value & 0x7f);
5845 /* More bytes to follow. */
5853 /* Checksum the context of the DIE. This adds the names of any
5854 surrounding namespaces or structures to the checksum. */
5857 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
5861 int tag = die->die_tag;
5863 if (tag != DW_TAG_namespace
5864 && tag != DW_TAG_structure_type
5865 && tag != DW_TAG_class_type)
5868 name = get_AT_string (die, DW_AT_name);
5870 spec = get_AT_ref (die, DW_AT_specification);
5874 if (die->die_parent != NULL)
5875 checksum_die_context (die->die_parent, ctx);
5877 CHECKSUM_ULEB128 ('C');
5878 CHECKSUM_ULEB128 (tag);
5880 CHECKSUM_STRING (name);
5883 /* Calculate the checksum of a location expression. */
5886 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5888 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
5889 were emitted as a DW_FORM_sdata instead of a location expression. */
5890 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
5892 CHECKSUM_ULEB128 (DW_FORM_sdata);
5893 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
5897 /* Otherwise, just checksum the raw location expression. */
5900 CHECKSUM_ULEB128 (loc->dw_loc_opc);
5901 CHECKSUM (loc->dw_loc_oprnd1);
5902 CHECKSUM (loc->dw_loc_oprnd2);
5903 loc = loc->dw_loc_next;
5907 /* Calculate the checksum of an attribute. */
5910 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at,
5911 struct md5_ctx *ctx, int *mark)
5913 dw_loc_descr_ref loc;
5916 if (AT_class (at) == dw_val_class_die_ref)
5918 dw_die_ref target_die = AT_ref (at);
5920 /* For pointer and reference types, we checksum only the (qualified)
5921 name of the target type (if there is a name). For friend entries,
5922 we checksum only the (qualified) name of the target type or function.
5923 This allows the checksum to remain the same whether the target type
5924 is complete or not. */
5925 if ((at->dw_attr == DW_AT_type
5926 && (tag == DW_TAG_pointer_type
5927 || tag == DW_TAG_reference_type
5928 || tag == DW_TAG_rvalue_reference_type
5929 || tag == DW_TAG_ptr_to_member_type))
5930 || (at->dw_attr == DW_AT_friend
5931 && tag == DW_TAG_friend))
5933 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name);
5935 if (name_attr != NULL)
5937 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
5941 CHECKSUM_ULEB128 ('N');
5942 CHECKSUM_ULEB128 (at->dw_attr);
5943 if (decl->die_parent != NULL)
5944 checksum_die_context (decl->die_parent, ctx);
5945 CHECKSUM_ULEB128 ('E');
5946 CHECKSUM_STRING (AT_string (name_attr));
5951 /* For all other references to another DIE, we check to see if the
5952 target DIE has already been visited. If it has, we emit a
5953 backward reference; if not, we descend recursively. */
5954 if (target_die->die_mark > 0)
5956 CHECKSUM_ULEB128 ('R');
5957 CHECKSUM_ULEB128 (at->dw_attr);
5958 CHECKSUM_ULEB128 (target_die->die_mark);
5962 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
5966 target_die->die_mark = ++(*mark);
5967 CHECKSUM_ULEB128 ('T');
5968 CHECKSUM_ULEB128 (at->dw_attr);
5969 if (decl->die_parent != NULL)
5970 checksum_die_context (decl->die_parent, ctx);
5971 die_checksum_ordered (target_die, ctx, mark);
5976 CHECKSUM_ULEB128 ('A');
5977 CHECKSUM_ULEB128 (at->dw_attr);
5979 switch (AT_class (at))
5981 case dw_val_class_const:
5982 CHECKSUM_ULEB128 (DW_FORM_sdata);
5983 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
5986 case dw_val_class_unsigned_const:
5987 CHECKSUM_ULEB128 (DW_FORM_sdata);
5988 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
5991 case dw_val_class_const_double:
5992 CHECKSUM_ULEB128 (DW_FORM_block);
5993 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
5994 CHECKSUM (at->dw_attr_val.v.val_double);
5997 case dw_val_class_vec:
5998 CHECKSUM_ULEB128 (DW_FORM_block);
5999 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_vec));
6000 CHECKSUM (at->dw_attr_val.v.val_vec);
6003 case dw_val_class_flag:
6004 CHECKSUM_ULEB128 (DW_FORM_flag);
6005 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
6008 case dw_val_class_str:
6009 CHECKSUM_ULEB128 (DW_FORM_string);
6010 CHECKSUM_STRING (AT_string (at));
6013 case dw_val_class_addr:
6015 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6016 CHECKSUM_ULEB128 (DW_FORM_string);
6017 CHECKSUM_STRING (XSTR (r, 0));
6020 case dw_val_class_offset:
6021 CHECKSUM_ULEB128 (DW_FORM_sdata);
6022 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
6025 case dw_val_class_loc:
6026 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6027 loc_checksum_ordered (loc, ctx);
6030 case dw_val_class_fde_ref:
6031 case dw_val_class_lbl_id:
6032 case dw_val_class_lineptr:
6033 case dw_val_class_macptr:
6036 case dw_val_class_file:
6037 CHECKSUM_ULEB128 (DW_FORM_string);
6038 CHECKSUM_STRING (AT_file (at)->filename);
6041 case dw_val_class_data8:
6042 CHECKSUM (at->dw_attr_val.v.val_data8);
6050 struct checksum_attributes
6052 dw_attr_ref at_name;
6053 dw_attr_ref at_type;
6054 dw_attr_ref at_friend;
6055 dw_attr_ref at_accessibility;
6056 dw_attr_ref at_address_class;
6057 dw_attr_ref at_allocated;
6058 dw_attr_ref at_artificial;
6059 dw_attr_ref at_associated;
6060 dw_attr_ref at_binary_scale;
6061 dw_attr_ref at_bit_offset;
6062 dw_attr_ref at_bit_size;
6063 dw_attr_ref at_bit_stride;
6064 dw_attr_ref at_byte_size;
6065 dw_attr_ref at_byte_stride;
6066 dw_attr_ref at_const_value;
6067 dw_attr_ref at_containing_type;
6068 dw_attr_ref at_count;
6069 dw_attr_ref at_data_location;
6070 dw_attr_ref at_data_member_location;
6071 dw_attr_ref at_decimal_scale;
6072 dw_attr_ref at_decimal_sign;
6073 dw_attr_ref at_default_value;
6074 dw_attr_ref at_digit_count;
6075 dw_attr_ref at_discr;
6076 dw_attr_ref at_discr_list;
6077 dw_attr_ref at_discr_value;
6078 dw_attr_ref at_encoding;
6079 dw_attr_ref at_endianity;
6080 dw_attr_ref at_explicit;
6081 dw_attr_ref at_is_optional;
6082 dw_attr_ref at_location;
6083 dw_attr_ref at_lower_bound;
6084 dw_attr_ref at_mutable;
6085 dw_attr_ref at_ordering;
6086 dw_attr_ref at_picture_string;
6087 dw_attr_ref at_prototyped;
6088 dw_attr_ref at_small;
6089 dw_attr_ref at_segment;
6090 dw_attr_ref at_string_length;
6091 dw_attr_ref at_threads_scaled;
6092 dw_attr_ref at_upper_bound;
6093 dw_attr_ref at_use_location;
6094 dw_attr_ref at_use_UTF8;
6095 dw_attr_ref at_variable_parameter;
6096 dw_attr_ref at_virtuality;
6097 dw_attr_ref at_visibility;
6098 dw_attr_ref at_vtable_elem_location;
6101 /* Collect the attributes that we will want to use for the checksum. */
6104 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
6109 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
6120 attrs->at_friend = a;
6122 case DW_AT_accessibility:
6123 attrs->at_accessibility = a;
6125 case DW_AT_address_class:
6126 attrs->at_address_class = a;
6128 case DW_AT_allocated:
6129 attrs->at_allocated = a;
6131 case DW_AT_artificial:
6132 attrs->at_artificial = a;
6134 case DW_AT_associated:
6135 attrs->at_associated = a;
6137 case DW_AT_binary_scale:
6138 attrs->at_binary_scale = a;
6140 case DW_AT_bit_offset:
6141 attrs->at_bit_offset = a;
6143 case DW_AT_bit_size:
6144 attrs->at_bit_size = a;
6146 case DW_AT_bit_stride:
6147 attrs->at_bit_stride = a;
6149 case DW_AT_byte_size:
6150 attrs->at_byte_size = a;
6152 case DW_AT_byte_stride:
6153 attrs->at_byte_stride = a;
6155 case DW_AT_const_value:
6156 attrs->at_const_value = a;
6158 case DW_AT_containing_type:
6159 attrs->at_containing_type = a;
6162 attrs->at_count = a;
6164 case DW_AT_data_location:
6165 attrs->at_data_location = a;
6167 case DW_AT_data_member_location:
6168 attrs->at_data_member_location = a;
6170 case DW_AT_decimal_scale:
6171 attrs->at_decimal_scale = a;
6173 case DW_AT_decimal_sign:
6174 attrs->at_decimal_sign = a;
6176 case DW_AT_default_value:
6177 attrs->at_default_value = a;
6179 case DW_AT_digit_count:
6180 attrs->at_digit_count = a;
6183 attrs->at_discr = a;
6185 case DW_AT_discr_list:
6186 attrs->at_discr_list = a;
6188 case DW_AT_discr_value:
6189 attrs->at_discr_value = a;
6191 case DW_AT_encoding:
6192 attrs->at_encoding = a;
6194 case DW_AT_endianity:
6195 attrs->at_endianity = a;
6197 case DW_AT_explicit:
6198 attrs->at_explicit = a;
6200 case DW_AT_is_optional:
6201 attrs->at_is_optional = a;
6203 case DW_AT_location:
6204 attrs->at_location = a;
6206 case DW_AT_lower_bound:
6207 attrs->at_lower_bound = a;
6210 attrs->at_mutable = a;
6212 case DW_AT_ordering:
6213 attrs->at_ordering = a;
6215 case DW_AT_picture_string:
6216 attrs->at_picture_string = a;
6218 case DW_AT_prototyped:
6219 attrs->at_prototyped = a;
6222 attrs->at_small = a;
6225 attrs->at_segment = a;
6227 case DW_AT_string_length:
6228 attrs->at_string_length = a;
6230 case DW_AT_threads_scaled:
6231 attrs->at_threads_scaled = a;
6233 case DW_AT_upper_bound:
6234 attrs->at_upper_bound = a;
6236 case DW_AT_use_location:
6237 attrs->at_use_location = a;
6239 case DW_AT_use_UTF8:
6240 attrs->at_use_UTF8 = a;
6242 case DW_AT_variable_parameter:
6243 attrs->at_variable_parameter = a;
6245 case DW_AT_virtuality:
6246 attrs->at_virtuality = a;
6248 case DW_AT_visibility:
6249 attrs->at_visibility = a;
6251 case DW_AT_vtable_elem_location:
6252 attrs->at_vtable_elem_location = a;
6260 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6263 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6267 struct checksum_attributes attrs;
6269 CHECKSUM_ULEB128 ('D');
6270 CHECKSUM_ULEB128 (die->die_tag);
6272 memset (&attrs, 0, sizeof (attrs));
6274 decl = get_AT_ref (die, DW_AT_specification);
6276 collect_checksum_attributes (&attrs, decl);
6277 collect_checksum_attributes (&attrs, die);
6279 CHECKSUM_ATTR (attrs.at_name);
6280 CHECKSUM_ATTR (attrs.at_accessibility);
6281 CHECKSUM_ATTR (attrs.at_address_class);
6282 CHECKSUM_ATTR (attrs.at_allocated);
6283 CHECKSUM_ATTR (attrs.at_artificial);
6284 CHECKSUM_ATTR (attrs.at_associated);
6285 CHECKSUM_ATTR (attrs.at_binary_scale);
6286 CHECKSUM_ATTR (attrs.at_bit_offset);
6287 CHECKSUM_ATTR (attrs.at_bit_size);
6288 CHECKSUM_ATTR (attrs.at_bit_stride);
6289 CHECKSUM_ATTR (attrs.at_byte_size);
6290 CHECKSUM_ATTR (attrs.at_byte_stride);
6291 CHECKSUM_ATTR (attrs.at_const_value);
6292 CHECKSUM_ATTR (attrs.at_containing_type);
6293 CHECKSUM_ATTR (attrs.at_count);
6294 CHECKSUM_ATTR (attrs.at_data_location);
6295 CHECKSUM_ATTR (attrs.at_data_member_location);
6296 CHECKSUM_ATTR (attrs.at_decimal_scale);
6297 CHECKSUM_ATTR (attrs.at_decimal_sign);
6298 CHECKSUM_ATTR (attrs.at_default_value);
6299 CHECKSUM_ATTR (attrs.at_digit_count);
6300 CHECKSUM_ATTR (attrs.at_discr);
6301 CHECKSUM_ATTR (attrs.at_discr_list);
6302 CHECKSUM_ATTR (attrs.at_discr_value);
6303 CHECKSUM_ATTR (attrs.at_encoding);
6304 CHECKSUM_ATTR (attrs.at_endianity);
6305 CHECKSUM_ATTR (attrs.at_explicit);
6306 CHECKSUM_ATTR (attrs.at_is_optional);
6307 CHECKSUM_ATTR (attrs.at_location);
6308 CHECKSUM_ATTR (attrs.at_lower_bound);
6309 CHECKSUM_ATTR (attrs.at_mutable);
6310 CHECKSUM_ATTR (attrs.at_ordering);
6311 CHECKSUM_ATTR (attrs.at_picture_string);
6312 CHECKSUM_ATTR (attrs.at_prototyped);
6313 CHECKSUM_ATTR (attrs.at_small);
6314 CHECKSUM_ATTR (attrs.at_segment);
6315 CHECKSUM_ATTR (attrs.at_string_length);
6316 CHECKSUM_ATTR (attrs.at_threads_scaled);
6317 CHECKSUM_ATTR (attrs.at_upper_bound);
6318 CHECKSUM_ATTR (attrs.at_use_location);
6319 CHECKSUM_ATTR (attrs.at_use_UTF8);
6320 CHECKSUM_ATTR (attrs.at_variable_parameter);
6321 CHECKSUM_ATTR (attrs.at_virtuality);
6322 CHECKSUM_ATTR (attrs.at_visibility);
6323 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
6324 CHECKSUM_ATTR (attrs.at_type);
6325 CHECKSUM_ATTR (attrs.at_friend);
6327 /* Checksum the child DIEs, except for nested types and member functions. */
6330 dw_attr_ref name_attr;
6333 name_attr = get_AT (c, DW_AT_name);
6334 if ((is_type_die (c) || c->die_tag == DW_TAG_subprogram)
6335 && name_attr != NULL)
6337 CHECKSUM_ULEB128 ('S');
6338 CHECKSUM_ULEB128 (c->die_tag);
6339 CHECKSUM_STRING (AT_string (name_attr));
6343 /* Mark this DIE so it gets processed when unmarking. */
6344 if (c->die_mark == 0)
6346 die_checksum_ordered (c, ctx, mark);
6348 } while (c != die->die_child);
6350 CHECKSUM_ULEB128 (0);
6354 #undef CHECKSUM_STRING
6355 #undef CHECKSUM_ATTR
6356 #undef CHECKSUM_LEB128
6357 #undef CHECKSUM_ULEB128
6359 /* Generate the type signature for DIE. This is computed by generating an
6360 MD5 checksum over the DIE's tag, its relevant attributes, and its
6361 children. Attributes that are references to other DIEs are processed
6362 by recursion, using the MARK field to prevent infinite recursion.
6363 If the DIE is nested inside a namespace or another type, we also
6364 need to include that context in the signature. The lower 64 bits
6365 of the resulting MD5 checksum comprise the signature. */
6368 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
6372 unsigned char checksum[16];
6376 name = get_AT_string (die, DW_AT_name);
6377 decl = get_AT_ref (die, DW_AT_specification);
6379 /* First, compute a signature for just the type name (and its surrounding
6380 context, if any. This is stored in the type unit DIE for link-time
6381 ODR (one-definition rule) checking. */
6383 if (is_cxx() && name != NULL)
6385 md5_init_ctx (&ctx);
6387 /* Checksum the names of surrounding namespaces and structures. */
6388 if (decl != NULL && decl->die_parent != NULL)
6389 checksum_die_context (decl->die_parent, &ctx);
6391 md5_process_bytes (&die->die_tag, sizeof (die->die_tag), &ctx);
6392 md5_process_bytes (name, strlen (name) + 1, &ctx);
6393 md5_finish_ctx (&ctx, checksum);
6395 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
6398 /* Next, compute the complete type signature. */
6400 md5_init_ctx (&ctx);
6402 die->die_mark = mark;
6404 /* Checksum the names of surrounding namespaces and structures. */
6405 if (decl != NULL && decl->die_parent != NULL)
6406 checksum_die_context (decl->die_parent, &ctx);
6408 /* Checksum the DIE and its children. */
6409 die_checksum_ordered (die, &ctx, &mark);
6410 unmark_all_dies (die);
6411 md5_finish_ctx (&ctx, checksum);
6413 /* Store the signature in the type node and link the type DIE and the
6414 type node together. */
6415 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
6416 DWARF_TYPE_SIGNATURE_SIZE);
6417 die->die_id.die_type_node = type_node;
6418 type_node->type_die = die;
6420 /* If the DIE is a specification, link its declaration to the type node
6423 decl->die_id.die_type_node = type_node;
6426 /* Do the location expressions look same? */
6428 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6430 return loc1->dw_loc_opc == loc2->dw_loc_opc
6431 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6432 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6435 /* Do the values look the same? */
6437 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6439 dw_loc_descr_ref loc1, loc2;
6442 if (v1->val_class != v2->val_class)
6445 switch (v1->val_class)
6447 case dw_val_class_const:
6448 return v1->v.val_int == v2->v.val_int;
6449 case dw_val_class_unsigned_const:
6450 return v1->v.val_unsigned == v2->v.val_unsigned;
6451 case dw_val_class_const_double:
6452 return v1->v.val_double.high == v2->v.val_double.high
6453 && v1->v.val_double.low == v2->v.val_double.low;
6454 case dw_val_class_vec:
6455 if (v1->v.val_vec.length != v2->v.val_vec.length
6456 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6458 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6459 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6462 case dw_val_class_flag:
6463 return v1->v.val_flag == v2->v.val_flag;
6464 case dw_val_class_str:
6465 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6467 case dw_val_class_addr:
6468 r1 = v1->v.val_addr;
6469 r2 = v2->v.val_addr;
6470 if (GET_CODE (r1) != GET_CODE (r2))
6472 return !rtx_equal_p (r1, r2);
6474 case dw_val_class_offset:
6475 return v1->v.val_offset == v2->v.val_offset;
6477 case dw_val_class_loc:
6478 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6480 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6481 if (!same_loc_p (loc1, loc2, mark))
6483 return !loc1 && !loc2;
6485 case dw_val_class_die_ref:
6486 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6488 case dw_val_class_fde_ref:
6489 case dw_val_class_vms_delta:
6490 case dw_val_class_lbl_id:
6491 case dw_val_class_lineptr:
6492 case dw_val_class_macptr:
6495 case dw_val_class_file:
6496 return v1->v.val_file == v2->v.val_file;
6498 case dw_val_class_data8:
6499 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
6506 /* Do the attributes look the same? */
6509 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6511 if (at1->dw_attr != at2->dw_attr)
6514 /* We don't care that this was compiled with a different compiler
6515 snapshot; if the output is the same, that's what matters. */
6516 if (at1->dw_attr == DW_AT_producer)
6519 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6522 /* Do the dies look the same? */
6525 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6531 /* To avoid infinite recursion. */
6533 return die1->die_mark == die2->die_mark;
6534 die1->die_mark = die2->die_mark = ++(*mark);
6536 if (die1->die_tag != die2->die_tag)
6539 if (VEC_length (dw_attr_node, die1->die_attr)
6540 != VEC_length (dw_attr_node, die2->die_attr))
6543 FOR_EACH_VEC_ELT (dw_attr_node, die1->die_attr, ix, a1)
6544 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
6547 c1 = die1->die_child;
6548 c2 = die2->die_child;
6557 if (!same_die_p (c1, c2, mark))
6561 if (c1 == die1->die_child)
6563 if (c2 == die2->die_child)
6573 /* Do the dies look the same? Wrapper around same_die_p. */
6576 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6579 int ret = same_die_p (die1, die2, &mark);
6581 unmark_all_dies (die1);
6582 unmark_all_dies (die2);
6587 /* The prefix to attach to symbols on DIEs in the current comdat debug
6589 static char *comdat_symbol_id;
6591 /* The index of the current symbol within the current comdat CU. */
6592 static unsigned int comdat_symbol_number;
6594 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6595 children, and set comdat_symbol_id accordingly. */
6598 compute_section_prefix (dw_die_ref unit_die)
6600 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6601 const char *base = die_name ? lbasename (die_name) : "anonymous";
6602 char *name = XALLOCAVEC (char, strlen (base) + 64);
6605 unsigned char checksum[16];
6608 /* Compute the checksum of the DIE, then append part of it as hex digits to
6609 the name filename of the unit. */
6611 md5_init_ctx (&ctx);
6613 die_checksum (unit_die, &ctx, &mark);
6614 unmark_all_dies (unit_die);
6615 md5_finish_ctx (&ctx, checksum);
6617 sprintf (name, "%s.", base);
6618 clean_symbol_name (name);
6620 p = name + strlen (name);
6621 for (i = 0; i < 4; i++)
6623 sprintf (p, "%.2x", checksum[i]);
6627 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name);
6628 comdat_symbol_number = 0;
6631 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6634 is_type_die (dw_die_ref die)
6636 switch (die->die_tag)
6638 case DW_TAG_array_type:
6639 case DW_TAG_class_type:
6640 case DW_TAG_interface_type:
6641 case DW_TAG_enumeration_type:
6642 case DW_TAG_pointer_type:
6643 case DW_TAG_reference_type:
6644 case DW_TAG_rvalue_reference_type:
6645 case DW_TAG_string_type:
6646 case DW_TAG_structure_type:
6647 case DW_TAG_subroutine_type:
6648 case DW_TAG_union_type:
6649 case DW_TAG_ptr_to_member_type:
6650 case DW_TAG_set_type:
6651 case DW_TAG_subrange_type:
6652 case DW_TAG_base_type:
6653 case DW_TAG_const_type:
6654 case DW_TAG_file_type:
6655 case DW_TAG_packed_type:
6656 case DW_TAG_volatile_type:
6657 case DW_TAG_typedef:
6664 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6665 Basically, we want to choose the bits that are likely to be shared between
6666 compilations (types) and leave out the bits that are specific to individual
6667 compilations (functions). */
6670 is_comdat_die (dw_die_ref c)
6672 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6673 we do for stabs. The advantage is a greater likelihood of sharing between
6674 objects that don't include headers in the same order (and therefore would
6675 put the base types in a different comdat). jason 8/28/00 */
6677 if (c->die_tag == DW_TAG_base_type)
6680 if (c->die_tag == DW_TAG_pointer_type
6681 || c->die_tag == DW_TAG_reference_type
6682 || c->die_tag == DW_TAG_rvalue_reference_type
6683 || c->die_tag == DW_TAG_const_type
6684 || c->die_tag == DW_TAG_volatile_type)
6686 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6688 return t ? is_comdat_die (t) : 0;
6691 return is_type_die (c);
6694 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6695 compilation unit. */
6698 is_symbol_die (dw_die_ref c)
6700 return (is_type_die (c)
6701 || is_declaration_die (c)
6702 || c->die_tag == DW_TAG_namespace
6703 || c->die_tag == DW_TAG_module);
6706 /* Returns true iff C is a compile-unit DIE. */
6709 is_cu_die (dw_die_ref c)
6711 return c && c->die_tag == DW_TAG_compile_unit;
6715 gen_internal_sym (const char *prefix)
6719 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6720 return xstrdup (buf);
6723 /* Assign symbols to all worthy DIEs under DIE. */
6726 assign_symbol_names (dw_die_ref die)
6730 if (is_symbol_die (die))
6732 if (comdat_symbol_id)
6734 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
6736 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6737 comdat_symbol_id, comdat_symbol_number++);
6738 die->die_id.die_symbol = xstrdup (p);
6741 die->die_id.die_symbol = gen_internal_sym ("LDIE");
6744 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6747 struct cu_hash_table_entry
6750 unsigned min_comdat_num, max_comdat_num;
6751 struct cu_hash_table_entry *next;
6754 /* Routines to manipulate hash table of CUs. */
6756 htab_cu_hash (const void *of)
6758 const struct cu_hash_table_entry *const entry =
6759 (const struct cu_hash_table_entry *) of;
6761 return htab_hash_string (entry->cu->die_id.die_symbol);
6765 htab_cu_eq (const void *of1, const void *of2)
6767 const struct cu_hash_table_entry *const entry1 =
6768 (const struct cu_hash_table_entry *) of1;
6769 const struct die_struct *const entry2 = (const struct die_struct *) of2;
6771 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol);
6775 htab_cu_del (void *what)
6777 struct cu_hash_table_entry *next,
6778 *entry = (struct cu_hash_table_entry *) what;
6788 /* Check whether we have already seen this CU and set up SYM_NUM
6791 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6793 struct cu_hash_table_entry dummy;
6794 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6796 dummy.max_comdat_num = 0;
6798 slot = (struct cu_hash_table_entry **)
6799 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
6803 for (; entry; last = entry, entry = entry->next)
6805 if (same_die_p_wrap (cu, entry->cu))
6811 *sym_num = entry->min_comdat_num;
6815 entry = XCNEW (struct cu_hash_table_entry);
6817 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6818 entry->next = *slot;
6824 /* Record SYM_NUM to record of CU in HTABLE. */
6826 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6828 struct cu_hash_table_entry **slot, *entry;
6830 slot = (struct cu_hash_table_entry **)
6831 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
6835 entry->max_comdat_num = sym_num;
6838 /* Traverse the DIE (which is always comp_unit_die), and set up
6839 additional compilation units for each of the include files we see
6840 bracketed by BINCL/EINCL. */
6843 break_out_includes (dw_die_ref die)
6846 dw_die_ref unit = NULL;
6847 limbo_die_node *node, **pnode;
6848 htab_t cu_hash_table;
6852 dw_die_ref prev = c;
6854 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6855 || (unit && is_comdat_die (c)))
6857 dw_die_ref next = c->die_sib;
6859 /* This DIE is for a secondary CU; remove it from the main one. */
6860 remove_child_with_prev (c, prev);
6862 if (c->die_tag == DW_TAG_GNU_BINCL)
6863 unit = push_new_compile_unit (unit, c);
6864 else if (c->die_tag == DW_TAG_GNU_EINCL)
6865 unit = pop_compile_unit (unit);
6867 add_child_die (unit, c);
6869 if (c == die->die_child)
6872 } while (c != die->die_child);
6875 /* We can only use this in debugging, since the frontend doesn't check
6876 to make sure that we leave every include file we enter. */
6880 assign_symbol_names (die);
6881 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6882 for (node = limbo_die_list, pnode = &limbo_die_list;
6888 compute_section_prefix (node->die);
6889 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6890 &comdat_symbol_number);
6891 assign_symbol_names (node->die);
6893 *pnode = node->next;
6896 pnode = &node->next;
6897 record_comdat_symbol_number (node->die, cu_hash_table,
6898 comdat_symbol_number);
6901 htab_delete (cu_hash_table);
6904 /* Return non-zero if this DIE is a declaration. */
6907 is_declaration_die (dw_die_ref die)
6912 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
6913 if (a->dw_attr == DW_AT_declaration)
6919 /* Return non-zero if this DIE is nested inside a subprogram. */
6922 is_nested_in_subprogram (dw_die_ref die)
6924 dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
6928 return local_scope_p (decl);
6931 /* Return non-zero if this DIE contains a defining declaration of a
6935 contains_subprogram_definition (dw_die_ref die)
6939 if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die))
6941 FOR_EACH_CHILD (die, c, if (contains_subprogram_definition(c)) return 1);
6945 /* Return non-zero if this is a type DIE that should be moved to a
6946 COMDAT .debug_types section. */
6949 should_move_die_to_comdat (dw_die_ref die)
6951 switch (die->die_tag)
6953 case DW_TAG_class_type:
6954 case DW_TAG_structure_type:
6955 case DW_TAG_enumeration_type:
6956 case DW_TAG_union_type:
6957 /* Don't move declarations, inlined instances, or types nested in a
6959 if (is_declaration_die (die)
6960 || get_AT (die, DW_AT_abstract_origin)
6961 || is_nested_in_subprogram (die))
6963 /* A type definition should never contain a subprogram definition. */
6964 gcc_assert (!contains_subprogram_definition (die));
6966 case DW_TAG_array_type:
6967 case DW_TAG_interface_type:
6968 case DW_TAG_pointer_type:
6969 case DW_TAG_reference_type:
6970 case DW_TAG_rvalue_reference_type:
6971 case DW_TAG_string_type:
6972 case DW_TAG_subroutine_type:
6973 case DW_TAG_ptr_to_member_type:
6974 case DW_TAG_set_type:
6975 case DW_TAG_subrange_type:
6976 case DW_TAG_base_type:
6977 case DW_TAG_const_type:
6978 case DW_TAG_file_type:
6979 case DW_TAG_packed_type:
6980 case DW_TAG_volatile_type:
6981 case DW_TAG_typedef:
6987 /* Make a clone of DIE. */
6990 clone_die (dw_die_ref die)
6996 clone = ggc_alloc_cleared_die_node ();
6997 clone->die_tag = die->die_tag;
6999 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7000 add_dwarf_attr (clone, a);
7005 /* Make a clone of the tree rooted at DIE. */
7008 clone_tree (dw_die_ref die)
7011 dw_die_ref clone = clone_die (die);
7013 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree(c)));
7018 /* Make a clone of DIE as a declaration. */
7021 clone_as_declaration (dw_die_ref die)
7028 /* If the DIE is already a declaration, just clone it. */
7029 if (is_declaration_die (die))
7030 return clone_die (die);
7032 /* If the DIE is a specification, just clone its declaration DIE. */
7033 decl = get_AT_ref (die, DW_AT_specification);
7035 return clone_die (decl);
7037 clone = ggc_alloc_cleared_die_node ();
7038 clone->die_tag = die->die_tag;
7040 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7042 /* We don't want to copy over all attributes.
7043 For example we don't want DW_AT_byte_size because otherwise we will no
7044 longer have a declaration and GDB will treat it as a definition. */
7048 case DW_AT_artificial:
7049 case DW_AT_containing_type:
7050 case DW_AT_external:
7053 case DW_AT_virtuality:
7054 case DW_AT_linkage_name:
7055 case DW_AT_MIPS_linkage_name:
7056 add_dwarf_attr (clone, a);
7058 case DW_AT_byte_size:
7064 if (die->die_id.die_type_node)
7065 add_AT_die_ref (clone, DW_AT_signature, die);
7067 add_AT_flag (clone, DW_AT_declaration, 1);
7071 /* Copy the declaration context to the new compile unit DIE. This includes
7072 any surrounding namespace or type declarations. If the DIE has an
7073 AT_specification attribute, it also includes attributes and children
7074 attached to the specification. */
7077 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
7080 dw_die_ref new_decl;
7082 decl = get_AT_ref (die, DW_AT_specification);
7091 /* Copy the type node pointer from the new DIE to the original
7092 declaration DIE so we can forward references later. */
7093 decl->die_id.die_type_node = die->die_id.die_type_node;
7095 remove_AT (die, DW_AT_specification);
7097 FOR_EACH_VEC_ELT (dw_attr_node, decl->die_attr, ix, a)
7099 if (a->dw_attr != DW_AT_name
7100 && a->dw_attr != DW_AT_declaration
7101 && a->dw_attr != DW_AT_external)
7102 add_dwarf_attr (die, a);
7105 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree(c)));
7108 if (decl->die_parent != NULL
7109 && decl->die_parent->die_tag != DW_TAG_compile_unit
7110 && decl->die_parent->die_tag != DW_TAG_type_unit)
7112 new_decl = copy_ancestor_tree (unit, decl, NULL);
7113 if (new_decl != NULL)
7115 remove_AT (new_decl, DW_AT_signature);
7116 add_AT_specification (die, new_decl);
7121 /* Generate the skeleton ancestor tree for the given NODE, then clone
7122 the DIE and add the clone into the tree. */
7125 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
7127 if (node->new_die != NULL)
7130 node->new_die = clone_as_declaration (node->old_die);
7132 if (node->parent != NULL)
7134 generate_skeleton_ancestor_tree (node->parent);
7135 add_child_die (node->parent->new_die, node->new_die);
7139 /* Generate a skeleton tree of DIEs containing any declarations that are
7140 found in the original tree. We traverse the tree looking for declaration
7141 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7144 generate_skeleton_bottom_up (skeleton_chain_node *parent)
7146 skeleton_chain_node node;
7149 dw_die_ref prev = NULL;
7150 dw_die_ref next = NULL;
7152 node.parent = parent;
7154 first = c = parent->old_die->die_child;
7158 if (prev == NULL || prev->die_sib == c)
7161 next = (c == first ? NULL : c->die_sib);
7163 node.new_die = NULL;
7164 if (is_declaration_die (c))
7166 /* Clone the existing DIE, move the original to the skeleton
7167 tree (which is in the main CU), and put the clone, with
7168 all the original's children, where the original came from. */
7169 dw_die_ref clone = clone_die (c);
7170 move_all_children (c, clone);
7172 replace_child (c, clone, prev);
7173 generate_skeleton_ancestor_tree (parent);
7174 add_child_die (parent->new_die, c);
7178 generate_skeleton_bottom_up (&node);
7179 } while (next != NULL);
7182 /* Wrapper function for generate_skeleton_bottom_up. */
7185 generate_skeleton (dw_die_ref die)
7187 skeleton_chain_node node;
7190 node.new_die = NULL;
7193 /* If this type definition is nested inside another type,
7194 always leave at least a declaration in its place. */
7195 if (die->die_parent != NULL && is_type_die (die->die_parent))
7196 node.new_die = clone_as_declaration (die);
7198 generate_skeleton_bottom_up (&node);
7199 return node.new_die;
7202 /* Remove the DIE from its parent, possibly replacing it with a cloned
7203 declaration. The original DIE will be moved to a new compile unit
7204 so that existing references to it follow it to the new location. If
7205 any of the original DIE's descendants is a declaration, we need to
7206 replace the original DIE with a skeleton tree and move the
7207 declarations back into the skeleton tree. */
7210 remove_child_or_replace_with_skeleton (dw_die_ref child, dw_die_ref prev)
7212 dw_die_ref skeleton;
7214 skeleton = generate_skeleton (child);
7215 if (skeleton == NULL)
7216 remove_child_with_prev (child, prev);
7219 skeleton->die_id.die_type_node = child->die_id.die_type_node;
7220 replace_child (child, skeleton, prev);
7226 /* Traverse the DIE and set up additional .debug_types sections for each
7227 type worthy of being placed in a COMDAT section. */
7230 break_out_comdat_types (dw_die_ref die)
7234 dw_die_ref prev = NULL;
7235 dw_die_ref next = NULL;
7236 dw_die_ref unit = NULL;
7238 first = c = die->die_child;
7242 if (prev == NULL || prev->die_sib == c)
7245 next = (c == first ? NULL : c->die_sib);
7246 if (should_move_die_to_comdat (c))
7248 dw_die_ref replacement;
7249 comdat_type_node_ref type_node;
7251 /* Create a new type unit DIE as the root for the new tree, and
7252 add it to the list of comdat types. */
7253 unit = new_die (DW_TAG_type_unit, NULL, NULL);
7254 add_AT_unsigned (unit, DW_AT_language,
7255 get_AT_unsigned (comp_unit_die (), DW_AT_language));
7256 type_node = ggc_alloc_cleared_comdat_type_node ();
7257 type_node->root_die = unit;
7258 type_node->next = comdat_type_list;
7259 comdat_type_list = type_node;
7261 /* Generate the type signature. */
7262 generate_type_signature (c, type_node);
7264 /* Copy the declaration context, attributes, and children of the
7265 declaration into the new compile unit DIE. */
7266 copy_declaration_context (unit, c);
7268 /* Remove this DIE from the main CU. */
7269 replacement = remove_child_or_replace_with_skeleton (c, prev);
7271 /* Break out nested types into their own type units. */
7272 break_out_comdat_types (c);
7274 /* Add the DIE to the new compunit. */
7275 add_child_die (unit, c);
7277 if (replacement != NULL)
7280 else if (c->die_tag == DW_TAG_namespace
7281 || c->die_tag == DW_TAG_class_type
7282 || c->die_tag == DW_TAG_structure_type
7283 || c->die_tag == DW_TAG_union_type)
7285 /* Look for nested types that can be broken out. */
7286 break_out_comdat_types (c);
7288 } while (next != NULL);
7291 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7293 struct decl_table_entry
7299 /* Routines to manipulate hash table of copied declarations. */
7302 htab_decl_hash (const void *of)
7304 const struct decl_table_entry *const entry =
7305 (const struct decl_table_entry *) of;
7307 return htab_hash_pointer (entry->orig);
7311 htab_decl_eq (const void *of1, const void *of2)
7313 const struct decl_table_entry *const entry1 =
7314 (const struct decl_table_entry *) of1;
7315 const struct die_struct *const entry2 = (const struct die_struct *) of2;
7317 return entry1->orig == entry2;
7321 htab_decl_del (void *what)
7323 struct decl_table_entry *entry = (struct decl_table_entry *) what;
7328 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7329 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7330 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7331 to check if the ancestor has already been copied into UNIT. */
7334 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
7336 dw_die_ref parent = die->die_parent;
7337 dw_die_ref new_parent = unit;
7340 struct decl_table_entry *entry = NULL;
7344 /* Check if the entry has already been copied to UNIT. */
7345 slot = htab_find_slot_with_hash (decl_table, die,
7346 htab_hash_pointer (die), INSERT);
7347 if (*slot != HTAB_EMPTY_ENTRY)
7349 entry = (struct decl_table_entry *) *slot;
7353 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7354 entry = XCNEW (struct decl_table_entry);
7362 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
7365 if (parent->die_tag != DW_TAG_compile_unit
7366 && parent->die_tag != DW_TAG_type_unit)
7367 new_parent = copy_ancestor_tree (unit, parent, decl_table);
7370 copy = clone_as_declaration (die);
7371 add_child_die (new_parent, copy);
7373 if (decl_table != NULL)
7375 /* Record the pointer to the copy. */
7382 /* Walk the DIE and its children, looking for references to incomplete
7383 or trivial types that are unmarked (i.e., that are not in the current
7387 copy_decls_walk (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
7393 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7395 if (AT_class (a) == dw_val_class_die_ref)
7397 dw_die_ref targ = AT_ref (a);
7398 comdat_type_node_ref type_node = targ->die_id.die_type_node;
7400 struct decl_table_entry *entry;
7402 if (targ->die_mark != 0 || type_node != NULL)
7405 slot = htab_find_slot_with_hash (decl_table, targ,
7406 htab_hash_pointer (targ), INSERT);
7408 if (*slot != HTAB_EMPTY_ENTRY)
7410 /* TARG has already been copied, so we just need to
7411 modify the reference to point to the copy. */
7412 entry = (struct decl_table_entry *) *slot;
7413 a->dw_attr_val.v.val_die_ref.die = entry->copy;
7417 dw_die_ref parent = unit;
7418 dw_die_ref copy = clone_tree (targ);
7420 /* Make sure the cloned tree is marked as part of the
7424 /* Record in DECL_TABLE that TARG has been copied.
7425 Need to do this now, before the recursive call,
7426 because DECL_TABLE may be expanded and SLOT
7427 would no longer be a valid pointer. */
7428 entry = XCNEW (struct decl_table_entry);
7433 /* If TARG has surrounding context, copy its ancestor tree
7434 into the new type unit. */
7435 if (targ->die_parent != NULL
7436 && targ->die_parent->die_tag != DW_TAG_compile_unit
7437 && targ->die_parent->die_tag != DW_TAG_type_unit)
7438 parent = copy_ancestor_tree (unit, targ->die_parent,
7441 add_child_die (parent, copy);
7442 a->dw_attr_val.v.val_die_ref.die = copy;
7444 /* Make sure the newly-copied DIE is walked. If it was
7445 installed in a previously-added context, it won't
7446 get visited otherwise. */
7449 /* Find the highest point of the newly-added tree,
7450 mark each node along the way, and walk from there. */
7451 parent->die_mark = 1;
7452 while (parent->die_parent
7453 && parent->die_parent->die_mark == 0)
7455 parent = parent->die_parent;
7456 parent->die_mark = 1;
7458 copy_decls_walk (unit, parent, decl_table);
7464 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
7467 /* Copy declarations for "unworthy" types into the new comdat section.
7468 Incomplete types, modified types, and certain other types aren't broken
7469 out into comdat sections of their own, so they don't have a signature,
7470 and we need to copy the declaration into the same section so that we
7471 don't have an external reference. */
7474 copy_decls_for_unworthy_types (dw_die_ref unit)
7479 decl_table = htab_create (10, htab_decl_hash, htab_decl_eq, htab_decl_del);
7480 copy_decls_walk (unit, unit, decl_table);
7481 htab_delete (decl_table);
7485 /* Traverse the DIE and add a sibling attribute if it may have the
7486 effect of speeding up access to siblings. To save some space,
7487 avoid generating sibling attributes for DIE's without children. */
7490 add_sibling_attributes (dw_die_ref die)
7494 if (! die->die_child)
7497 if (die->die_parent && die != die->die_parent->die_child)
7498 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7500 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7503 /* Output all location lists for the DIE and its children. */
7506 output_location_lists (dw_die_ref die)
7512 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7513 if (AT_class (a) == dw_val_class_loc_list)
7514 output_loc_list (AT_loc_list (a));
7516 FOR_EACH_CHILD (die, c, output_location_lists (c));
7519 /* The format of each DIE (and its attribute value pairs) is encoded in an
7520 abbreviation table. This routine builds the abbreviation table and assigns
7521 a unique abbreviation id for each abbreviation entry. The children of each
7522 die are visited recursively. */
7525 build_abbrev_table (dw_die_ref die)
7527 unsigned long abbrev_id;
7528 unsigned int n_alloc;
7533 /* Scan the DIE references, and mark as external any that refer to
7534 DIEs from other CUs (i.e. those which are not marked). */
7535 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7536 if (AT_class (a) == dw_val_class_die_ref
7537 && AT_ref (a)->die_mark == 0)
7539 gcc_assert (use_debug_types || AT_ref (a)->die_id.die_symbol);
7540 set_AT_ref_external (a, 1);
7543 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7545 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7546 dw_attr_ref die_a, abbrev_a;
7550 if (abbrev->die_tag != die->die_tag)
7552 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7555 if (VEC_length (dw_attr_node, abbrev->die_attr)
7556 != VEC_length (dw_attr_node, die->die_attr))
7559 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, die_a)
7561 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
7562 if ((abbrev_a->dw_attr != die_a->dw_attr)
7563 || (value_format (abbrev_a) != value_format (die_a)))
7573 if (abbrev_id >= abbrev_die_table_in_use)
7575 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7577 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7578 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7581 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7582 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7583 abbrev_die_table_allocated = n_alloc;
7586 ++abbrev_die_table_in_use;
7587 abbrev_die_table[abbrev_id] = die;
7590 die->die_abbrev = abbrev_id;
7591 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
7594 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7597 constant_size (unsigned HOST_WIDE_INT value)
7604 log = floor_log2 (value);
7607 log = 1 << (floor_log2 (log) + 1);
7612 /* Return the size of a DIE as it is represented in the
7613 .debug_info section. */
7615 static unsigned long
7616 size_of_die (dw_die_ref die)
7618 unsigned long size = 0;
7622 size += size_of_uleb128 (die->die_abbrev);
7623 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7625 switch (AT_class (a))
7627 case dw_val_class_addr:
7628 size += DWARF2_ADDR_SIZE;
7630 case dw_val_class_offset:
7631 size += DWARF_OFFSET_SIZE;
7633 case dw_val_class_loc:
7635 unsigned long lsize = size_of_locs (AT_loc (a));
7638 if (dwarf_version >= 4)
7639 size += size_of_uleb128 (lsize);
7641 size += constant_size (lsize);
7645 case dw_val_class_loc_list:
7646 size += DWARF_OFFSET_SIZE;
7648 case dw_val_class_range_list:
7649 size += DWARF_OFFSET_SIZE;
7651 case dw_val_class_const:
7652 size += size_of_sleb128 (AT_int (a));
7654 case dw_val_class_unsigned_const:
7656 int csize = constant_size (AT_unsigned (a));
7657 if (dwarf_version == 3
7658 && a->dw_attr == DW_AT_data_member_location
7660 size += size_of_uleb128 (AT_unsigned (a));
7665 case dw_val_class_const_double:
7666 size += 2 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
7667 if (HOST_BITS_PER_WIDE_INT >= 64)
7670 case dw_val_class_vec:
7671 size += constant_size (a->dw_attr_val.v.val_vec.length
7672 * a->dw_attr_val.v.val_vec.elt_size)
7673 + a->dw_attr_val.v.val_vec.length
7674 * a->dw_attr_val.v.val_vec.elt_size; /* block */
7676 case dw_val_class_flag:
7677 if (dwarf_version >= 4)
7678 /* Currently all add_AT_flag calls pass in 1 as last argument,
7679 so DW_FORM_flag_present can be used. If that ever changes,
7680 we'll need to use DW_FORM_flag and have some optimization
7681 in build_abbrev_table that will change those to
7682 DW_FORM_flag_present if it is set to 1 in all DIEs using
7683 the same abbrev entry. */
7684 gcc_assert (a->dw_attr_val.v.val_flag == 1);
7688 case dw_val_class_die_ref:
7689 if (AT_ref_external (a))
7691 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
7692 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
7693 is sized by target address length, whereas in DWARF3
7694 it's always sized as an offset. */
7695 if (use_debug_types)
7696 size += DWARF_TYPE_SIGNATURE_SIZE;
7697 else if (dwarf_version == 2)
7698 size += DWARF2_ADDR_SIZE;
7700 size += DWARF_OFFSET_SIZE;
7703 size += DWARF_OFFSET_SIZE;
7705 case dw_val_class_fde_ref:
7706 size += DWARF_OFFSET_SIZE;
7708 case dw_val_class_lbl_id:
7709 size += DWARF2_ADDR_SIZE;
7711 case dw_val_class_lineptr:
7712 case dw_val_class_macptr:
7713 size += DWARF_OFFSET_SIZE;
7715 case dw_val_class_str:
7716 if (AT_string_form (a) == DW_FORM_strp)
7717 size += DWARF_OFFSET_SIZE;
7719 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
7721 case dw_val_class_file:
7722 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
7724 case dw_val_class_data8:
7727 case dw_val_class_vms_delta:
7728 size += DWARF_OFFSET_SIZE;
7738 /* Size the debugging information associated with a given DIE. Visits the
7739 DIE's children recursively. Updates the global variable next_die_offset, on
7740 each time through. Uses the current value of next_die_offset to update the
7741 die_offset field in each DIE. */
7744 calc_die_sizes (dw_die_ref die)
7748 gcc_assert (die->die_offset == 0
7749 || (unsigned long int) die->die_offset == next_die_offset);
7750 die->die_offset = next_die_offset;
7751 next_die_offset += size_of_die (die);
7753 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
7755 if (die->die_child != NULL)
7756 /* Count the null byte used to terminate sibling lists. */
7757 next_die_offset += 1;
7760 /* Size just the base type children at the start of the CU.
7761 This is needed because build_abbrev needs to size locs
7762 and sizing of type based stack ops needs to know die_offset
7763 values for the base types. */
7766 calc_base_type_die_sizes (void)
7768 unsigned long die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7770 dw_die_ref base_type;
7771 #if ENABLE_ASSERT_CHECKING
7772 dw_die_ref prev = comp_unit_die ()->die_child;
7775 die_offset += size_of_die (comp_unit_die ());
7776 for (i = 0; VEC_iterate (dw_die_ref, base_types, i, base_type); i++)
7778 #if ENABLE_ASSERT_CHECKING
7779 gcc_assert (base_type->die_offset == 0
7780 && prev->die_sib == base_type
7781 && base_type->die_child == NULL
7782 && base_type->die_abbrev);
7785 base_type->die_offset = die_offset;
7786 die_offset += size_of_die (base_type);
7790 /* Set the marks for a die and its children. We do this so
7791 that we know whether or not a reference needs to use FORM_ref_addr; only
7792 DIEs in the same CU will be marked. We used to clear out the offset
7793 and use that as the flag, but ran into ordering problems. */
7796 mark_dies (dw_die_ref die)
7800 gcc_assert (!die->die_mark);
7803 FOR_EACH_CHILD (die, c, mark_dies (c));
7806 /* Clear the marks for a die and its children. */
7809 unmark_dies (dw_die_ref die)
7813 if (! use_debug_types)
7814 gcc_assert (die->die_mark);
7817 FOR_EACH_CHILD (die, c, unmark_dies (c));
7820 /* Clear the marks for a die, its children and referred dies. */
7823 unmark_all_dies (dw_die_ref die)
7833 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
7835 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7836 if (AT_class (a) == dw_val_class_die_ref)
7837 unmark_all_dies (AT_ref (a));
7840 /* Return the size of the .debug_pubnames or .debug_pubtypes table
7841 generated for the compilation unit. */
7843 static unsigned long
7844 size_of_pubnames (VEC (pubname_entry, gc) * names)
7850 size = DWARF_PUBNAMES_HEADER_SIZE;
7851 FOR_EACH_VEC_ELT (pubname_entry, names, i, p)
7852 if (names != pubtype_table
7853 || p->die->die_offset != 0
7854 || !flag_eliminate_unused_debug_types)
7855 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
7857 size += DWARF_OFFSET_SIZE;
7861 /* Return the size of the information in the .debug_aranges section. */
7863 static unsigned long
7864 size_of_aranges (void)
7868 size = DWARF_ARANGES_HEADER_SIZE;
7870 /* Count the address/length pair for this compilation unit. */
7871 if (text_section_used)
7872 size += 2 * DWARF2_ADDR_SIZE;
7873 if (cold_text_section_used)
7874 size += 2 * DWARF2_ADDR_SIZE;
7875 if (have_multiple_function_sections)
7880 FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, fde_idx, fde)
7882 if (!fde->in_std_section)
7883 size += 2 * DWARF2_ADDR_SIZE;
7884 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
7885 size += 2 * DWARF2_ADDR_SIZE;
7889 /* Count the two zero words used to terminated the address range table. */
7890 size += 2 * DWARF2_ADDR_SIZE;
7894 /* Select the encoding of an attribute value. */
7896 static enum dwarf_form
7897 value_format (dw_attr_ref a)
7899 switch (a->dw_attr_val.val_class)
7901 case dw_val_class_addr:
7902 /* Only very few attributes allow DW_FORM_addr. */
7907 case DW_AT_entry_pc:
7908 case DW_AT_trampoline:
7909 return DW_FORM_addr;
7913 switch (DWARF2_ADDR_SIZE)
7916 return DW_FORM_data1;
7918 return DW_FORM_data2;
7920 return DW_FORM_data4;
7922 return DW_FORM_data8;
7926 case dw_val_class_range_list:
7927 case dw_val_class_loc_list:
7928 if (dwarf_version >= 4)
7929 return DW_FORM_sec_offset;
7931 case dw_val_class_vms_delta:
7932 case dw_val_class_offset:
7933 switch (DWARF_OFFSET_SIZE)
7936 return DW_FORM_data4;
7938 return DW_FORM_data8;
7942 case dw_val_class_loc:
7943 if (dwarf_version >= 4)
7944 return DW_FORM_exprloc;
7945 switch (constant_size (size_of_locs (AT_loc (a))))
7948 return DW_FORM_block1;
7950 return DW_FORM_block2;
7954 case dw_val_class_const:
7955 return DW_FORM_sdata;
7956 case dw_val_class_unsigned_const:
7957 switch (constant_size (AT_unsigned (a)))
7960 return DW_FORM_data1;
7962 return DW_FORM_data2;
7964 /* In DWARF3 DW_AT_data_member_location with
7965 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
7966 constant, so we need to use DW_FORM_udata if we need
7967 a large constant. */
7968 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
7969 return DW_FORM_udata;
7970 return DW_FORM_data4;
7972 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
7973 return DW_FORM_udata;
7974 return DW_FORM_data8;
7978 case dw_val_class_const_double:
7979 switch (HOST_BITS_PER_WIDE_INT)
7982 return DW_FORM_data2;
7984 return DW_FORM_data4;
7986 return DW_FORM_data8;
7989 return DW_FORM_block1;
7991 case dw_val_class_vec:
7992 switch (constant_size (a->dw_attr_val.v.val_vec.length
7993 * a->dw_attr_val.v.val_vec.elt_size))
7996 return DW_FORM_block1;
7998 return DW_FORM_block2;
8000 return DW_FORM_block4;
8004 case dw_val_class_flag:
8005 if (dwarf_version >= 4)
8007 /* Currently all add_AT_flag calls pass in 1 as last argument,
8008 so DW_FORM_flag_present can be used. If that ever changes,
8009 we'll need to use DW_FORM_flag and have some optimization
8010 in build_abbrev_table that will change those to
8011 DW_FORM_flag_present if it is set to 1 in all DIEs using
8012 the same abbrev entry. */
8013 gcc_assert (a->dw_attr_val.v.val_flag == 1);
8014 return DW_FORM_flag_present;
8016 return DW_FORM_flag;
8017 case dw_val_class_die_ref:
8018 if (AT_ref_external (a))
8019 return use_debug_types ? DW_FORM_ref_sig8 : DW_FORM_ref_addr;
8022 case dw_val_class_fde_ref:
8023 return DW_FORM_data;
8024 case dw_val_class_lbl_id:
8025 return DW_FORM_addr;
8026 case dw_val_class_lineptr:
8027 case dw_val_class_macptr:
8028 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data;
8029 case dw_val_class_str:
8030 return AT_string_form (a);
8031 case dw_val_class_file:
8032 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
8035 return DW_FORM_data1;
8037 return DW_FORM_data2;
8039 return DW_FORM_data4;
8044 case dw_val_class_data8:
8045 return DW_FORM_data8;
8052 /* Output the encoding of an attribute value. */
8055 output_value_format (dw_attr_ref a)
8057 enum dwarf_form form = value_format (a);
8059 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
8062 /* Output the .debug_abbrev section which defines the DIE abbreviation
8066 output_abbrev_section (void)
8068 unsigned long abbrev_id;
8070 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8072 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
8076 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
8077 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
8078 dwarf_tag_name (abbrev->die_tag));
8080 if (abbrev->die_child != NULL)
8081 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
8083 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
8085 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
8088 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
8089 dwarf_attr_name (a_attr->dw_attr));
8090 output_value_format (a_attr);
8093 dw2_asm_output_data (1, 0, NULL);
8094 dw2_asm_output_data (1, 0, NULL);
8097 /* Terminate the table. */
8098 dw2_asm_output_data (1, 0, NULL);
8101 /* Output a symbol we can use to refer to this DIE from another CU. */
8104 output_die_symbol (dw_die_ref die)
8106 char *sym = die->die_id.die_symbol;
8111 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
8112 /* We make these global, not weak; if the target doesn't support
8113 .linkonce, it doesn't support combining the sections, so debugging
8115 targetm.asm_out.globalize_label (asm_out_file, sym);
8117 ASM_OUTPUT_LABEL (asm_out_file, sym);
8120 /* Return a new location list, given the begin and end range, and the
8123 static inline dw_loc_list_ref
8124 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
8125 const char *section)
8127 dw_loc_list_ref retlist = ggc_alloc_cleared_dw_loc_list_node ();
8129 retlist->begin = begin;
8131 retlist->expr = expr;
8132 retlist->section = section;
8137 /* Generate a new internal symbol for this location list node, if it
8138 hasn't got one yet. */
8141 gen_llsym (dw_loc_list_ref list)
8143 gcc_assert (!list->ll_symbol);
8144 list->ll_symbol = gen_internal_sym ("LLST");
8147 /* Output the location list given to us. */
8150 output_loc_list (dw_loc_list_ref list_head)
8152 dw_loc_list_ref curr = list_head;
8154 if (list_head->emitted)
8156 list_head->emitted = true;
8158 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
8160 /* Walk the location list, and output each range + expression. */
8161 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
8164 /* Don't output an entry that starts and ends at the same address. */
8165 if (strcmp (curr->begin, curr->end) == 0 && !curr->force)
8167 if (!have_multiple_function_sections)
8169 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
8170 "Location list begin address (%s)",
8171 list_head->ll_symbol);
8172 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
8173 "Location list end address (%s)",
8174 list_head->ll_symbol);
8178 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
8179 "Location list begin address (%s)",
8180 list_head->ll_symbol);
8181 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
8182 "Location list end address (%s)",
8183 list_head->ll_symbol);
8185 size = size_of_locs (curr->expr);
8187 /* Output the block length for this list of location operations. */
8188 gcc_assert (size <= 0xffff);
8189 dw2_asm_output_data (2, size, "%s", "Location expression size");
8191 output_loc_sequence (curr->expr, -1);
8194 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8195 "Location list terminator begin (%s)",
8196 list_head->ll_symbol);
8197 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8198 "Location list terminator end (%s)",
8199 list_head->ll_symbol);
8202 /* Output a type signature. */
8205 output_signature (const char *sig, const char *name)
8209 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8210 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
8213 /* Output the DIE and its attributes. Called recursively to generate
8214 the definitions of each child DIE. */
8217 output_die (dw_die_ref die)
8224 /* If someone in another CU might refer to us, set up a symbol for
8225 them to point to. */
8226 if (! use_debug_types && die->die_id.die_symbol)
8227 output_die_symbol (die);
8229 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)",
8230 (unsigned long)die->die_offset,
8231 dwarf_tag_name (die->die_tag));
8233 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
8235 const char *name = dwarf_attr_name (a->dw_attr);
8237 switch (AT_class (a))
8239 case dw_val_class_addr:
8240 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8243 case dw_val_class_offset:
8244 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8248 case dw_val_class_range_list:
8250 char *p = strchr (ranges_section_label, '\0');
8252 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
8253 a->dw_attr_val.v.val_offset);
8254 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8255 debug_ranges_section, "%s", name);
8260 case dw_val_class_loc:
8261 size = size_of_locs (AT_loc (a));
8263 /* Output the block length for this list of location operations. */
8264 if (dwarf_version >= 4)
8265 dw2_asm_output_data_uleb128 (size, "%s", name);
8267 dw2_asm_output_data (constant_size (size), size, "%s", name);
8269 output_loc_sequence (AT_loc (a), -1);
8272 case dw_val_class_const:
8273 /* ??? It would be slightly more efficient to use a scheme like is
8274 used for unsigned constants below, but gdb 4.x does not sign
8275 extend. Gdb 5.x does sign extend. */
8276 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8279 case dw_val_class_unsigned_const:
8281 int csize = constant_size (AT_unsigned (a));
8282 if (dwarf_version == 3
8283 && a->dw_attr == DW_AT_data_member_location
8285 dw2_asm_output_data_uleb128 (AT_unsigned (a), "%s", name);
8287 dw2_asm_output_data (csize, AT_unsigned (a), "%s", name);
8291 case dw_val_class_const_double:
8293 unsigned HOST_WIDE_INT first, second;
8295 if (HOST_BITS_PER_WIDE_INT >= 64)
8296 dw2_asm_output_data (1,
8297 2 * HOST_BITS_PER_WIDE_INT
8298 / HOST_BITS_PER_CHAR,
8301 if (WORDS_BIG_ENDIAN)
8303 first = a->dw_attr_val.v.val_double.high;
8304 second = a->dw_attr_val.v.val_double.low;
8308 first = a->dw_attr_val.v.val_double.low;
8309 second = a->dw_attr_val.v.val_double.high;
8312 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8314 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8319 case dw_val_class_vec:
8321 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8322 unsigned int len = a->dw_attr_val.v.val_vec.length;
8326 dw2_asm_output_data (constant_size (len * elt_size),
8327 len * elt_size, "%s", name);
8328 if (elt_size > sizeof (HOST_WIDE_INT))
8333 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8336 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8337 "fp or vector constant word %u", i);
8341 case dw_val_class_flag:
8342 if (dwarf_version >= 4)
8344 /* Currently all add_AT_flag calls pass in 1 as last argument,
8345 so DW_FORM_flag_present can be used. If that ever changes,
8346 we'll need to use DW_FORM_flag and have some optimization
8347 in build_abbrev_table that will change those to
8348 DW_FORM_flag_present if it is set to 1 in all DIEs using
8349 the same abbrev entry. */
8350 gcc_assert (AT_flag (a) == 1);
8352 fprintf (asm_out_file, "\t\t\t%s %s\n",
8353 ASM_COMMENT_START, name);
8356 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8359 case dw_val_class_loc_list:
8361 char *sym = AT_loc_list (a)->ll_symbol;
8364 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8369 case dw_val_class_die_ref:
8370 if (AT_ref_external (a))
8372 if (use_debug_types)
8374 comdat_type_node_ref type_node =
8375 AT_ref (a)->die_id.die_type_node;
8377 gcc_assert (type_node);
8378 output_signature (type_node->signature, name);
8382 char *sym = AT_ref (a)->die_id.die_symbol;
8386 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8387 length, whereas in DWARF3 it's always sized as an
8389 if (dwarf_version == 2)
8390 size = DWARF2_ADDR_SIZE;
8392 size = DWARF_OFFSET_SIZE;
8393 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
8399 gcc_assert (AT_ref (a)->die_offset);
8400 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8405 case dw_val_class_fde_ref:
8409 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
8410 a->dw_attr_val.v.val_fde_index * 2);
8411 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
8416 case dw_val_class_vms_delta:
8417 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE,
8418 AT_vms_delta2 (a), AT_vms_delta1 (a),
8422 case dw_val_class_lbl_id:
8423 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8426 case dw_val_class_lineptr:
8427 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8428 debug_line_section, "%s", name);
8431 case dw_val_class_macptr:
8432 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8433 debug_macinfo_section, "%s", name);
8436 case dw_val_class_str:
8437 if (AT_string_form (a) == DW_FORM_strp)
8438 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
8439 a->dw_attr_val.v.val_str->label,
8441 "%s: \"%s\"", name, AT_string (a));
8443 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
8446 case dw_val_class_file:
8448 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
8450 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
8451 a->dw_attr_val.v.val_file->filename);
8455 case dw_val_class_data8:
8459 for (i = 0; i < 8; i++)
8460 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
8461 i == 0 ? "%s" : NULL, name);
8470 FOR_EACH_CHILD (die, c, output_die (c));
8472 /* Add null byte to terminate sibling list. */
8473 if (die->die_child != NULL)
8474 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
8475 (unsigned long) die->die_offset);
8478 /* Output the compilation unit that appears at the beginning of the
8479 .debug_info section, and precedes the DIE descriptions. */
8482 output_compilation_unit_header (void)
8484 int ver = dwarf_version;
8486 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8487 dw2_asm_output_data (4, 0xffffffff,
8488 "Initial length escape value indicating 64-bit DWARF extension");
8489 dw2_asm_output_data (DWARF_OFFSET_SIZE,
8490 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
8491 "Length of Compilation Unit Info");
8492 dw2_asm_output_data (2, ver, "DWARF version number");
8493 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
8494 debug_abbrev_section,
8495 "Offset Into Abbrev. Section");
8496 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
8499 /* Output the compilation unit DIE and its children. */
8502 output_comp_unit (dw_die_ref die, int output_if_empty)
8504 const char *secname;
8507 /* Unless we are outputting main CU, we may throw away empty ones. */
8508 if (!output_if_empty && die->die_child == NULL)
8511 /* Even if there are no children of this DIE, we must output the information
8512 about the compilation unit. Otherwise, on an empty translation unit, we
8513 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8514 will then complain when examining the file. First mark all the DIEs in
8515 this CU so we know which get local refs. */
8518 build_abbrev_table (die);
8520 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8521 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8522 calc_die_sizes (die);
8524 oldsym = die->die_id.die_symbol;
8527 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
8529 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
8531 die->die_id.die_symbol = NULL;
8532 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
8536 switch_to_section (debug_info_section);
8537 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
8538 info_section_emitted = true;
8541 /* Output debugging information. */
8542 output_compilation_unit_header ();
8545 /* Leave the marks on the main CU, so we can check them in
8550 die->die_id.die_symbol = oldsym;
8554 /* Output a comdat type unit DIE and its children. */
8557 output_comdat_type_unit (comdat_type_node *node)
8559 const char *secname;
8562 #if defined (OBJECT_FORMAT_ELF)
8566 /* First mark all the DIEs in this CU so we know which get local refs. */
8567 mark_dies (node->root_die);
8569 build_abbrev_table (node->root_die);
8571 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8572 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
8573 calc_die_sizes (node->root_die);
8575 #if defined (OBJECT_FORMAT_ELF)
8576 secname = ".debug_types";
8577 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
8578 sprintf (tmp, "wt.");
8579 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8580 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
8581 comdat_key = get_identifier (tmp);
8582 targetm.asm_out.named_section (secname,
8583 SECTION_DEBUG | SECTION_LINKONCE,
8586 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
8587 sprintf (tmp, ".gnu.linkonce.wt.");
8588 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8589 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
8591 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
8594 /* Output debugging information. */
8595 output_compilation_unit_header ();
8596 output_signature (node->signature, "Type Signature");
8597 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
8598 "Offset to Type DIE");
8599 output_die (node->root_die);
8601 unmark_dies (node->root_die);
8604 /* Return the DWARF2/3 pubname associated with a decl. */
8607 dwarf2_name (tree decl, int scope)
8609 if (DECL_NAMELESS (decl))
8611 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
8614 /* Add a new entry to .debug_pubnames if appropriate. */
8617 add_pubname_string (const char *str, dw_die_ref die)
8619 if (targetm.want_debug_pub_sections)
8624 e.name = xstrdup (str);
8625 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
8630 add_pubname (tree decl, dw_die_ref die)
8632 if (targetm.want_debug_pub_sections && TREE_PUBLIC (decl))
8634 const char *name = dwarf2_name (decl, 1);
8636 add_pubname_string (name, die);
8640 /* Add a new entry to .debug_pubtypes if appropriate. */
8643 add_pubtype (tree decl, dw_die_ref die)
8647 if (!targetm.want_debug_pub_sections)
8651 if ((TREE_PUBLIC (decl)
8652 || is_cu_die (die->die_parent))
8653 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
8658 if (TYPE_NAME (decl))
8660 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
8661 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
8662 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
8663 && DECL_NAME (TYPE_NAME (decl)))
8664 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
8666 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
8671 e.name = dwarf2_name (decl, 1);
8673 e.name = xstrdup (e.name);
8676 /* If we don't have a name for the type, there's no point in adding
8678 if (e.name && e.name[0] != '\0')
8679 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
8683 /* Output the public names table used to speed up access to externally
8684 visible names; or the public types table used to find type definitions. */
8687 output_pubnames (VEC (pubname_entry, gc) * names)
8690 unsigned long pubnames_length = size_of_pubnames (names);
8693 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8694 dw2_asm_output_data (4, 0xffffffff,
8695 "Initial length escape value indicating 64-bit DWARF extension");
8696 if (names == pubname_table)
8697 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8698 "Length of Public Names Info");
8700 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8701 "Length of Public Type Names Info");
8702 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
8703 dw2_asm_output_data (2, 2, "DWARF Version");
8704 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8706 "Offset of Compilation Unit Info");
8707 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
8708 "Compilation Unit Length");
8710 FOR_EACH_VEC_ELT (pubname_entry, names, i, pub)
8712 /* We shouldn't see pubnames for DIEs outside of the main CU. */
8713 if (names == pubname_table)
8714 gcc_assert (pub->die->die_mark);
8716 if (names != pubtype_table
8717 || pub->die->die_offset != 0
8718 || !flag_eliminate_unused_debug_types)
8720 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
8723 dw2_asm_output_nstring (pub->name, -1, "external name");
8727 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
8730 /* Output the information that goes into the .debug_aranges table.
8731 Namely, define the beginning and ending address range of the
8732 text section generated for this compilation unit. */
8735 output_aranges (unsigned long aranges_length)
8739 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8740 dw2_asm_output_data (4, 0xffffffff,
8741 "Initial length escape value indicating 64-bit DWARF extension");
8742 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
8743 "Length of Address Ranges Info");
8744 /* Version number for aranges is still 2, even in DWARF3. */
8745 dw2_asm_output_data (2, 2, "DWARF Version");
8746 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8748 "Offset of Compilation Unit Info");
8749 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
8750 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
8752 /* We need to align to twice the pointer size here. */
8753 if (DWARF_ARANGES_PAD_SIZE)
8755 /* Pad using a 2 byte words so that padding is correct for any
8757 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
8758 2 * DWARF2_ADDR_SIZE);
8759 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
8760 dw2_asm_output_data (2, 0, NULL);
8763 /* It is necessary not to output these entries if the sections were
8764 not used; if the sections were not used, the length will be 0 and
8765 the address may end up as 0 if the section is discarded by ld
8766 --gc-sections, leaving an invalid (0, 0) entry that can be
8767 confused with the terminator. */
8768 if (text_section_used)
8770 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
8771 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
8772 text_section_label, "Length");
8774 if (cold_text_section_used)
8776 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
8778 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
8779 cold_text_section_label, "Length");
8782 if (have_multiple_function_sections)
8787 FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, fde_idx, fde)
8789 if (!fde->in_std_section)
8791 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
8793 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_end,
8794 fde->dw_fde_begin, "Length");
8796 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
8798 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_second_begin,
8800 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_second_end,
8801 fde->dw_fde_second_begin, "Length");
8806 /* Output the terminator words. */
8807 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8808 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8811 /* Add a new entry to .debug_ranges. Return the offset at which it
8815 add_ranges_num (int num)
8817 unsigned int in_use = ranges_table_in_use;
8819 if (in_use == ranges_table_allocated)
8821 ranges_table_allocated += RANGES_TABLE_INCREMENT;
8822 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
8823 ranges_table_allocated);
8824 memset (ranges_table + ranges_table_in_use, 0,
8825 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
8828 ranges_table[in_use].num = num;
8829 ranges_table_in_use = in_use + 1;
8831 return in_use * 2 * DWARF2_ADDR_SIZE;
8834 /* Add a new entry to .debug_ranges corresponding to a block, or a
8835 range terminator if BLOCK is NULL. */
8838 add_ranges (const_tree block)
8840 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
8843 /* Add a new entry to .debug_ranges corresponding to a pair of
8847 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
8850 unsigned int in_use = ranges_by_label_in_use;
8851 unsigned int offset;
8853 if (in_use == ranges_by_label_allocated)
8855 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
8856 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
8858 ranges_by_label_allocated);
8859 memset (ranges_by_label + ranges_by_label_in_use, 0,
8860 RANGES_TABLE_INCREMENT
8861 * sizeof (struct dw_ranges_by_label_struct));
8864 ranges_by_label[in_use].begin = begin;
8865 ranges_by_label[in_use].end = end;
8866 ranges_by_label_in_use = in_use + 1;
8868 offset = add_ranges_num (-(int)in_use - 1);
8871 add_AT_range_list (die, DW_AT_ranges, offset);
8877 output_ranges (void)
8880 static const char *const start_fmt = "Offset %#x";
8881 const char *fmt = start_fmt;
8883 for (i = 0; i < ranges_table_in_use; i++)
8885 int block_num = ranges_table[i].num;
8889 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
8890 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
8892 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
8893 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
8895 /* If all code is in the text section, then the compilation
8896 unit base address defaults to DW_AT_low_pc, which is the
8897 base of the text section. */
8898 if (!have_multiple_function_sections)
8900 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
8902 fmt, i * 2 * DWARF2_ADDR_SIZE);
8903 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
8904 text_section_label, NULL);
8907 /* Otherwise, the compilation unit base address is zero,
8908 which allows us to use absolute addresses, and not worry
8909 about whether the target supports cross-section
8913 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
8914 fmt, i * 2 * DWARF2_ADDR_SIZE);
8915 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
8921 /* Negative block_num stands for an index into ranges_by_label. */
8922 else if (block_num < 0)
8924 int lab_idx = - block_num - 1;
8926 if (!have_multiple_function_sections)
8930 /* If we ever use add_ranges_by_labels () for a single
8931 function section, all we have to do is to take out
8933 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8934 ranges_by_label[lab_idx].begin,
8936 fmt, i * 2 * DWARF2_ADDR_SIZE);
8937 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8938 ranges_by_label[lab_idx].end,
8939 text_section_label, NULL);
8944 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8945 ranges_by_label[lab_idx].begin,
8946 fmt, i * 2 * DWARF2_ADDR_SIZE);
8947 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8948 ranges_by_label[lab_idx].end,
8954 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8955 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8961 /* Data structure containing information about input files. */
8964 const char *path; /* Complete file name. */
8965 const char *fname; /* File name part. */
8966 int length; /* Length of entire string. */
8967 struct dwarf_file_data * file_idx; /* Index in input file table. */
8968 int dir_idx; /* Index in directory table. */
8971 /* Data structure containing information about directories with source
8975 const char *path; /* Path including directory name. */
8976 int length; /* Path length. */
8977 int prefix; /* Index of directory entry which is a prefix. */
8978 int count; /* Number of files in this directory. */
8979 int dir_idx; /* Index of directory used as base. */
8982 /* Callback function for file_info comparison. We sort by looking at
8983 the directories in the path. */
8986 file_info_cmp (const void *p1, const void *p2)
8988 const struct file_info *const s1 = (const struct file_info *) p1;
8989 const struct file_info *const s2 = (const struct file_info *) p2;
8990 const unsigned char *cp1;
8991 const unsigned char *cp2;
8993 /* Take care of file names without directories. We need to make sure that
8994 we return consistent values to qsort since some will get confused if
8995 we return the same value when identical operands are passed in opposite
8996 orders. So if neither has a directory, return 0 and otherwise return
8997 1 or -1 depending on which one has the directory. */
8998 if ((s1->path == s1->fname || s2->path == s2->fname))
8999 return (s2->path == s2->fname) - (s1->path == s1->fname);
9001 cp1 = (const unsigned char *) s1->path;
9002 cp2 = (const unsigned char *) s2->path;
9008 /* Reached the end of the first path? If so, handle like above. */
9009 if ((cp1 == (const unsigned char *) s1->fname)
9010 || (cp2 == (const unsigned char *) s2->fname))
9011 return ((cp2 == (const unsigned char *) s2->fname)
9012 - (cp1 == (const unsigned char *) s1->fname));
9014 /* Character of current path component the same? */
9015 else if (*cp1 != *cp2)
9020 struct file_name_acquire_data
9022 struct file_info *files;
9027 /* Traversal function for the hash table. */
9030 file_name_acquire (void ** slot, void *data)
9032 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
9033 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
9034 struct file_info *fi;
9037 gcc_assert (fnad->max_files >= d->emitted_number);
9039 if (! d->emitted_number)
9042 gcc_assert (fnad->max_files != fnad->used_files);
9044 fi = fnad->files + fnad->used_files++;
9046 /* Skip all leading "./". */
9048 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
9051 /* Create a new array entry. */
9053 fi->length = strlen (f);
9056 /* Search for the file name part. */
9057 f = strrchr (f, DIR_SEPARATOR);
9058 #if defined (DIR_SEPARATOR_2)
9060 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
9064 if (f == NULL || f < g)
9070 fi->fname = f == NULL ? fi->path : f + 1;
9074 /* Output the directory table and the file name table. We try to minimize
9075 the total amount of memory needed. A heuristic is used to avoid large
9076 slowdowns with many input files. */
9079 output_file_names (void)
9081 struct file_name_acquire_data fnad;
9083 struct file_info *files;
9084 struct dir_info *dirs;
9092 if (!last_emitted_file)
9094 dw2_asm_output_data (1, 0, "End directory table");
9095 dw2_asm_output_data (1, 0, "End file name table");
9099 numfiles = last_emitted_file->emitted_number;
9101 /* Allocate the various arrays we need. */
9102 files = XALLOCAVEC (struct file_info, numfiles);
9103 dirs = XALLOCAVEC (struct dir_info, numfiles);
9106 fnad.used_files = 0;
9107 fnad.max_files = numfiles;
9108 htab_traverse (file_table, file_name_acquire, &fnad);
9109 gcc_assert (fnad.used_files == fnad.max_files);
9111 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
9113 /* Find all the different directories used. */
9114 dirs[0].path = files[0].path;
9115 dirs[0].length = files[0].fname - files[0].path;
9116 dirs[0].prefix = -1;
9118 dirs[0].dir_idx = 0;
9119 files[0].dir_idx = 0;
9122 for (i = 1; i < numfiles; i++)
9123 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
9124 && memcmp (dirs[ndirs - 1].path, files[i].path,
9125 dirs[ndirs - 1].length) == 0)
9127 /* Same directory as last entry. */
9128 files[i].dir_idx = ndirs - 1;
9129 ++dirs[ndirs - 1].count;
9135 /* This is a new directory. */
9136 dirs[ndirs].path = files[i].path;
9137 dirs[ndirs].length = files[i].fname - files[i].path;
9138 dirs[ndirs].count = 1;
9139 dirs[ndirs].dir_idx = ndirs;
9140 files[i].dir_idx = ndirs;
9142 /* Search for a prefix. */
9143 dirs[ndirs].prefix = -1;
9144 for (j = 0; j < ndirs; j++)
9145 if (dirs[j].length < dirs[ndirs].length
9146 && dirs[j].length > 1
9147 && (dirs[ndirs].prefix == -1
9148 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
9149 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
9150 dirs[ndirs].prefix = j;
9155 /* Now to the actual work. We have to find a subset of the directories which
9156 allow expressing the file name using references to the directory table
9157 with the least amount of characters. We do not do an exhaustive search
9158 where we would have to check out every combination of every single
9159 possible prefix. Instead we use a heuristic which provides nearly optimal
9160 results in most cases and never is much off. */
9161 saved = XALLOCAVEC (int, ndirs);
9162 savehere = XALLOCAVEC (int, ndirs);
9164 memset (saved, '\0', ndirs * sizeof (saved[0]));
9165 for (i = 0; i < ndirs; i++)
9170 /* We can always save some space for the current directory. But this
9171 does not mean it will be enough to justify adding the directory. */
9172 savehere[i] = dirs[i].length;
9173 total = (savehere[i] - saved[i]) * dirs[i].count;
9175 for (j = i + 1; j < ndirs; j++)
9178 if (saved[j] < dirs[i].length)
9180 /* Determine whether the dirs[i] path is a prefix of the
9185 while (k != -1 && k != (int) i)
9190 /* Yes it is. We can possibly save some memory by
9191 writing the filenames in dirs[j] relative to
9193 savehere[j] = dirs[i].length;
9194 total += (savehere[j] - saved[j]) * dirs[j].count;
9199 /* Check whether we can save enough to justify adding the dirs[i]
9201 if (total > dirs[i].length + 1)
9203 /* It's worthwhile adding. */
9204 for (j = i; j < ndirs; j++)
9205 if (savehere[j] > 0)
9207 /* Remember how much we saved for this directory so far. */
9208 saved[j] = savehere[j];
9210 /* Remember the prefix directory. */
9211 dirs[j].dir_idx = i;
9216 /* Emit the directory name table. */
9217 idx_offset = dirs[0].length > 0 ? 1 : 0;
9218 for (i = 1 - idx_offset; i < ndirs; i++)
9219 dw2_asm_output_nstring (dirs[i].path,
9221 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
9222 "Directory Entry: %#x", i + idx_offset);
9224 dw2_asm_output_data (1, 0, "End directory table");
9226 /* We have to emit them in the order of emitted_number since that's
9227 used in the debug info generation. To do this efficiently we
9228 generate a back-mapping of the indices first. */
9229 backmap = XALLOCAVEC (int, numfiles);
9230 for (i = 0; i < numfiles; i++)
9231 backmap[files[i].file_idx->emitted_number - 1] = i;
9233 /* Now write all the file names. */
9234 for (i = 0; i < numfiles; i++)
9236 int file_idx = backmap[i];
9237 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
9239 #ifdef VMS_DEBUGGING_INFO
9240 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
9242 /* Setting these fields can lead to debugger miscomparisons,
9243 but VMS Debug requires them to be set correctly. */
9248 int maxfilelen = strlen (files[file_idx].path)
9249 + dirs[dir_idx].length
9250 + MAX_VMS_VERSION_LEN + 1;
9251 char *filebuf = XALLOCAVEC (char, maxfilelen);
9253 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
9254 snprintf (filebuf, maxfilelen, "%s;%d",
9255 files[file_idx].path + dirs[dir_idx].length, ver);
9257 dw2_asm_output_nstring
9258 (filebuf, -1, "File Entry: %#x", (unsigned) i + 1);
9260 /* Include directory index. */
9261 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
9263 /* Modification time. */
9264 dw2_asm_output_data_uleb128
9265 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
9269 /* File length in bytes. */
9270 dw2_asm_output_data_uleb128
9271 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
9275 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
9276 "File Entry: %#x", (unsigned) i + 1);
9278 /* Include directory index. */
9279 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
9281 /* Modification time. */
9282 dw2_asm_output_data_uleb128 (0, NULL);
9284 /* File length in bytes. */
9285 dw2_asm_output_data_uleb128 (0, NULL);
9286 #endif /* VMS_DEBUGGING_INFO */
9289 dw2_asm_output_data (1, 0, "End file name table");
9293 /* Output one line number table into the .debug_line section. */
9296 output_one_line_info_table (dw_line_info_table *table)
9298 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
9299 unsigned int current_line = 1;
9300 bool current_is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
9301 dw_line_info_entry *ent;
9304 FOR_EACH_VEC_ELT (dw_line_info_entry, table->entries, i, ent)
9306 switch (ent->opcode)
9308 case LI_set_address:
9309 /* ??? Unfortunately, we have little choice here currently, and
9310 must always use the most general form. GCC does not know the
9311 address delta itself, so we can't use DW_LNS_advance_pc. Many
9312 ports do have length attributes which will give an upper bound
9313 on the address range. We could perhaps use length attributes
9314 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
9315 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val);
9317 /* This can handle any delta. This takes
9318 4+DWARF2_ADDR_SIZE bytes. */
9319 dw2_asm_output_data (1, 0, "set address %s", line_label);
9320 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9321 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9322 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9326 if (ent->val == current_line)
9328 /* We still need to start a new row, so output a copy insn. */
9329 dw2_asm_output_data (1, DW_LNS_copy,
9330 "copy line %u", current_line);
9334 int line_offset = ent->val - current_line;
9335 int line_delta = line_offset - DWARF_LINE_BASE;
9337 current_line = ent->val;
9338 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9340 /* This can handle deltas from -10 to 234, using the current
9341 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
9342 This takes 1 byte. */
9343 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9344 "line %u", current_line);
9348 /* This can handle any delta. This takes at least 4 bytes,
9349 depending on the value being encoded. */
9350 dw2_asm_output_data (1, DW_LNS_advance_line,
9351 "advance to line %u", current_line);
9352 dw2_asm_output_data_sleb128 (line_offset, NULL);
9353 dw2_asm_output_data (1, DW_LNS_copy, NULL);
9359 dw2_asm_output_data (1, DW_LNS_set_file, "set file %u", ent->val);
9360 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
9364 dw2_asm_output_data (1, DW_LNS_set_column, "column %u", ent->val);
9365 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
9368 case LI_negate_stmt:
9369 current_is_stmt = !current_is_stmt;
9370 dw2_asm_output_data (1, DW_LNS_negate_stmt,
9371 "is_stmt %d", current_is_stmt);
9374 case LI_set_prologue_end:
9375 dw2_asm_output_data (1, DW_LNS_set_prologue_end,
9376 "set prologue end");
9379 case LI_set_epilogue_begin:
9380 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin,
9381 "set epilogue begin");
9384 case LI_set_discriminator:
9385 dw2_asm_output_data (1, 0, "discriminator %u", ent->val);
9386 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent->val), NULL);
9387 dw2_asm_output_data (1, DW_LNE_set_discriminator, NULL);
9388 dw2_asm_output_data_uleb128 (ent->val, NULL);
9393 /* Emit debug info for the address of the end of the table. */
9394 dw2_asm_output_data (1, 0, "set address %s", table->end_label);
9395 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9396 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9397 dw2_asm_output_addr (DWARF2_ADDR_SIZE, table->end_label, NULL);
9399 dw2_asm_output_data (1, 0, "end sequence");
9400 dw2_asm_output_data_uleb128 (1, NULL);
9401 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9404 /* Output the source line number correspondence information. This
9405 information goes into the .debug_line section. */
9408 output_line_info (void)
9410 char l1[20], l2[20], p1[20], p2[20];
9411 int ver = dwarf_version;
9412 bool saw_one = false;
9415 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
9416 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
9417 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
9418 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
9420 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9421 dw2_asm_output_data (4, 0xffffffff,
9422 "Initial length escape value indicating 64-bit DWARF extension");
9423 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
9424 "Length of Source Line Info");
9425 ASM_OUTPUT_LABEL (asm_out_file, l1);
9427 dw2_asm_output_data (2, ver, "DWARF Version");
9428 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
9429 ASM_OUTPUT_LABEL (asm_out_file, p1);
9431 /* Define the architecture-dependent minimum instruction length (in bytes).
9432 In this implementation of DWARF, this field is used for information
9433 purposes only. Since GCC generates assembly language, we have no
9434 a priori knowledge of how many instruction bytes are generated for each
9435 source line, and therefore can use only the DW_LNE_set_address and
9436 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
9437 this as '1', which is "correct enough" for all architectures,
9438 and don't let the target override. */
9439 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
9442 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
9443 "Maximum Operations Per Instruction");
9444 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
9445 "Default is_stmt_start flag");
9446 dw2_asm_output_data (1, DWARF_LINE_BASE,
9447 "Line Base Value (Special Opcodes)");
9448 dw2_asm_output_data (1, DWARF_LINE_RANGE,
9449 "Line Range Value (Special Opcodes)");
9450 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
9451 "Special Opcode Base");
9453 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
9458 case DW_LNS_advance_pc:
9459 case DW_LNS_advance_line:
9460 case DW_LNS_set_file:
9461 case DW_LNS_set_column:
9462 case DW_LNS_fixed_advance_pc:
9463 case DW_LNS_set_isa:
9471 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args",
9475 /* Write out the information about the files we use. */
9476 output_file_names ();
9477 ASM_OUTPUT_LABEL (asm_out_file, p2);
9479 if (separate_line_info)
9481 dw_line_info_table *table;
9484 FOR_EACH_VEC_ELT (dw_line_info_table_p, separate_line_info, i, table)
9487 output_one_line_info_table (table);
9491 if (cold_text_section_line_info && cold_text_section_line_info->in_use)
9493 output_one_line_info_table (cold_text_section_line_info);
9497 /* ??? Some Darwin linkers crash on a .debug_line section with no
9498 sequences. Further, merely a DW_LNE_end_sequence entry is not
9499 sufficient -- the address column must also be initialized.
9500 Make sure to output at least one set_address/end_sequence pair,
9501 choosing .text since that section is always present. */
9502 if (text_section_line_info->in_use || !saw_one)
9503 output_one_line_info_table (text_section_line_info);
9505 /* Output the marker for the end of the line number info. */
9506 ASM_OUTPUT_LABEL (asm_out_file, l2);
9509 /* Given a pointer to a tree node for some base type, return a pointer to
9510 a DIE that describes the given type.
9512 This routine must only be called for GCC type nodes that correspond to
9513 Dwarf base (fundamental) types. */
9516 base_type_die (tree type)
9518 dw_die_ref base_type_result;
9519 enum dwarf_type encoding;
9521 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
9524 /* If this is a subtype that should not be emitted as a subrange type,
9525 use the base type. See subrange_type_for_debug_p. */
9526 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
9527 type = TREE_TYPE (type);
9529 switch (TREE_CODE (type))
9532 if ((dwarf_version >= 4 || !dwarf_strict)
9534 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9535 && DECL_IS_BUILTIN (TYPE_NAME (type))
9536 && DECL_NAME (TYPE_NAME (type)))
9538 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
9539 if (strcmp (name, "char16_t") == 0
9540 || strcmp (name, "char32_t") == 0)
9542 encoding = DW_ATE_UTF;
9546 if (TYPE_STRING_FLAG (type))
9548 if (TYPE_UNSIGNED (type))
9549 encoding = DW_ATE_unsigned_char;
9551 encoding = DW_ATE_signed_char;
9553 else if (TYPE_UNSIGNED (type))
9554 encoding = DW_ATE_unsigned;
9556 encoding = DW_ATE_signed;
9560 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
9562 if (dwarf_version >= 3 || !dwarf_strict)
9563 encoding = DW_ATE_decimal_float;
9565 encoding = DW_ATE_lo_user;
9568 encoding = DW_ATE_float;
9571 case FIXED_POINT_TYPE:
9572 if (!(dwarf_version >= 3 || !dwarf_strict))
9573 encoding = DW_ATE_lo_user;
9574 else if (TYPE_UNSIGNED (type))
9575 encoding = DW_ATE_unsigned_fixed;
9577 encoding = DW_ATE_signed_fixed;
9580 /* Dwarf2 doesn't know anything about complex ints, so use
9581 a user defined type for it. */
9583 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
9584 encoding = DW_ATE_complex_float;
9586 encoding = DW_ATE_lo_user;
9590 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
9591 encoding = DW_ATE_boolean;
9595 /* No other TREE_CODEs are Dwarf fundamental types. */
9599 base_type_result = new_die (DW_TAG_base_type, comp_unit_die (), type);
9601 add_AT_unsigned (base_type_result, DW_AT_byte_size,
9602 int_size_in_bytes (type));
9603 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
9605 return base_type_result;
9608 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
9609 given input type is a Dwarf "fundamental" type. Otherwise return null. */
9612 is_base_type (tree type)
9614 switch (TREE_CODE (type))
9620 case FIXED_POINT_TYPE:
9628 case QUAL_UNION_TYPE:
9633 case REFERENCE_TYPE:
9647 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
9648 node, return the size in bits for the type if it is a constant, or else
9649 return the alignment for the type if the type's size is not constant, or
9650 else return BITS_PER_WORD if the type actually turns out to be an
9653 static inline unsigned HOST_WIDE_INT
9654 simple_type_size_in_bits (const_tree type)
9656 if (TREE_CODE (type) == ERROR_MARK)
9657 return BITS_PER_WORD;
9658 else if (TYPE_SIZE (type) == NULL_TREE)
9660 else if (host_integerp (TYPE_SIZE (type), 1))
9661 return tree_low_cst (TYPE_SIZE (type), 1);
9663 return TYPE_ALIGN (type);
9666 /* Similarly, but return a double_int instead of UHWI. */
9668 static inline double_int
9669 double_int_type_size_in_bits (const_tree type)
9671 if (TREE_CODE (type) == ERROR_MARK)
9672 return uhwi_to_double_int (BITS_PER_WORD);
9673 else if (TYPE_SIZE (type) == NULL_TREE)
9674 return double_int_zero;
9675 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
9676 return tree_to_double_int (TYPE_SIZE (type));
9678 return uhwi_to_double_int (TYPE_ALIGN (type));
9681 /* Given a pointer to a tree node for a subrange type, return a pointer
9682 to a DIE that describes the given type. */
9685 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
9687 dw_die_ref subrange_die;
9688 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
9690 if (context_die == NULL)
9691 context_die = comp_unit_die ();
9693 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
9695 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
9697 /* The size of the subrange type and its base type do not match,
9698 so we need to generate a size attribute for the subrange type. */
9699 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
9703 add_bound_info (subrange_die, DW_AT_lower_bound, low);
9705 add_bound_info (subrange_die, DW_AT_upper_bound, high);
9707 return subrange_die;
9710 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
9711 entry that chains various modifiers in front of the given type. */
9714 modified_type_die (tree type, int is_const_type, int is_volatile_type,
9715 dw_die_ref context_die)
9717 enum tree_code code = TREE_CODE (type);
9718 dw_die_ref mod_type_die;
9719 dw_die_ref sub_die = NULL;
9720 tree item_type = NULL;
9721 tree qualified_type;
9722 tree name, low, high;
9724 if (code == ERROR_MARK)
9727 /* See if we already have the appropriately qualified variant of
9730 = get_qualified_type (type,
9731 ((is_const_type ? TYPE_QUAL_CONST : 0)
9732 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
9734 if (qualified_type == sizetype
9735 && TYPE_NAME (qualified_type)
9736 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL)
9738 tree t = TREE_TYPE (TYPE_NAME (qualified_type));
9740 gcc_checking_assert (TREE_CODE (t) == INTEGER_TYPE
9741 && TYPE_PRECISION (t)
9742 == TYPE_PRECISION (qualified_type)
9743 && TYPE_UNSIGNED (t)
9744 == TYPE_UNSIGNED (qualified_type));
9748 /* If we do, then we can just use its DIE, if it exists. */
9751 mod_type_die = lookup_type_die (qualified_type);
9753 return mod_type_die;
9756 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
9758 /* Handle C typedef types. */
9759 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)
9760 && !DECL_ARTIFICIAL (name))
9762 tree dtype = TREE_TYPE (name);
9764 if (qualified_type == dtype)
9766 /* For a named type, use the typedef. */
9767 gen_type_die (qualified_type, context_die);
9768 return lookup_type_die (qualified_type);
9770 else if (is_const_type < TYPE_READONLY (dtype)
9771 || is_volatile_type < TYPE_VOLATILE (dtype)
9772 || (is_const_type <= TYPE_READONLY (dtype)
9773 && is_volatile_type <= TYPE_VOLATILE (dtype)
9774 && DECL_ORIGINAL_TYPE (name) != type))
9775 /* cv-unqualified version of named type. Just use the unnamed
9776 type to which it refers. */
9777 return modified_type_die (DECL_ORIGINAL_TYPE (name),
9778 is_const_type, is_volatile_type,
9780 /* Else cv-qualified version of named type; fall through. */
9784 /* If both is_const_type and is_volatile_type, prefer the path
9785 which leads to a qualified type. */
9786 && (!is_volatile_type
9787 || get_qualified_type (type, TYPE_QUAL_CONST) == NULL_TREE
9788 || get_qualified_type (type, TYPE_QUAL_VOLATILE) != NULL_TREE))
9790 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die (), type);
9791 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
9793 else if (is_volatile_type)
9795 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die (), type);
9796 sub_die = modified_type_die (type, is_const_type, 0, context_die);
9798 else if (code == POINTER_TYPE)
9800 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die (), type);
9801 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9802 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9803 item_type = TREE_TYPE (type);
9804 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
9805 add_AT_unsigned (mod_type_die, DW_AT_address_class,
9806 TYPE_ADDR_SPACE (item_type));
9808 else if (code == REFERENCE_TYPE)
9810 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
9811 mod_type_die = new_die (DW_TAG_rvalue_reference_type, comp_unit_die (),
9814 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die (), type);
9815 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9816 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9817 item_type = TREE_TYPE (type);
9818 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
9819 add_AT_unsigned (mod_type_die, DW_AT_address_class,
9820 TYPE_ADDR_SPACE (item_type));
9822 else if (code == INTEGER_TYPE
9823 && TREE_TYPE (type) != NULL_TREE
9824 && subrange_type_for_debug_p (type, &low, &high))
9826 mod_type_die = subrange_type_die (type, low, high, context_die);
9827 item_type = TREE_TYPE (type);
9829 else if (is_base_type (type))
9830 mod_type_die = base_type_die (type);
9833 gen_type_die (type, context_die);
9835 /* We have to get the type_main_variant here (and pass that to the
9836 `lookup_type_die' routine) because the ..._TYPE node we have
9837 might simply be a *copy* of some original type node (where the
9838 copy was created to help us keep track of typedef names) and
9839 that copy might have a different TYPE_UID from the original
9841 if (TREE_CODE (type) != VECTOR_TYPE)
9842 return lookup_type_die (type_main_variant (type));
9844 /* Vectors have the debugging information in the type,
9845 not the main variant. */
9846 return lookup_type_die (type);
9849 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
9850 don't output a DW_TAG_typedef, since there isn't one in the
9851 user's program; just attach a DW_AT_name to the type.
9852 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
9853 if the base type already has the same name. */
9855 && ((TREE_CODE (name) != TYPE_DECL
9856 && (qualified_type == TYPE_MAIN_VARIANT (type)
9857 || (!is_const_type && !is_volatile_type)))
9858 || (TREE_CODE (name) == TYPE_DECL
9859 && TREE_TYPE (name) == qualified_type
9860 && DECL_NAME (name))))
9862 if (TREE_CODE (name) == TYPE_DECL)
9863 /* Could just call add_name_and_src_coords_attributes here,
9864 but since this is a builtin type it doesn't have any
9865 useful source coordinates anyway. */
9866 name = DECL_NAME (name);
9867 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
9868 add_gnat_descriptive_type_attribute (mod_type_die, type, context_die);
9869 if (TYPE_ARTIFICIAL (type))
9870 add_AT_flag (mod_type_die, DW_AT_artificial, 1);
9872 /* This probably indicates a bug. */
9873 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
9874 add_name_attribute (mod_type_die, "__unknown__");
9877 equate_type_number_to_die (qualified_type, mod_type_die);
9880 /* We must do this after the equate_type_number_to_die call, in case
9881 this is a recursive type. This ensures that the modified_type_die
9882 recursion will terminate even if the type is recursive. Recursive
9883 types are possible in Ada. */
9884 sub_die = modified_type_die (item_type,
9885 TYPE_READONLY (item_type),
9886 TYPE_VOLATILE (item_type),
9889 if (sub_die != NULL)
9890 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
9892 return mod_type_die;
9895 /* Generate DIEs for the generic parameters of T.
9896 T must be either a generic type or a generic function.
9897 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
9900 gen_generic_params_dies (tree t)
9904 dw_die_ref die = NULL;
9906 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
9910 die = lookup_type_die (t);
9911 else if (DECL_P (t))
9912 die = lookup_decl_die (t);
9916 parms = lang_hooks.get_innermost_generic_parms (t);
9918 /* T has no generic parameter. It means T is neither a generic type
9919 or function. End of story. */
9922 parms_num = TREE_VEC_LENGTH (parms);
9923 args = lang_hooks.get_innermost_generic_args (t);
9924 for (i = 0; i < parms_num; i++)
9926 tree parm, arg, arg_pack_elems;
9928 parm = TREE_VEC_ELT (parms, i);
9929 arg = TREE_VEC_ELT (args, i);
9930 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
9931 gcc_assert (parm && TREE_VALUE (parm) && arg);
9933 if (parm && TREE_VALUE (parm) && arg)
9935 /* If PARM represents a template parameter pack,
9936 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
9937 by DW_TAG_template_*_parameter DIEs for the argument
9938 pack elements of ARG. Note that ARG would then be
9939 an argument pack. */
9941 template_parameter_pack_die (TREE_VALUE (parm),
9945 generic_parameter_die (TREE_VALUE (parm), arg,
9946 true /* Emit DW_AT_name */, die);
9951 /* Create and return a DIE for PARM which should be
9952 the representation of a generic type parameter.
9953 For instance, in the C++ front end, PARM would be a template parameter.
9954 ARG is the argument to PARM.
9955 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
9957 PARENT_DIE is the parent DIE which the new created DIE should be added to,
9961 generic_parameter_die (tree parm, tree arg,
9963 dw_die_ref parent_die)
9965 dw_die_ref tmpl_die = NULL;
9966 const char *name = NULL;
9968 if (!parm || !DECL_NAME (parm) || !arg)
9971 /* We support non-type generic parameters and arguments,
9972 type generic parameters and arguments, as well as
9973 generic generic parameters (a.k.a. template template parameters in C++)
9975 if (TREE_CODE (parm) == PARM_DECL)
9976 /* PARM is a nontype generic parameter */
9977 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
9978 else if (TREE_CODE (parm) == TYPE_DECL)
9979 /* PARM is a type generic parameter. */
9980 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
9981 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
9982 /* PARM is a generic generic parameter.
9983 Its DIE is a GNU extension. It shall have a
9984 DW_AT_name attribute to represent the name of the template template
9985 parameter, and a DW_AT_GNU_template_name attribute to represent the
9986 name of the template template argument. */
9987 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
9996 /* If PARM is a generic parameter pack, it means we are
9997 emitting debug info for a template argument pack element.
9998 In other terms, ARG is a template argument pack element.
9999 In that case, we don't emit any DW_AT_name attribute for
10003 name = IDENTIFIER_POINTER (DECL_NAME (parm));
10005 add_AT_string (tmpl_die, DW_AT_name, name);
10008 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10010 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10011 TMPL_DIE should have a child DW_AT_type attribute that is set
10012 to the type of the argument to PARM, which is ARG.
10013 If PARM is a type generic parameter, TMPL_DIE should have a
10014 child DW_AT_type that is set to ARG. */
10015 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
10016 add_type_attribute (tmpl_die, tmpl_type, 0,
10017 TREE_THIS_VOLATILE (tmpl_type),
10022 /* So TMPL_DIE is a DIE representing a
10023 a generic generic template parameter, a.k.a template template
10024 parameter in C++ and arg is a template. */
10026 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10027 to the name of the argument. */
10028 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
10030 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
10033 if (TREE_CODE (parm) == PARM_DECL)
10034 /* So PARM is a non-type generic parameter.
10035 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10036 attribute of TMPL_DIE which value represents the value
10038 We must be careful here:
10039 The value of ARG might reference some function decls.
10040 We might currently be emitting debug info for a generic
10041 type and types are emitted before function decls, we don't
10042 know if the function decls referenced by ARG will actually be
10043 emitted after cgraph computations.
10044 So must defer the generation of the DW_AT_const_value to
10045 after cgraph is ready. */
10046 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
10052 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
10053 PARM_PACK must be a template parameter pack. The returned DIE
10054 will be child DIE of PARENT_DIE. */
10057 template_parameter_pack_die (tree parm_pack,
10058 tree parm_pack_args,
10059 dw_die_ref parent_die)
10064 gcc_assert (parent_die && parm_pack);
10066 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
10067 add_name_and_src_coords_attributes (die, parm_pack);
10068 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
10069 generic_parameter_die (parm_pack,
10070 TREE_VEC_ELT (parm_pack_args, j),
10071 false /* Don't emit DW_AT_name */,
10076 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10077 an enumerated type. */
10080 type_is_enum (const_tree type)
10082 return TREE_CODE (type) == ENUMERAL_TYPE;
10085 /* Return the DBX register number described by a given RTL node. */
10087 static unsigned int
10088 dbx_reg_number (const_rtx rtl)
10090 unsigned regno = REGNO (rtl);
10092 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
10094 #ifdef LEAF_REG_REMAP
10095 if (current_function_uses_only_leaf_regs)
10097 int leaf_reg = LEAF_REG_REMAP (regno);
10098 if (leaf_reg != -1)
10099 regno = (unsigned) leaf_reg;
10103 return DBX_REGISTER_NUMBER (regno);
10106 /* Optionally add a DW_OP_piece term to a location description expression.
10107 DW_OP_piece is only added if the location description expression already
10108 doesn't end with DW_OP_piece. */
10111 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
10113 dw_loc_descr_ref loc;
10115 if (*list_head != NULL)
10117 /* Find the end of the chain. */
10118 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
10121 if (loc->dw_loc_opc != DW_OP_piece)
10122 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
10126 /* Return a location descriptor that designates a machine register or
10127 zero if there is none. */
10129 static dw_loc_descr_ref
10130 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
10134 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
10137 /* We only use "frame base" when we're sure we're talking about the
10138 post-prologue local stack frame. We do this by *not* running
10139 register elimination until this point, and recognizing the special
10140 argument pointer and soft frame pointer rtx's.
10141 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
10142 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx)
10143 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl)
10145 dw_loc_descr_ref result = NULL;
10147 if (dwarf_version >= 4 || !dwarf_strict)
10149 result = mem_loc_descriptor (rtl, GET_MODE (rtl), VOIDmode,
10152 add_loc_descr (&result,
10153 new_loc_descr (DW_OP_stack_value, 0, 0));
10158 regs = targetm.dwarf_register_span (rtl);
10160 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
10161 return multiple_reg_loc_descriptor (rtl, regs, initialized);
10163 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
10166 /* Return a location descriptor that designates a machine register for
10167 a given hard register number. */
10169 static dw_loc_descr_ref
10170 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
10172 dw_loc_descr_ref reg_loc_descr;
10176 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
10178 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
10180 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10181 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10183 return reg_loc_descr;
10186 /* Given an RTL of a register, return a location descriptor that
10187 designates a value that spans more than one register. */
10189 static dw_loc_descr_ref
10190 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
10191 enum var_init_status initialized)
10193 int nregs, size, i;
10195 dw_loc_descr_ref loc_result = NULL;
10198 #ifdef LEAF_REG_REMAP
10199 if (current_function_uses_only_leaf_regs)
10201 int leaf_reg = LEAF_REG_REMAP (reg);
10202 if (leaf_reg != -1)
10203 reg = (unsigned) leaf_reg;
10206 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
10207 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
10209 /* Simple, contiguous registers. */
10210 if (regs == NULL_RTX)
10212 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
10217 dw_loc_descr_ref t;
10219 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
10220 VAR_INIT_STATUS_INITIALIZED);
10221 add_loc_descr (&loc_result, t);
10222 add_loc_descr_op_piece (&loc_result, size);
10228 /* Now onto stupid register sets in non contiguous locations. */
10230 gcc_assert (GET_CODE (regs) == PARALLEL);
10232 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
10235 for (i = 0; i < XVECLEN (regs, 0); ++i)
10237 dw_loc_descr_ref t;
10239 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
10240 VAR_INIT_STATUS_INITIALIZED);
10241 add_loc_descr (&loc_result, t);
10242 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
10243 add_loc_descr_op_piece (&loc_result, size);
10246 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10247 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10251 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT);
10253 /* Return a location descriptor that designates a constant i,
10254 as a compound operation from constant (i >> shift), constant shift
10257 static dw_loc_descr_ref
10258 int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
10260 dw_loc_descr_ref ret = int_loc_descriptor (i >> shift);
10261 add_loc_descr (&ret, int_loc_descriptor (shift));
10262 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
10266 /* Return a location descriptor that designates a constant. */
10268 static dw_loc_descr_ref
10269 int_loc_descriptor (HOST_WIDE_INT i)
10271 enum dwarf_location_atom op;
10273 /* Pick the smallest representation of a constant, rather than just
10274 defaulting to the LEB encoding. */
10277 int clz = clz_hwi (i);
10278 int ctz = ctz_hwi (i);
10280 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
10281 else if (i <= 0xff)
10282 op = DW_OP_const1u;
10283 else if (i <= 0xffff)
10284 op = DW_OP_const2u;
10285 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
10286 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
10287 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
10288 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
10289 while DW_OP_const4u is 5 bytes. */
10290 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 5);
10291 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
10292 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
10293 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
10294 while DW_OP_const4u is 5 bytes. */
10295 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
10296 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
10297 op = DW_OP_const4u;
10298 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
10299 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
10300 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
10301 while DW_OP_constu of constant >= 0x100000000 takes at least
10303 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
10304 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
10305 && clz + 16 + (size_of_uleb128 (i) > 5 ? 255 : 31)
10306 >= HOST_BITS_PER_WIDE_INT)
10307 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
10308 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
10309 while DW_OP_constu takes in this case at least 6 bytes. */
10310 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 16);
10311 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
10312 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
10313 && size_of_uleb128 (i) > 6)
10314 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
10315 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 32);
10322 op = DW_OP_const1s;
10323 else if (i >= -0x8000)
10324 op = DW_OP_const2s;
10325 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
10327 if (size_of_int_loc_descriptor (i) < 5)
10329 dw_loc_descr_ref ret = int_loc_descriptor (-i);
10330 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
10333 op = DW_OP_const4s;
10337 if (size_of_int_loc_descriptor (i)
10338 < (unsigned long) 1 + size_of_sleb128 (i))
10340 dw_loc_descr_ref ret = int_loc_descriptor (-i);
10341 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
10348 return new_loc_descr (op, i, 0);
10351 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
10352 without actually allocating it. */
10354 static unsigned long
10355 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
10357 return size_of_int_loc_descriptor (i >> shift)
10358 + size_of_int_loc_descriptor (shift)
10362 /* Return size_of_locs (int_loc_descriptor (i)) without
10363 actually allocating it. */
10365 static unsigned long
10366 size_of_int_loc_descriptor (HOST_WIDE_INT i)
10375 else if (i <= 0xff)
10377 else if (i <= 0xffff)
10381 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
10382 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
10383 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
10385 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
10386 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
10387 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
10389 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
10391 s = size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
10392 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
10393 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
10394 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
10396 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
10397 && clz + 16 + (s > 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT)
10398 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
10400 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
10401 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
10403 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
10412 else if (i >= -0x8000)
10414 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
10416 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
10418 s = size_of_int_loc_descriptor (-i) + 1;
10426 unsigned long r = 1 + size_of_sleb128 (i);
10427 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
10429 s = size_of_int_loc_descriptor (-i) + 1;
10438 /* Return loc description representing "address" of integer value.
10439 This can appear only as toplevel expression. */
10441 static dw_loc_descr_ref
10442 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
10445 dw_loc_descr_ref loc_result = NULL;
10447 if (!(dwarf_version >= 4 || !dwarf_strict))
10450 litsize = size_of_int_loc_descriptor (i);
10451 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
10452 is more compact. For DW_OP_stack_value we need:
10453 litsize + 1 (DW_OP_stack_value)
10454 and for DW_OP_implicit_value:
10455 1 (DW_OP_implicit_value) + 1 (length) + size. */
10456 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
10458 loc_result = int_loc_descriptor (i);
10459 add_loc_descr (&loc_result,
10460 new_loc_descr (DW_OP_stack_value, 0, 0));
10464 loc_result = new_loc_descr (DW_OP_implicit_value,
10466 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
10467 loc_result->dw_loc_oprnd2.v.val_int = i;
10471 /* Return a location descriptor that designates a base+offset location. */
10473 static dw_loc_descr_ref
10474 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
10475 enum var_init_status initialized)
10477 unsigned int regno;
10478 dw_loc_descr_ref result;
10479 dw_fde_ref fde = cfun->fde;
10481 /* We only use "frame base" when we're sure we're talking about the
10482 post-prologue local stack frame. We do this by *not* running
10483 register elimination until this point, and recognizing the special
10484 argument pointer and soft frame pointer rtx's. */
10485 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
10487 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10491 if (GET_CODE (elim) == PLUS)
10493 offset += INTVAL (XEXP (elim, 1));
10494 elim = XEXP (elim, 0);
10496 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
10497 && (elim == hard_frame_pointer_rtx
10498 || elim == stack_pointer_rtx))
10499 || elim == (frame_pointer_needed
10500 ? hard_frame_pointer_rtx
10501 : stack_pointer_rtx));
10503 /* If drap register is used to align stack, use frame
10504 pointer + offset to access stack variables. If stack
10505 is aligned without drap, use stack pointer + offset to
10506 access stack variables. */
10507 if (crtl->stack_realign_tried
10508 && reg == frame_pointer_rtx)
10511 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
10512 ? HARD_FRAME_POINTER_REGNUM
10514 return new_reg_loc_descr (base_reg, offset);
10517 gcc_assert (frame_pointer_fb_offset_valid);
10518 offset += frame_pointer_fb_offset;
10519 return new_loc_descr (DW_OP_fbreg, offset, 0);
10523 regno = DWARF_FRAME_REGNUM (REGNO (reg));
10525 if (!optimize && fde
10526 && (fde->drap_reg == regno || fde->vdrap_reg == regno))
10528 /* Use cfa+offset to represent the location of arguments passed
10529 on the stack when drap is used to align stack.
10530 Only do this when not optimizing, for optimized code var-tracking
10531 is supposed to track where the arguments live and the register
10532 used as vdrap or drap in some spot might be used for something
10533 else in other part of the routine. */
10534 return new_loc_descr (DW_OP_fbreg, offset, 0);
10538 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
10541 result = new_loc_descr (DW_OP_bregx, regno, offset);
10543 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10544 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10549 /* Return true if this RTL expression describes a base+offset calculation. */
10552 is_based_loc (const_rtx rtl)
10554 return (GET_CODE (rtl) == PLUS
10555 && ((REG_P (XEXP (rtl, 0))
10556 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
10557 && CONST_INT_P (XEXP (rtl, 1)))));
10560 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
10563 static dw_loc_descr_ref
10564 tls_mem_loc_descriptor (rtx mem)
10567 dw_loc_descr_ref loc_result;
10569 if (MEM_EXPR (mem) == NULL_TREE || !MEM_OFFSET_KNOWN_P (mem))
10572 base = get_base_address (MEM_EXPR (mem));
10574 || TREE_CODE (base) != VAR_DECL
10575 || !DECL_THREAD_LOCAL_P (base))
10578 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1);
10579 if (loc_result == NULL)
10582 if (MEM_OFFSET (mem))
10583 loc_descr_plus_const (&loc_result, MEM_OFFSET (mem));
10588 /* Output debug info about reason why we failed to expand expression as dwarf
10592 expansion_failed (tree expr, rtx rtl, char const *reason)
10594 if (dump_file && (dump_flags & TDF_DETAILS))
10596 fprintf (dump_file, "Failed to expand as dwarf: ");
10598 print_generic_expr (dump_file, expr, dump_flags);
10601 fprintf (dump_file, "\n");
10602 print_rtl (dump_file, rtl);
10604 fprintf (dump_file, "\nReason: %s\n", reason);
10608 /* Helper function for const_ok_for_output, called either directly
10609 or via for_each_rtx. */
10612 const_ok_for_output_1 (rtx *rtlp, void *data ATTRIBUTE_UNUSED)
10616 if (GET_CODE (rtl) == UNSPEC)
10618 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
10619 we can't express it in the debug info. */
10620 #ifdef ENABLE_CHECKING
10621 /* Don't complain about TLS UNSPECs, those are just too hard to
10623 if (XVECLEN (rtl, 0) != 1
10624 || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
10625 || SYMBOL_REF_DECL (XVECEXP (rtl, 0, 0)) == NULL
10626 || TREE_CODE (SYMBOL_REF_DECL (XVECEXP (rtl, 0, 0))) != VAR_DECL
10627 || !DECL_THREAD_LOCAL_P (SYMBOL_REF_DECL (XVECEXP (rtl, 0, 0))))
10628 inform (current_function_decl
10629 ? DECL_SOURCE_LOCATION (current_function_decl)
10630 : UNKNOWN_LOCATION,
10631 #if NUM_UNSPEC_VALUES > 0
10632 "non-delegitimized UNSPEC %s (%d) found in variable location",
10633 ((XINT (rtl, 1) >= 0 && XINT (rtl, 1) < NUM_UNSPEC_VALUES)
10634 ? unspec_strings[XINT (rtl, 1)] : "unknown"),
10637 "non-delegitimized UNSPEC %d found in variable location",
10641 expansion_failed (NULL_TREE, rtl,
10642 "UNSPEC hasn't been delegitimized.\n");
10646 if (GET_CODE (rtl) != SYMBOL_REF)
10649 if (CONSTANT_POOL_ADDRESS_P (rtl))
10652 get_pool_constant_mark (rtl, &marked);
10653 /* If all references to this pool constant were optimized away,
10654 it was not output and thus we can't represent it. */
10657 expansion_failed (NULL_TREE, rtl,
10658 "Constant was removed from constant pool.\n");
10663 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
10666 /* Avoid references to external symbols in debug info, on several targets
10667 the linker might even refuse to link when linking a shared library,
10668 and in many other cases the relocations for .debug_info/.debug_loc are
10669 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
10670 to be defined within the same shared library or executable are fine. */
10671 if (SYMBOL_REF_EXTERNAL_P (rtl))
10673 tree decl = SYMBOL_REF_DECL (rtl);
10675 if (decl == NULL || !targetm.binds_local_p (decl))
10677 expansion_failed (NULL_TREE, rtl,
10678 "Symbol not defined in current TU.\n");
10686 /* Return true if constant RTL can be emitted in DW_OP_addr or
10687 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
10688 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
10691 const_ok_for_output (rtx rtl)
10693 if (GET_CODE (rtl) == SYMBOL_REF)
10694 return const_ok_for_output_1 (&rtl, NULL) == 0;
10696 if (GET_CODE (rtl) == CONST)
10697 return for_each_rtx (&XEXP (rtl, 0), const_ok_for_output_1, NULL) == 0;
10702 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
10703 if possible, NULL otherwise. */
10706 base_type_for_mode (enum machine_mode mode, bool unsignedp)
10708 dw_die_ref type_die;
10709 tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
10713 switch (TREE_CODE (type))
10721 type_die = lookup_type_die (type);
10723 type_die = modified_type_die (type, false, false, comp_unit_die ());
10724 if (type_die == NULL || type_die->die_tag != DW_TAG_base_type)
10729 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
10730 type matching MODE, or, if MODE is narrower than or as wide as
10731 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
10734 static dw_loc_descr_ref
10735 convert_descriptor_to_mode (enum machine_mode mode, dw_loc_descr_ref op)
10737 enum machine_mode outer_mode = mode;
10738 dw_die_ref type_die;
10739 dw_loc_descr_ref cvt;
10741 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
10743 add_loc_descr (&op, new_loc_descr (DW_OP_GNU_convert, 0, 0));
10746 type_die = base_type_for_mode (outer_mode, 1);
10747 if (type_die == NULL)
10749 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
10750 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
10751 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
10752 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
10753 add_loc_descr (&op, cvt);
10757 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
10759 static dw_loc_descr_ref
10760 compare_loc_descriptor (enum dwarf_location_atom op, dw_loc_descr_ref op0,
10761 dw_loc_descr_ref op1)
10763 dw_loc_descr_ref ret = op0;
10764 add_loc_descr (&ret, op1);
10765 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10766 if (STORE_FLAG_VALUE != 1)
10768 add_loc_descr (&ret, int_loc_descriptor (STORE_FLAG_VALUE));
10769 add_loc_descr (&ret, new_loc_descr (DW_OP_mul, 0, 0));
10774 /* Return location descriptor for signed comparison OP RTL. */
10776 static dw_loc_descr_ref
10777 scompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
10778 enum machine_mode mem_mode)
10780 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
10781 dw_loc_descr_ref op0, op1;
10784 if (op_mode == VOIDmode)
10785 op_mode = GET_MODE (XEXP (rtl, 1));
10786 if (op_mode == VOIDmode)
10790 && (GET_MODE_CLASS (op_mode) != MODE_INT
10791 || GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE))
10794 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
10795 VAR_INIT_STATUS_INITIALIZED);
10796 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
10797 VAR_INIT_STATUS_INITIALIZED);
10799 if (op0 == NULL || op1 == NULL)
10802 if (GET_MODE_CLASS (op_mode) != MODE_INT
10803 || GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
10804 return compare_loc_descriptor (op, op0, op1);
10806 if (GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
10808 dw_die_ref type_die = base_type_for_mode (op_mode, 0);
10809 dw_loc_descr_ref cvt;
10811 if (type_die == NULL)
10813 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
10814 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
10815 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
10816 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
10817 add_loc_descr (&op0, cvt);
10818 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
10819 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
10820 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
10821 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
10822 add_loc_descr (&op1, cvt);
10823 return compare_loc_descriptor (op, op0, op1);
10826 shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode)) * BITS_PER_UNIT;
10827 /* For eq/ne, if the operands are known to be zero-extended,
10828 there is no need to do the fancy shifting up. */
10829 if (op == DW_OP_eq || op == DW_OP_ne)
10831 dw_loc_descr_ref last0, last1;
10832 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
10834 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
10836 /* deref_size zero extends, and for constants we can check
10837 whether they are zero extended or not. */
10838 if (((last0->dw_loc_opc == DW_OP_deref_size
10839 && last0->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
10840 || (CONST_INT_P (XEXP (rtl, 0))
10841 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
10842 == (INTVAL (XEXP (rtl, 0)) & GET_MODE_MASK (op_mode))))
10843 && ((last1->dw_loc_opc == DW_OP_deref_size
10844 && last1->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
10845 || (CONST_INT_P (XEXP (rtl, 1))
10846 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 1))
10847 == (INTVAL (XEXP (rtl, 1)) & GET_MODE_MASK (op_mode)))))
10848 return compare_loc_descriptor (op, op0, op1);
10850 /* EQ/NE comparison against constant in narrower type than
10851 DWARF2_ADDR_SIZE can be performed either as
10852 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
10855 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
10856 DW_OP_{eq,ne}. Pick whatever is shorter. */
10857 if (CONST_INT_P (XEXP (rtl, 1))
10858 && GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
10859 && (size_of_int_loc_descriptor (shift) + 1
10860 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift)
10861 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode)) + 1
10862 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1))
10863 & GET_MODE_MASK (op_mode))))
10865 add_loc_descr (&op0, int_loc_descriptor (GET_MODE_MASK (op_mode)));
10866 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
10867 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1))
10868 & GET_MODE_MASK (op_mode));
10869 return compare_loc_descriptor (op, op0, op1);
10872 add_loc_descr (&op0, int_loc_descriptor (shift));
10873 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
10874 if (CONST_INT_P (XEXP (rtl, 1)))
10875 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
10878 add_loc_descr (&op1, int_loc_descriptor (shift));
10879 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
10881 return compare_loc_descriptor (op, op0, op1);
10884 /* Return location descriptor for unsigned comparison OP RTL. */
10886 static dw_loc_descr_ref
10887 ucompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
10888 enum machine_mode mem_mode)
10890 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
10891 dw_loc_descr_ref op0, op1;
10893 if (op_mode == VOIDmode)
10894 op_mode = GET_MODE (XEXP (rtl, 1));
10895 if (op_mode == VOIDmode)
10897 if (GET_MODE_CLASS (op_mode) != MODE_INT)
10900 if (dwarf_strict && GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
10903 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
10904 VAR_INIT_STATUS_INITIALIZED);
10905 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
10906 VAR_INIT_STATUS_INITIALIZED);
10908 if (op0 == NULL || op1 == NULL)
10911 if (GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
10913 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
10914 dw_loc_descr_ref last0, last1;
10915 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
10917 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
10919 if (CONST_INT_P (XEXP (rtl, 0)))
10920 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
10921 /* deref_size zero extends, so no need to mask it again. */
10922 else if (last0->dw_loc_opc != DW_OP_deref_size
10923 || last0->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
10925 add_loc_descr (&op0, int_loc_descriptor (mask));
10926 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
10928 if (CONST_INT_P (XEXP (rtl, 1)))
10929 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
10930 /* deref_size zero extends, so no need to mask it again. */
10931 else if (last1->dw_loc_opc != DW_OP_deref_size
10932 || last1->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
10934 add_loc_descr (&op1, int_loc_descriptor (mask));
10935 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
10938 else if (GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
10940 HOST_WIDE_INT bias = 1;
10941 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
10942 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
10943 if (CONST_INT_P (XEXP (rtl, 1)))
10944 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
10945 + INTVAL (XEXP (rtl, 1)));
10947 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
10950 return compare_loc_descriptor (op, op0, op1);
10953 /* Return location descriptor for {U,S}{MIN,MAX}. */
10955 static dw_loc_descr_ref
10956 minmax_loc_descriptor (rtx rtl, enum machine_mode mode,
10957 enum machine_mode mem_mode)
10959 enum dwarf_location_atom op;
10960 dw_loc_descr_ref op0, op1, ret;
10961 dw_loc_descr_ref bra_node, drop_node;
10964 && (GET_MODE_CLASS (mode) != MODE_INT
10965 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE))
10968 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
10969 VAR_INIT_STATUS_INITIALIZED);
10970 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
10971 VAR_INIT_STATUS_INITIALIZED);
10973 if (op0 == NULL || op1 == NULL)
10976 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
10977 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
10978 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
10979 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
10981 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
10983 HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10984 add_loc_descr (&op0, int_loc_descriptor (mask));
10985 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
10986 add_loc_descr (&op1, int_loc_descriptor (mask));
10987 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
10989 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
10991 HOST_WIDE_INT bias = 1;
10992 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
10993 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
10994 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
10997 else if (GET_MODE_CLASS (mode) == MODE_INT
10998 && GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
11000 int shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (mode)) * BITS_PER_UNIT;
11001 add_loc_descr (&op0, int_loc_descriptor (shift));
11002 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
11003 add_loc_descr (&op1, int_loc_descriptor (shift));
11004 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
11006 else if (GET_MODE_CLASS (mode) == MODE_INT
11007 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
11009 dw_die_ref type_die = base_type_for_mode (mode, 0);
11010 dw_loc_descr_ref cvt;
11011 if (type_die == NULL)
11013 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11014 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11015 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11016 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11017 add_loc_descr (&op0, cvt);
11018 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11019 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11020 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11021 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11022 add_loc_descr (&op1, cvt);
11025 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
11030 add_loc_descr (&ret, op1);
11031 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
11032 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
11033 add_loc_descr (&ret, bra_node);
11034 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11035 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
11036 add_loc_descr (&ret, drop_node);
11037 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
11038 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
11039 if ((GET_CODE (rtl) == SMIN || GET_CODE (rtl) == SMAX)
11040 && GET_MODE_CLASS (mode) == MODE_INT
11041 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
11042 ret = convert_descriptor_to_mode (mode, ret);
11046 /* Helper function for mem_loc_descriptor. Perform OP binary op,
11047 but after converting arguments to type_die, afterwards
11048 convert back to unsigned. */
11050 static dw_loc_descr_ref
11051 typed_binop (enum dwarf_location_atom op, rtx rtl, dw_die_ref type_die,
11052 enum machine_mode mode, enum machine_mode mem_mode)
11054 dw_loc_descr_ref cvt, op0, op1;
11056 if (type_die == NULL)
11058 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11059 VAR_INIT_STATUS_INITIALIZED);
11060 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
11061 VAR_INIT_STATUS_INITIALIZED);
11062 if (op0 == NULL || op1 == NULL)
11064 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11065 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11066 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11067 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11068 add_loc_descr (&op0, cvt);
11069 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11070 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11071 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11072 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11073 add_loc_descr (&op1, cvt);
11074 add_loc_descr (&op0, op1);
11075 add_loc_descr (&op0, new_loc_descr (op, 0, 0));
11076 return convert_descriptor_to_mode (mode, op0);
11079 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
11080 const0 is DW_OP_lit0 or corresponding typed constant,
11081 const1 is DW_OP_lit1 or corresponding typed constant
11082 and constMSB is constant with just the MSB bit set
11084 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11085 L1: const0 DW_OP_swap
11086 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
11087 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11092 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
11093 L1: const0 DW_OP_swap
11094 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11095 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11100 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
11101 L1: const1 DW_OP_swap
11102 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
11103 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
11107 static dw_loc_descr_ref
11108 clz_loc_descriptor (rtx rtl, enum machine_mode mode,
11109 enum machine_mode mem_mode)
11111 dw_loc_descr_ref op0, ret, tmp;
11112 HOST_WIDE_INT valv;
11113 dw_loc_descr_ref l1jump, l1label;
11114 dw_loc_descr_ref l2jump, l2label;
11115 dw_loc_descr_ref l3jump, l3label;
11116 dw_loc_descr_ref l4jump, l4label;
11119 if (GET_MODE_CLASS (mode) != MODE_INT
11120 || GET_MODE (XEXP (rtl, 0)) != mode
11121 || (GET_CODE (rtl) == CLZ
11122 && GET_MODE_BITSIZE (mode) > 2 * HOST_BITS_PER_WIDE_INT))
11125 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11126 VAR_INIT_STATUS_INITIALIZED);
11130 if (GET_CODE (rtl) == CLZ)
11132 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode, valv))
11133 valv = GET_MODE_BITSIZE (mode);
11135 else if (GET_CODE (rtl) == FFS)
11137 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode, valv))
11138 valv = GET_MODE_BITSIZE (mode);
11139 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
11140 l1jump = new_loc_descr (DW_OP_bra, 0, 0);
11141 add_loc_descr (&ret, l1jump);
11142 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
11143 tmp = mem_loc_descriptor (GEN_INT (valv), mode, mem_mode,
11144 VAR_INIT_STATUS_INITIALIZED);
11147 add_loc_descr (&ret, tmp);
11148 l4jump = new_loc_descr (DW_OP_skip, 0, 0);
11149 add_loc_descr (&ret, l4jump);
11150 l1label = mem_loc_descriptor (GET_CODE (rtl) == FFS
11151 ? const1_rtx : const0_rtx,
11153 VAR_INIT_STATUS_INITIALIZED);
11154 if (l1label == NULL)
11156 add_loc_descr (&ret, l1label);
11157 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11158 l2label = new_loc_descr (DW_OP_dup, 0, 0);
11159 add_loc_descr (&ret, l2label);
11160 if (GET_CODE (rtl) != CLZ)
11162 else if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11163 msb = GEN_INT ((unsigned HOST_WIDE_INT) 1
11164 << (GET_MODE_BITSIZE (mode) - 1));
11166 msb = immed_double_const (0, (unsigned HOST_WIDE_INT) 1
11167 << (GET_MODE_BITSIZE (mode)
11168 - HOST_BITS_PER_WIDE_INT - 1), mode);
11169 if (GET_CODE (msb) == CONST_INT && INTVAL (msb) < 0)
11170 tmp = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
11171 ? DW_OP_const4u : HOST_BITS_PER_WIDE_INT == 64
11172 ? DW_OP_const8u : DW_OP_constu, INTVAL (msb), 0);
11174 tmp = mem_loc_descriptor (msb, mode, mem_mode,
11175 VAR_INIT_STATUS_INITIALIZED);
11178 add_loc_descr (&ret, tmp);
11179 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
11180 l3jump = new_loc_descr (DW_OP_bra, 0, 0);
11181 add_loc_descr (&ret, l3jump);
11182 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
11183 VAR_INIT_STATUS_INITIALIZED);
11186 add_loc_descr (&ret, tmp);
11187 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == CLZ
11188 ? DW_OP_shl : DW_OP_shr, 0, 0));
11189 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11190 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, 1, 0));
11191 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11192 l2jump = new_loc_descr (DW_OP_skip, 0, 0);
11193 add_loc_descr (&ret, l2jump);
11194 l3label = new_loc_descr (DW_OP_drop, 0, 0);
11195 add_loc_descr (&ret, l3label);
11196 l4label = new_loc_descr (DW_OP_nop, 0, 0);
11197 add_loc_descr (&ret, l4label);
11198 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
11199 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
11200 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
11201 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
11202 l3jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
11203 l3jump->dw_loc_oprnd1.v.val_loc = l3label;
11204 l4jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
11205 l4jump->dw_loc_oprnd1.v.val_loc = l4label;
11209 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
11210 const1 is DW_OP_lit1 or corresponding typed constant):
11212 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
11213 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
11217 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
11218 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
11221 static dw_loc_descr_ref
11222 popcount_loc_descriptor (rtx rtl, enum machine_mode mode,
11223 enum machine_mode mem_mode)
11225 dw_loc_descr_ref op0, ret, tmp;
11226 dw_loc_descr_ref l1jump, l1label;
11227 dw_loc_descr_ref l2jump, l2label;
11229 if (GET_MODE_CLASS (mode) != MODE_INT
11230 || GET_MODE (XEXP (rtl, 0)) != mode)
11233 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11234 VAR_INIT_STATUS_INITIALIZED);
11238 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
11239 VAR_INIT_STATUS_INITIALIZED);
11242 add_loc_descr (&ret, tmp);
11243 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11244 l1label = new_loc_descr (DW_OP_dup, 0, 0);
11245 add_loc_descr (&ret, l1label);
11246 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
11247 add_loc_descr (&ret, l2jump);
11248 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
11249 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
11250 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
11251 VAR_INIT_STATUS_INITIALIZED);
11254 add_loc_descr (&ret, tmp);
11255 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
11256 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == POPCOUNT
11257 ? DW_OP_plus : DW_OP_xor, 0, 0));
11258 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11259 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
11260 VAR_INIT_STATUS_INITIALIZED);
11261 add_loc_descr (&ret, tmp);
11262 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
11263 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
11264 add_loc_descr (&ret, l1jump);
11265 l2label = new_loc_descr (DW_OP_drop, 0, 0);
11266 add_loc_descr (&ret, l2label);
11267 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
11268 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
11269 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
11270 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
11274 /* BSWAP (constS is initial shift count, either 56 or 24):
11276 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
11277 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
11278 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
11279 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
11280 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
11282 static dw_loc_descr_ref
11283 bswap_loc_descriptor (rtx rtl, enum machine_mode mode,
11284 enum machine_mode mem_mode)
11286 dw_loc_descr_ref op0, ret, tmp;
11287 dw_loc_descr_ref l1jump, l1label;
11288 dw_loc_descr_ref l2jump, l2label;
11290 if (GET_MODE_CLASS (mode) != MODE_INT
11291 || BITS_PER_UNIT != 8
11292 || (GET_MODE_BITSIZE (mode) != 32
11293 && GET_MODE_BITSIZE (mode) != 64))
11296 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11297 VAR_INIT_STATUS_INITIALIZED);
11302 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
11304 VAR_INIT_STATUS_INITIALIZED);
11307 add_loc_descr (&ret, tmp);
11308 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
11309 VAR_INIT_STATUS_INITIALIZED);
11312 add_loc_descr (&ret, tmp);
11313 l1label = new_loc_descr (DW_OP_pick, 2, 0);
11314 add_loc_descr (&ret, l1label);
11315 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
11317 VAR_INIT_STATUS_INITIALIZED);
11318 add_loc_descr (&ret, tmp);
11319 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 3, 0));
11320 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
11321 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
11322 tmp = mem_loc_descriptor (GEN_INT (255), mode, mem_mode,
11323 VAR_INIT_STATUS_INITIALIZED);
11326 add_loc_descr (&ret, tmp);
11327 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
11328 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 2, 0));
11329 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
11330 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
11331 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11332 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
11333 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
11334 VAR_INIT_STATUS_INITIALIZED);
11335 add_loc_descr (&ret, tmp);
11336 add_loc_descr (&ret, new_loc_descr (DW_OP_eq, 0, 0));
11337 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
11338 add_loc_descr (&ret, l2jump);
11339 tmp = mem_loc_descriptor (GEN_INT (8), mode, mem_mode,
11340 VAR_INIT_STATUS_INITIALIZED);
11341 add_loc_descr (&ret, tmp);
11342 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
11343 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11344 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
11345 add_loc_descr (&ret, l1jump);
11346 l2label = new_loc_descr (DW_OP_drop, 0, 0);
11347 add_loc_descr (&ret, l2label);
11348 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11349 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
11350 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
11351 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
11352 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
11353 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
11357 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
11358 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
11359 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
11360 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
11362 ROTATERT is similar:
11363 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
11364 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
11365 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
11367 static dw_loc_descr_ref
11368 rotate_loc_descriptor (rtx rtl, enum machine_mode mode,
11369 enum machine_mode mem_mode)
11371 rtx rtlop1 = XEXP (rtl, 1);
11372 dw_loc_descr_ref op0, op1, ret, mask[2] = { NULL, NULL };
11375 if (GET_MODE_CLASS (mode) != MODE_INT)
11378 if (GET_MODE (rtlop1) != VOIDmode
11379 && GET_MODE_BITSIZE (GET_MODE (rtlop1)) < GET_MODE_BITSIZE (mode))
11380 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
11381 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11382 VAR_INIT_STATUS_INITIALIZED);
11383 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
11384 VAR_INIT_STATUS_INITIALIZED);
11385 if (op0 == NULL || op1 == NULL)
11387 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
11388 for (i = 0; i < 2; i++)
11390 if (GET_MODE_BITSIZE (mode) < HOST_BITS_PER_WIDE_INT)
11391 mask[i] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode)),
11393 VAR_INIT_STATUS_INITIALIZED);
11394 else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
11395 mask[i] = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
11397 : HOST_BITS_PER_WIDE_INT == 64
11398 ? DW_OP_const8u : DW_OP_constu,
11399 GET_MODE_MASK (mode), 0);
11402 if (mask[i] == NULL)
11404 add_loc_descr (&mask[i], new_loc_descr (DW_OP_and, 0, 0));
11407 add_loc_descr (&ret, op1);
11408 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
11409 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
11410 if (GET_CODE (rtl) == ROTATERT)
11412 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
11413 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
11414 GET_MODE_BITSIZE (mode), 0));
11416 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
11417 if (mask[0] != NULL)
11418 add_loc_descr (&ret, mask[0]);
11419 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
11420 if (mask[1] != NULL)
11422 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11423 add_loc_descr (&ret, mask[1]);
11424 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
11426 if (GET_CODE (rtl) == ROTATE)
11428 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
11429 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
11430 GET_MODE_BITSIZE (mode), 0));
11432 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
11433 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
11437 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
11438 for DEBUG_PARAMETER_REF RTL. */
11440 static dw_loc_descr_ref
11441 parameter_ref_descriptor (rtx rtl)
11443 dw_loc_descr_ref ret;
11448 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl)) == PARM_DECL);
11449 ref = lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl));
11450 ret = new_loc_descr (DW_OP_GNU_parameter_ref, 0, 0);
11453 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11454 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
11455 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
11459 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
11460 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_PARAMETER_REF_DECL (rtl);
11465 /* Helper function to get mode of MEM's address. */
11468 get_address_mode (rtx mem)
11470 enum machine_mode mode = GET_MODE (XEXP (mem, 0));
11471 if (mode != VOIDmode)
11473 return targetm.addr_space.address_mode (MEM_ADDR_SPACE (mem));
11476 /* The following routine converts the RTL for a variable or parameter
11477 (resident in memory) into an equivalent Dwarf representation of a
11478 mechanism for getting the address of that same variable onto the top of a
11479 hypothetical "address evaluation" stack.
11481 When creating memory location descriptors, we are effectively transforming
11482 the RTL for a memory-resident object into its Dwarf postfix expression
11483 equivalent. This routine recursively descends an RTL tree, turning
11484 it into Dwarf postfix code as it goes.
11486 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
11488 MEM_MODE is the mode of the memory reference, needed to handle some
11489 autoincrement addressing modes.
11491 Return 0 if we can't represent the location. */
11494 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
11495 enum machine_mode mem_mode,
11496 enum var_init_status initialized)
11498 dw_loc_descr_ref mem_loc_result = NULL;
11499 enum dwarf_location_atom op;
11500 dw_loc_descr_ref op0, op1;
11502 if (mode == VOIDmode)
11503 mode = GET_MODE (rtl);
11505 /* Note that for a dynamically sized array, the location we will generate a
11506 description of here will be the lowest numbered location which is
11507 actually within the array. That's *not* necessarily the same as the
11508 zeroth element of the array. */
11510 rtl = targetm.delegitimize_address (rtl);
11512 if (mode != GET_MODE (rtl) && GET_MODE (rtl) != VOIDmode)
11515 switch (GET_CODE (rtl))
11520 return mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, initialized);
11523 /* The case of a subreg may arise when we have a local (register)
11524 variable or a formal (register) parameter which doesn't quite fill
11525 up an entire register. For now, just assume that it is
11526 legitimate to make the Dwarf info refer to the whole register which
11527 contains the given subreg. */
11528 if (!subreg_lowpart_p (rtl))
11530 if (GET_MODE_CLASS (mode) == MODE_INT
11531 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (rtl))) == MODE_INT
11532 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
11533 #ifdef POINTERS_EXTEND_UNSIGNED
11534 || (mode == Pmode && mem_mode != VOIDmode)
11537 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl))) <= DWARF2_ADDR_SIZE)
11539 mem_loc_result = mem_loc_descriptor (SUBREG_REG (rtl),
11540 GET_MODE (SUBREG_REG (rtl)),
11541 mem_mode, initialized);
11546 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl))))
11548 if (GET_MODE_SIZE (mode) != GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl)))
11549 && (GET_MODE_CLASS (mode) != MODE_INT
11550 || GET_MODE_CLASS (GET_MODE (SUBREG_REG (rtl))) != MODE_INT))
11554 dw_die_ref type_die;
11555 dw_loc_descr_ref cvt;
11557 mem_loc_result = mem_loc_descriptor (SUBREG_REG (rtl),
11558 GET_MODE (SUBREG_REG (rtl)),
11559 mem_mode, initialized);
11560 if (mem_loc_result == NULL)
11562 type_die = base_type_for_mode (mode,
11563 GET_MODE_CLASS (mode) == MODE_INT);
11564 if (type_die == NULL)
11566 mem_loc_result = NULL;
11569 if (GET_MODE_SIZE (mode)
11570 != GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl))))
11571 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11573 cvt = new_loc_descr (DW_OP_GNU_reinterpret, 0, 0);
11574 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11575 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11576 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11577 add_loc_descr (&mem_loc_result, cvt);
11582 if (GET_MODE_CLASS (mode) != MODE_INT
11583 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
11584 #ifdef POINTERS_EXTEND_UNSIGNED
11585 && (mode != Pmode || mem_mode == VOIDmode)
11589 dw_die_ref type_die;
11593 if (REGNO (rtl) > FIRST_PSEUDO_REGISTER)
11595 type_die = base_type_for_mode (mode,
11596 GET_MODE_CLASS (mode) == MODE_INT);
11597 if (type_die == NULL)
11599 mem_loc_result = new_loc_descr (DW_OP_GNU_regval_type,
11600 dbx_reg_number (rtl), 0);
11601 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
11602 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.die = type_die;
11603 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.external = 0;
11606 /* Whenever a register number forms a part of the description of the
11607 method for calculating the (dynamic) address of a memory resident
11608 object, DWARF rules require the register number be referred to as
11609 a "base register". This distinction is not based in any way upon
11610 what category of register the hardware believes the given register
11611 belongs to. This is strictly DWARF terminology we're dealing with
11612 here. Note that in cases where the location of a memory-resident
11613 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
11614 OP_CONST (0)) the actual DWARF location descriptor that we generate
11615 may just be OP_BASEREG (basereg). This may look deceptively like
11616 the object in question was allocated to a register (rather than in
11617 memory) so DWARF consumers need to be aware of the subtle
11618 distinction between OP_REG and OP_BASEREG. */
11619 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
11620 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
11621 else if (stack_realign_drap
11623 && crtl->args.internal_arg_pointer == rtl
11624 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
11626 /* If RTL is internal_arg_pointer, which has been optimized
11627 out, use DRAP instead. */
11628 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
11629 VAR_INIT_STATUS_INITIALIZED);
11635 if (GET_MODE_CLASS (mode) != MODE_INT)
11637 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
11638 mem_mode, VAR_INIT_STATUS_INITIALIZED);
11641 else if (GET_CODE (rtl) == ZERO_EXTEND
11642 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
11643 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
11644 < HOST_BITS_PER_WIDE_INT
11645 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
11646 to expand zero extend as two shifts instead of
11648 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= 4)
11650 enum machine_mode imode = GET_MODE (XEXP (rtl, 0));
11651 mem_loc_result = op0;
11652 add_loc_descr (&mem_loc_result,
11653 int_loc_descriptor (GET_MODE_MASK (imode)));
11654 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_and, 0, 0));
11656 else if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
11658 int shift = DWARF2_ADDR_SIZE
11659 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
11660 shift *= BITS_PER_UNIT;
11661 if (GET_CODE (rtl) == SIGN_EXTEND)
11665 mem_loc_result = op0;
11666 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
11667 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
11668 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
11669 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11671 else if (!dwarf_strict)
11673 dw_die_ref type_die1, type_die2;
11674 dw_loc_descr_ref cvt;
11676 type_die1 = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
11677 GET_CODE (rtl) == ZERO_EXTEND);
11678 if (type_die1 == NULL)
11680 type_die2 = base_type_for_mode (mode, 1);
11681 if (type_die2 == NULL)
11683 mem_loc_result = op0;
11684 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11685 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11686 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die1;
11687 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11688 add_loc_descr (&mem_loc_result, cvt);
11689 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11690 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11691 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die2;
11692 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11693 add_loc_descr (&mem_loc_result, cvt);
11698 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0),
11699 get_address_mode (rtl), mode,
11700 VAR_INIT_STATUS_INITIALIZED);
11701 if (mem_loc_result == NULL)
11702 mem_loc_result = tls_mem_loc_descriptor (rtl);
11703 if (mem_loc_result != 0)
11705 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
11706 || GET_MODE_CLASS (mode) != MODE_INT)
11708 dw_die_ref type_die;
11709 dw_loc_descr_ref deref;
11714 = base_type_for_mode (mode, GET_MODE_CLASS (mode) == MODE_INT);
11715 if (type_die == NULL)
11717 deref = new_loc_descr (DW_OP_GNU_deref_type,
11718 GET_MODE_SIZE (mode), 0);
11719 deref->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
11720 deref->dw_loc_oprnd2.v.val_die_ref.die = type_die;
11721 deref->dw_loc_oprnd2.v.val_die_ref.external = 0;
11722 add_loc_descr (&mem_loc_result, deref);
11724 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
11725 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
11727 add_loc_descr (&mem_loc_result,
11728 new_loc_descr (DW_OP_deref_size,
11729 GET_MODE_SIZE (mode), 0));
11733 rtx new_rtl = avoid_constant_pool_reference (rtl);
11734 if (new_rtl != rtl)
11735 return mem_loc_descriptor (new_rtl, mode, mem_mode, initialized);
11740 return mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, initialized);
11743 /* Some ports can transform a symbol ref into a label ref, because
11744 the symbol ref is too far away and has to be dumped into a constant
11748 if (GET_MODE_CLASS (mode) != MODE_INT
11749 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
11750 #ifdef POINTERS_EXTEND_UNSIGNED
11751 && (mode != Pmode || mem_mode == VOIDmode)
11755 if (GET_CODE (rtl) == SYMBOL_REF
11756 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
11758 dw_loc_descr_ref temp;
11760 /* If this is not defined, we have no way to emit the data. */
11761 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
11764 /* We used to emit DW_OP_addr here, but that's wrong, since
11765 DW_OP_addr should be relocated by the debug info consumer,
11766 while DW_OP_GNU_push_tls_address operand should not. */
11767 temp = new_loc_descr (DWARF2_ADDR_SIZE == 4
11768 ? DW_OP_const4u : DW_OP_const8u, 0, 0);
11769 temp->dw_loc_oprnd1.val_class = dw_val_class_addr;
11770 temp->dw_loc_oprnd1.v.val_addr = rtl;
11771 temp->dtprel = true;
11773 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
11774 add_loc_descr (&mem_loc_result, temp);
11779 if (!const_ok_for_output (rtl))
11783 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
11784 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
11785 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
11786 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11792 case DEBUG_IMPLICIT_PTR:
11793 expansion_failed (NULL_TREE, rtl,
11794 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
11800 if (REG_P (ENTRY_VALUE_EXP (rtl)))
11802 if (GET_MODE_CLASS (mode) != MODE_INT
11803 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
11804 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
11805 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
11808 = one_reg_loc_descriptor (dbx_reg_number (ENTRY_VALUE_EXP (rtl)),
11809 VAR_INIT_STATUS_INITIALIZED);
11811 else if (MEM_P (ENTRY_VALUE_EXP (rtl))
11812 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl), 0)))
11814 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
11815 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
11816 if (op0 && op0->dw_loc_opc == DW_OP_fbreg)
11820 gcc_unreachable ();
11823 mem_loc_result = new_loc_descr (DW_OP_GNU_entry_value, 0, 0);
11824 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_loc;
11825 mem_loc_result->dw_loc_oprnd1.v.val_loc = op0;
11828 case DEBUG_PARAMETER_REF:
11829 mem_loc_result = parameter_ref_descriptor (rtl);
11833 /* Extract the PLUS expression nested inside and fall into
11834 PLUS code below. */
11835 rtl = XEXP (rtl, 1);
11840 /* Turn these into a PLUS expression and fall into the PLUS code
11842 rtl = gen_rtx_PLUS (mode, XEXP (rtl, 0),
11843 GEN_INT (GET_CODE (rtl) == PRE_INC
11844 ? GET_MODE_UNIT_SIZE (mem_mode)
11845 : -GET_MODE_UNIT_SIZE (mem_mode)));
11847 /* ... fall through ... */
11851 if (is_based_loc (rtl)
11852 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
11853 && GET_MODE_CLASS (mode) == MODE_INT)
11854 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
11855 INTVAL (XEXP (rtl, 1)),
11856 VAR_INIT_STATUS_INITIALIZED);
11859 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11860 VAR_INIT_STATUS_INITIALIZED);
11861 if (mem_loc_result == 0)
11864 if (CONST_INT_P (XEXP (rtl, 1))
11865 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
11866 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
11869 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
11870 VAR_INIT_STATUS_INITIALIZED);
11873 add_loc_descr (&mem_loc_result, op1);
11874 add_loc_descr (&mem_loc_result,
11875 new_loc_descr (DW_OP_plus, 0, 0));
11880 /* If a pseudo-reg is optimized away, it is possible for it to
11881 be replaced with a MEM containing a multiply or shift. */
11892 && GET_MODE_CLASS (mode) == MODE_INT
11893 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
11895 mem_loc_result = typed_binop (DW_OP_div, rtl,
11896 base_type_for_mode (mode, 0),
11920 if (GET_MODE_CLASS (mode) != MODE_INT)
11922 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11923 VAR_INIT_STATUS_INITIALIZED);
11925 rtx rtlop1 = XEXP (rtl, 1);
11926 if (GET_MODE (rtlop1) != VOIDmode
11927 && GET_MODE_BITSIZE (GET_MODE (rtlop1))
11928 < GET_MODE_BITSIZE (mode))
11929 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
11930 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
11931 VAR_INIT_STATUS_INITIALIZED);
11934 if (op0 == 0 || op1 == 0)
11937 mem_loc_result = op0;
11938 add_loc_descr (&mem_loc_result, op1);
11939 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11955 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11956 VAR_INIT_STATUS_INITIALIZED);
11957 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
11958 VAR_INIT_STATUS_INITIALIZED);
11960 if (op0 == 0 || op1 == 0)
11963 mem_loc_result = op0;
11964 add_loc_descr (&mem_loc_result, op1);
11965 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11969 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE && !dwarf_strict)
11971 mem_loc_result = typed_binop (DW_OP_mod, rtl,
11972 base_type_for_mode (mode, 0),
11977 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11978 VAR_INIT_STATUS_INITIALIZED);
11979 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
11980 VAR_INIT_STATUS_INITIALIZED);
11982 if (op0 == 0 || op1 == 0)
11985 mem_loc_result = op0;
11986 add_loc_descr (&mem_loc_result, op1);
11987 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
11988 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
11989 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0));
11990 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
11991 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
11995 if (!dwarf_strict && GET_MODE_CLASS (mode) == MODE_INT)
11997 if (GET_MODE_CLASS (mode) > DWARF2_ADDR_SIZE)
12002 mem_loc_result = typed_binop (DW_OP_div, rtl,
12003 base_type_for_mode (mode, 1),
12021 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12022 VAR_INIT_STATUS_INITIALIZED);
12027 mem_loc_result = op0;
12028 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12032 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12033 #ifdef POINTERS_EXTEND_UNSIGNED
12035 && mem_mode != VOIDmode
12036 && trunc_int_for_mode (INTVAL (rtl), ptr_mode) == INTVAL (rtl))
12040 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
12044 && (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT
12045 || GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT))
12047 dw_die_ref type_die = base_type_for_mode (mode, 1);
12048 enum machine_mode amode;
12049 if (type_die == NULL)
12051 amode = mode_for_size (DWARF2_ADDR_SIZE * BITS_PER_UNIT,
12053 if (INTVAL (rtl) >= 0
12054 && amode != BLKmode
12055 && trunc_int_for_mode (INTVAL (rtl), amode) == INTVAL (rtl)
12056 /* const DW_OP_GNU_convert <XXX> vs.
12057 DW_OP_GNU_const_type <XXX, 1, const>. */
12058 && size_of_int_loc_descriptor (INTVAL (rtl)) + 1 + 1
12059 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode))
12061 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
12062 op0 = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12063 op0->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12064 op0->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12065 op0->dw_loc_oprnd1.v.val_die_ref.external = 0;
12066 add_loc_descr (&mem_loc_result, op0);
12067 return mem_loc_result;
12069 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0,
12071 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12072 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12073 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
12074 if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
12075 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
12078 mem_loc_result->dw_loc_oprnd2.val_class
12079 = dw_val_class_const_double;
12080 mem_loc_result->dw_loc_oprnd2.v.val_double
12081 = shwi_to_double_int (INTVAL (rtl));
12089 dw_die_ref type_die;
12091 /* Note that a CONST_DOUBLE rtx could represent either an integer
12092 or a floating-point constant. A CONST_DOUBLE is used whenever
12093 the constant requires more than one word in order to be
12094 adequately represented. We output CONST_DOUBLEs as blocks. */
12095 if (mode == VOIDmode
12096 || (GET_MODE (rtl) == VOIDmode
12097 && GET_MODE_BITSIZE (mode) != 2 * HOST_BITS_PER_WIDE_INT))
12099 type_die = base_type_for_mode (mode,
12100 GET_MODE_CLASS (mode) == MODE_INT);
12101 if (type_die == NULL)
12103 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0);
12104 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12105 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12106 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
12107 if (SCALAR_FLOAT_MODE_P (mode))
12109 unsigned int length = GET_MODE_SIZE (mode);
12110 unsigned char *array
12111 = (unsigned char*) ggc_alloc_atomic (length);
12113 insert_float (rtl, array);
12114 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
12115 mem_loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
12116 mem_loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
12117 mem_loc_result->dw_loc_oprnd2.v.val_vec.array = array;
12121 mem_loc_result->dw_loc_oprnd2.val_class
12122 = dw_val_class_const_double;
12123 mem_loc_result->dw_loc_oprnd2.v.val_double
12124 = rtx_to_double_int (rtl);
12130 mem_loc_result = scompare_loc_descriptor (DW_OP_eq, rtl, mem_mode);
12134 mem_loc_result = scompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
12138 mem_loc_result = scompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
12142 mem_loc_result = scompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
12146 mem_loc_result = scompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
12150 mem_loc_result = scompare_loc_descriptor (DW_OP_ne, rtl, mem_mode);
12154 mem_loc_result = ucompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
12158 mem_loc_result = ucompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
12162 mem_loc_result = ucompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
12166 mem_loc_result = ucompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
12171 if (GET_MODE_CLASS (mode) != MODE_INT)
12176 mem_loc_result = minmax_loc_descriptor (rtl, mode, mem_mode);
12181 if (CONST_INT_P (XEXP (rtl, 1))
12182 && CONST_INT_P (XEXP (rtl, 2))
12183 && ((unsigned) INTVAL (XEXP (rtl, 1))
12184 + (unsigned) INTVAL (XEXP (rtl, 2))
12185 <= GET_MODE_BITSIZE (mode))
12186 && GET_MODE_CLASS (mode) == MODE_INT
12187 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12188 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
12191 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
12192 mem_mode, VAR_INIT_STATUS_INITIALIZED);
12195 if (GET_CODE (rtl) == SIGN_EXTRACT)
12199 mem_loc_result = op0;
12200 size = INTVAL (XEXP (rtl, 1));
12201 shift = INTVAL (XEXP (rtl, 2));
12202 if (BITS_BIG_ENDIAN)
12203 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
12205 if (shift + size != (int) DWARF2_ADDR_SIZE)
12207 add_loc_descr (&mem_loc_result,
12208 int_loc_descriptor (DWARF2_ADDR_SIZE
12210 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
12212 if (size != (int) DWARF2_ADDR_SIZE)
12214 add_loc_descr (&mem_loc_result,
12215 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
12216 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12223 dw_loc_descr_ref op2, bra_node, drop_node;
12224 op0 = mem_loc_descriptor (XEXP (rtl, 0),
12225 GET_MODE (XEXP (rtl, 0)) == VOIDmode
12226 ? word_mode : GET_MODE (XEXP (rtl, 0)),
12227 mem_mode, VAR_INIT_STATUS_INITIALIZED);
12228 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12229 VAR_INIT_STATUS_INITIALIZED);
12230 op2 = mem_loc_descriptor (XEXP (rtl, 2), mode, mem_mode,
12231 VAR_INIT_STATUS_INITIALIZED);
12232 if (op0 == NULL || op1 == NULL || op2 == NULL)
12235 mem_loc_result = op1;
12236 add_loc_descr (&mem_loc_result, op2);
12237 add_loc_descr (&mem_loc_result, op0);
12238 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
12239 add_loc_descr (&mem_loc_result, bra_node);
12240 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
12241 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
12242 add_loc_descr (&mem_loc_result, drop_node);
12243 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
12244 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
12249 case FLOAT_TRUNCATE:
12251 case UNSIGNED_FLOAT:
12256 dw_die_ref type_die;
12257 dw_loc_descr_ref cvt;
12259 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
12260 mem_mode, VAR_INIT_STATUS_INITIALIZED);
12263 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) == MODE_INT
12264 && (GET_CODE (rtl) == FLOAT
12265 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)))
12266 <= DWARF2_ADDR_SIZE))
12268 type_die = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
12269 GET_CODE (rtl) == UNSIGNED_FLOAT);
12270 if (type_die == NULL)
12272 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12273 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12274 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12275 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12276 add_loc_descr (&op0, cvt);
12278 type_die = base_type_for_mode (mode, GET_CODE (rtl) == UNSIGNED_FIX);
12279 if (type_die == NULL)
12281 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12282 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12283 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12284 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12285 add_loc_descr (&op0, cvt);
12286 if (GET_MODE_CLASS (mode) == MODE_INT
12287 && (GET_CODE (rtl) == FIX
12288 || GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE))
12290 op0 = convert_descriptor_to_mode (mode, op0);
12294 mem_loc_result = op0;
12301 mem_loc_result = clz_loc_descriptor (rtl, mode, mem_mode);
12306 mem_loc_result = popcount_loc_descriptor (rtl, mode, mem_mode);
12310 mem_loc_result = bswap_loc_descriptor (rtl, mode, mem_mode);
12315 mem_loc_result = rotate_loc_descriptor (rtl, mode, mem_mode);
12320 /* In theory, we could implement the above. */
12321 /* DWARF cannot represent the unsigned compare operations
12346 case FRACT_CONVERT:
12347 case UNSIGNED_FRACT_CONVERT:
12349 case UNSIGNED_SAT_FRACT:
12355 case VEC_DUPLICATE:
12359 case STRICT_LOW_PART:
12363 /* If delegitimize_address couldn't do anything with the UNSPEC, we
12364 can't express it in the debug info. This can happen e.g. with some
12369 resolve_one_addr (&rtl, NULL);
12373 #ifdef ENABLE_CHECKING
12374 print_rtl (stderr, rtl);
12375 gcc_unreachable ();
12381 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
12382 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
12384 return mem_loc_result;
12387 /* Return a descriptor that describes the concatenation of two locations.
12388 This is typically a complex variable. */
12390 static dw_loc_descr_ref
12391 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
12393 dw_loc_descr_ref cc_loc_result = NULL;
12394 dw_loc_descr_ref x0_ref
12395 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12396 dw_loc_descr_ref x1_ref
12397 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12399 if (x0_ref == 0 || x1_ref == 0)
12402 cc_loc_result = x0_ref;
12403 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
12405 add_loc_descr (&cc_loc_result, x1_ref);
12406 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
12408 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
12409 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
12411 return cc_loc_result;
12414 /* Return a descriptor that describes the concatenation of N
12417 static dw_loc_descr_ref
12418 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
12421 dw_loc_descr_ref cc_loc_result = NULL;
12422 unsigned int n = XVECLEN (concatn, 0);
12424 for (i = 0; i < n; ++i)
12426 dw_loc_descr_ref ref;
12427 rtx x = XVECEXP (concatn, 0, i);
12429 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12433 add_loc_descr (&cc_loc_result, ref);
12434 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
12437 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
12438 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
12440 return cc_loc_result;
12443 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
12444 for DEBUG_IMPLICIT_PTR RTL. */
12446 static dw_loc_descr_ref
12447 implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
12449 dw_loc_descr_ref ret;
12454 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL
12455 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL
12456 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL);
12457 ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl));
12458 ret = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
12459 ret->dw_loc_oprnd2.val_class = dw_val_class_const;
12462 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12463 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
12464 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
12468 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
12469 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_IMPLICIT_PTR_DECL (rtl);
12474 /* Output a proper Dwarf location descriptor for a variable or parameter
12475 which is either allocated in a register or in a memory location. For a
12476 register, we just generate an OP_REG and the register number. For a
12477 memory location we provide a Dwarf postfix expression describing how to
12478 generate the (dynamic) address of the object onto the address stack.
12480 MODE is mode of the decl if this loc_descriptor is going to be used in
12481 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
12482 allowed, VOIDmode otherwise.
12484 If we don't know how to describe it, return 0. */
12486 static dw_loc_descr_ref
12487 loc_descriptor (rtx rtl, enum machine_mode mode,
12488 enum var_init_status initialized)
12490 dw_loc_descr_ref loc_result = NULL;
12492 switch (GET_CODE (rtl))
12495 /* The case of a subreg may arise when we have a local (register)
12496 variable or a formal (register) parameter which doesn't quite fill
12497 up an entire register. For now, just assume that it is
12498 legitimate to make the Dwarf info refer to the whole register which
12499 contains the given subreg. */
12500 if (REG_P (SUBREG_REG (rtl)) && subreg_lowpart_p (rtl))
12501 loc_result = loc_descriptor (SUBREG_REG (rtl), mode, initialized);
12507 loc_result = reg_loc_descriptor (rtl, initialized);
12511 loc_result = mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
12512 GET_MODE (rtl), initialized);
12513 if (loc_result == NULL)
12514 loc_result = tls_mem_loc_descriptor (rtl);
12515 if (loc_result == NULL)
12517 rtx new_rtl = avoid_constant_pool_reference (rtl);
12518 if (new_rtl != rtl)
12519 loc_result = loc_descriptor (new_rtl, mode, initialized);
12524 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
12529 loc_result = concatn_loc_descriptor (rtl, initialized);
12534 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL)
12536 rtx loc = PAT_VAR_LOCATION_LOC (rtl);
12537 if (GET_CODE (loc) == EXPR_LIST)
12538 loc = XEXP (loc, 0);
12539 loc_result = loc_descriptor (loc, mode, initialized);
12543 rtl = XEXP (rtl, 1);
12548 rtvec par_elems = XVEC (rtl, 0);
12549 int num_elem = GET_NUM_ELEM (par_elems);
12550 enum machine_mode mode;
12553 /* Create the first one, so we have something to add to. */
12554 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
12555 VOIDmode, initialized);
12556 if (loc_result == NULL)
12558 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
12559 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
12560 for (i = 1; i < num_elem; i++)
12562 dw_loc_descr_ref temp;
12564 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
12565 VOIDmode, initialized);
12568 add_loc_descr (&loc_result, temp);
12569 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
12570 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
12576 if (mode != VOIDmode && mode != BLKmode)
12577 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
12582 if (mode == VOIDmode)
12583 mode = GET_MODE (rtl);
12585 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
12587 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
12589 /* Note that a CONST_DOUBLE rtx could represent either an integer
12590 or a floating-point constant. A CONST_DOUBLE is used whenever
12591 the constant requires more than one word in order to be
12592 adequately represented. We output CONST_DOUBLEs as blocks. */
12593 loc_result = new_loc_descr (DW_OP_implicit_value,
12594 GET_MODE_SIZE (mode), 0);
12595 if (SCALAR_FLOAT_MODE_P (mode))
12597 unsigned int length = GET_MODE_SIZE (mode);
12598 unsigned char *array
12599 = (unsigned char*) ggc_alloc_atomic (length);
12601 insert_float (rtl, array);
12602 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
12603 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
12604 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
12605 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
12609 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
12610 loc_result->dw_loc_oprnd2.v.val_double
12611 = rtx_to_double_int (rtl);
12617 if (mode == VOIDmode)
12618 mode = GET_MODE (rtl);
12620 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
12622 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
12623 unsigned int length = CONST_VECTOR_NUNITS (rtl);
12624 unsigned char *array = (unsigned char *)
12625 ggc_alloc_atomic (length * elt_size);
12629 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
12630 switch (GET_MODE_CLASS (mode))
12632 case MODE_VECTOR_INT:
12633 for (i = 0, p = array; i < length; i++, p += elt_size)
12635 rtx elt = CONST_VECTOR_ELT (rtl, i);
12636 double_int val = rtx_to_double_int (elt);
12638 if (elt_size <= sizeof (HOST_WIDE_INT))
12639 insert_int (double_int_to_shwi (val), elt_size, p);
12642 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
12643 insert_double (val, p);
12648 case MODE_VECTOR_FLOAT:
12649 for (i = 0, p = array; i < length; i++, p += elt_size)
12651 rtx elt = CONST_VECTOR_ELT (rtl, i);
12652 insert_float (elt, p);
12657 gcc_unreachable ();
12660 loc_result = new_loc_descr (DW_OP_implicit_value,
12661 length * elt_size, 0);
12662 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
12663 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
12664 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
12665 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
12670 if (mode == VOIDmode
12671 || GET_CODE (XEXP (rtl, 0)) == CONST_INT
12672 || GET_CODE (XEXP (rtl, 0)) == CONST_DOUBLE
12673 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
12675 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
12680 if (!const_ok_for_output (rtl))
12683 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
12684 && (dwarf_version >= 4 || !dwarf_strict))
12686 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
12687 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
12688 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
12689 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
12690 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
12694 case DEBUG_IMPLICIT_PTR:
12695 loc_result = implicit_ptr_descriptor (rtl, 0);
12699 if (GET_CODE (XEXP (rtl, 0)) == DEBUG_IMPLICIT_PTR
12700 && CONST_INT_P (XEXP (rtl, 1)))
12703 = implicit_ptr_descriptor (XEXP (rtl, 0), INTVAL (XEXP (rtl, 1)));
12709 if ((GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
12710 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
12711 && dwarf_version >= 4)
12712 || (!dwarf_strict && mode != VOIDmode && mode != BLKmode))
12714 /* Value expression. */
12715 loc_result = mem_loc_descriptor (rtl, mode, VOIDmode, initialized);
12717 add_loc_descr (&loc_result,
12718 new_loc_descr (DW_OP_stack_value, 0, 0));
12726 /* We need to figure out what section we should use as the base for the
12727 address ranges where a given location is valid.
12728 1. If this particular DECL has a section associated with it, use that.
12729 2. If this function has a section associated with it, use that.
12730 3. Otherwise, use the text section.
12731 XXX: If you split a variable across multiple sections, we won't notice. */
12733 static const char *
12734 secname_for_decl (const_tree decl)
12736 const char *secname;
12738 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
12740 tree sectree = DECL_SECTION_NAME (decl);
12741 secname = TREE_STRING_POINTER (sectree);
12743 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
12745 tree sectree = DECL_SECTION_NAME (current_function_decl);
12746 secname = TREE_STRING_POINTER (sectree);
12748 else if (cfun && in_cold_section_p)
12749 secname = crtl->subsections.cold_section_label;
12751 secname = text_section_label;
12756 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
12759 decl_by_reference_p (tree decl)
12761 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
12762 || TREE_CODE (decl) == VAR_DECL)
12763 && DECL_BY_REFERENCE (decl));
12766 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
12769 static dw_loc_descr_ref
12770 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
12771 enum var_init_status initialized)
12773 int have_address = 0;
12774 dw_loc_descr_ref descr;
12775 enum machine_mode mode;
12777 if (want_address != 2)
12779 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
12781 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
12783 varloc = PAT_VAR_LOCATION_LOC (varloc);
12784 if (GET_CODE (varloc) == EXPR_LIST)
12785 varloc = XEXP (varloc, 0);
12786 mode = GET_MODE (varloc);
12787 if (MEM_P (varloc))
12789 rtx addr = XEXP (varloc, 0);
12790 descr = mem_loc_descriptor (addr, get_address_mode (varloc),
12791 mode, initialized);
12796 rtx x = avoid_constant_pool_reference (varloc);
12798 descr = mem_loc_descriptor (x, mode, VOIDmode,
12803 descr = mem_loc_descriptor (varloc, mode, VOIDmode, initialized);
12810 if (GET_CODE (varloc) == VAR_LOCATION)
12811 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc));
12813 mode = DECL_MODE (loc);
12814 descr = loc_descriptor (varloc, mode, initialized);
12821 if (want_address == 2 && !have_address
12822 && (dwarf_version >= 4 || !dwarf_strict))
12824 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
12826 expansion_failed (loc, NULL_RTX,
12827 "DWARF address size mismatch");
12830 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
12833 /* Show if we can't fill the request for an address. */
12834 if (want_address && !have_address)
12836 expansion_failed (loc, NULL_RTX,
12837 "Want address and only have value");
12841 /* If we've got an address and don't want one, dereference. */
12842 if (!want_address && have_address)
12844 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
12845 enum dwarf_location_atom op;
12847 if (size > DWARF2_ADDR_SIZE || size == -1)
12849 expansion_failed (loc, NULL_RTX,
12850 "DWARF address size mismatch");
12853 else if (size == DWARF2_ADDR_SIZE)
12856 op = DW_OP_deref_size;
12858 add_loc_descr (&descr, new_loc_descr (op, size, 0));
12864 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
12865 if it is not possible. */
12867 static dw_loc_descr_ref
12868 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
12870 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
12871 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0);
12872 else if (dwarf_version >= 3 || !dwarf_strict)
12873 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
12878 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
12879 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
12881 static dw_loc_descr_ref
12882 dw_sra_loc_expr (tree decl, rtx loc)
12885 unsigned int padsize = 0;
12886 dw_loc_descr_ref descr, *descr_tail;
12887 unsigned HOST_WIDE_INT decl_size;
12889 enum var_init_status initialized;
12891 if (DECL_SIZE (decl) == NULL
12892 || !host_integerp (DECL_SIZE (decl), 1))
12895 decl_size = tree_low_cst (DECL_SIZE (decl), 1);
12897 descr_tail = &descr;
12899 for (p = loc; p; p = XEXP (p, 1))
12901 unsigned int bitsize = decl_piece_bitsize (p);
12902 rtx loc_note = *decl_piece_varloc_ptr (p);
12903 dw_loc_descr_ref cur_descr;
12904 dw_loc_descr_ref *tail, last = NULL;
12905 unsigned int opsize = 0;
12907 if (loc_note == NULL_RTX
12908 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX)
12910 padsize += bitsize;
12913 initialized = NOTE_VAR_LOCATION_STATUS (loc_note);
12914 varloc = NOTE_VAR_LOCATION (loc_note);
12915 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized);
12916 if (cur_descr == NULL)
12918 padsize += bitsize;
12922 /* Check that cur_descr either doesn't use
12923 DW_OP_*piece operations, or their sum is equal
12924 to bitsize. Otherwise we can't embed it. */
12925 for (tail = &cur_descr; *tail != NULL;
12926 tail = &(*tail)->dw_loc_next)
12927 if ((*tail)->dw_loc_opc == DW_OP_piece)
12929 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned
12933 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece)
12935 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned;
12939 if (last != NULL && opsize != bitsize)
12941 padsize += bitsize;
12945 /* If there is a hole, add DW_OP_*piece after empty DWARF
12946 expression, which means that those bits are optimized out. */
12949 if (padsize > decl_size)
12951 decl_size -= padsize;
12952 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0);
12953 if (*descr_tail == NULL)
12955 descr_tail = &(*descr_tail)->dw_loc_next;
12958 *descr_tail = cur_descr;
12960 if (bitsize > decl_size)
12962 decl_size -= bitsize;
12965 HOST_WIDE_INT offset = 0;
12966 if (GET_CODE (varloc) == VAR_LOCATION
12967 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
12969 varloc = PAT_VAR_LOCATION_LOC (varloc);
12970 if (GET_CODE (varloc) == EXPR_LIST)
12971 varloc = XEXP (varloc, 0);
12975 if (GET_CODE (varloc) == CONST
12976 || GET_CODE (varloc) == SIGN_EXTEND
12977 || GET_CODE (varloc) == ZERO_EXTEND)
12978 varloc = XEXP (varloc, 0);
12979 else if (GET_CODE (varloc) == SUBREG)
12980 varloc = SUBREG_REG (varloc);
12985 /* DW_OP_bit_size offset should be zero for register
12986 or implicit location descriptions and empty location
12987 descriptions, but for memory addresses needs big endian
12989 if (MEM_P (varloc))
12991 unsigned HOST_WIDE_INT memsize
12992 = MEM_SIZE (varloc) * BITS_PER_UNIT;
12993 if (memsize != bitsize)
12995 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
12996 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD))
12998 if (memsize < bitsize)
13000 if (BITS_BIG_ENDIAN)
13001 offset = memsize - bitsize;
13005 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
13006 if (*descr_tail == NULL)
13008 descr_tail = &(*descr_tail)->dw_loc_next;
13012 /* If there were any non-empty expressions, add padding till the end of
13014 if (descr != NULL && decl_size != 0)
13016 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0);
13017 if (*descr_tail == NULL)
13023 /* Return the dwarf representation of the location list LOC_LIST of
13024 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
13027 static dw_loc_list_ref
13028 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
13030 const char *endname, *secname;
13032 enum var_init_status initialized;
13033 struct var_loc_node *node;
13034 dw_loc_descr_ref descr;
13035 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
13036 dw_loc_list_ref list = NULL;
13037 dw_loc_list_ref *listp = &list;
13039 /* Now that we know what section we are using for a base,
13040 actually construct the list of locations.
13041 The first location information is what is passed to the
13042 function that creates the location list, and the remaining
13043 locations just get added on to that list.
13044 Note that we only know the start address for a location
13045 (IE location changes), so to build the range, we use
13046 the range [current location start, next location start].
13047 This means we have to special case the last node, and generate
13048 a range of [last location start, end of function label]. */
13050 secname = secname_for_decl (decl);
13052 for (node = loc_list->first; node; node = node->next)
13053 if (GET_CODE (node->loc) == EXPR_LIST
13054 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX)
13056 if (GET_CODE (node->loc) == EXPR_LIST)
13058 /* This requires DW_OP_{,bit_}piece, which is not usable
13059 inside DWARF expressions. */
13060 if (want_address != 2)
13062 descr = dw_sra_loc_expr (decl, node->loc);
13068 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
13069 varloc = NOTE_VAR_LOCATION (node->loc);
13070 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
13074 bool range_across_switch = false;
13075 /* If section switch happens in between node->label
13076 and node->next->label (or end of function) and
13077 we can't emit it as a single entry list,
13078 emit two ranges, first one ending at the end
13079 of first partition and second one starting at the
13080 beginning of second partition. */
13081 if (node == loc_list->last_before_switch
13082 && (node != loc_list->first || loc_list->first->next)
13083 && current_function_decl)
13085 endname = cfun->fde->dw_fde_end;
13086 range_across_switch = true;
13088 /* The variable has a location between NODE->LABEL and
13089 NODE->NEXT->LABEL. */
13090 else if (node->next)
13091 endname = node->next->label;
13092 /* If the variable has a location at the last label
13093 it keeps its location until the end of function. */
13094 else if (!current_function_decl)
13095 endname = text_end_label;
13098 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
13099 current_function_funcdef_no);
13100 endname = ggc_strdup (label_id);
13103 *listp = new_loc_list (descr, node->label, endname, secname);
13104 if (TREE_CODE (decl) == PARM_DECL
13105 && node == loc_list->first
13106 && GET_CODE (node->loc) == NOTE
13107 && strcmp (node->label, endname) == 0)
13108 (*listp)->force = true;
13109 listp = &(*listp)->dw_loc_next;
13111 if (range_across_switch)
13113 if (GET_CODE (node->loc) == EXPR_LIST)
13114 descr = dw_sra_loc_expr (decl, node->loc);
13117 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
13118 varloc = NOTE_VAR_LOCATION (node->loc);
13119 descr = dw_loc_list_1 (decl, varloc, want_address,
13122 gcc_assert (descr);
13123 /* The variable has a location between NODE->LABEL and
13124 NODE->NEXT->LABEL. */
13126 endname = node->next->label;
13128 endname = cfun->fde->dw_fde_second_end;
13129 *listp = new_loc_list (descr,
13130 cfun->fde->dw_fde_second_begin,
13132 listp = &(*listp)->dw_loc_next;
13137 /* Try to avoid the overhead of a location list emitting a location
13138 expression instead, but only if we didn't have more than one
13139 location entry in the first place. If some entries were not
13140 representable, we don't want to pretend a single entry that was
13141 applies to the entire scope in which the variable is
13143 if (list && loc_list->first->next)
13149 /* Return if the loc_list has only single element and thus can be represented
13150 as location description. */
13153 single_element_loc_list_p (dw_loc_list_ref list)
13155 gcc_assert (!list->dw_loc_next || list->ll_symbol);
13156 return !list->ll_symbol;
13159 /* To each location in list LIST add loc descr REF. */
13162 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
13164 dw_loc_descr_ref copy;
13165 add_loc_descr (&list->expr, ref);
13166 list = list->dw_loc_next;
13169 copy = ggc_alloc_dw_loc_descr_node ();
13170 memcpy (copy, ref, sizeof (dw_loc_descr_node));
13171 add_loc_descr (&list->expr, copy);
13172 while (copy->dw_loc_next)
13174 dw_loc_descr_ref new_copy = ggc_alloc_dw_loc_descr_node ();
13175 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
13176 copy->dw_loc_next = new_copy;
13179 list = list->dw_loc_next;
13183 /* Given two lists RET and LIST
13184 produce location list that is result of adding expression in LIST
13185 to expression in RET on each possition in program.
13186 Might be destructive on both RET and LIST.
13188 TODO: We handle only simple cases of RET or LIST having at most one
13189 element. General case would inolve sorting the lists in program order
13190 and merging them that will need some additional work.
13191 Adding that will improve quality of debug info especially for SRA-ed
13195 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
13204 if (!list->dw_loc_next)
13206 add_loc_descr_to_each (*ret, list->expr);
13209 if (!(*ret)->dw_loc_next)
13211 add_loc_descr_to_each (list, (*ret)->expr);
13215 expansion_failed (NULL_TREE, NULL_RTX,
13216 "Don't know how to merge two non-trivial"
13217 " location lists.\n");
13222 /* LOC is constant expression. Try a luck, look it up in constant
13223 pool and return its loc_descr of its address. */
13225 static dw_loc_descr_ref
13226 cst_pool_loc_descr (tree loc)
13228 /* Get an RTL for this, if something has been emitted. */
13229 rtx rtl = lookup_constant_def (loc);
13231 if (!rtl || !MEM_P (rtl))
13236 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
13238 /* TODO: We might get more coverage if we was actually delaying expansion
13239 of all expressions till end of compilation when constant pools are fully
13241 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
13243 expansion_failed (loc, NULL_RTX,
13244 "CST value in contant pool but not marked.");
13247 return mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
13248 GET_MODE (rtl), VAR_INIT_STATUS_INITIALIZED);
13251 /* Return dw_loc_list representing address of addr_expr LOC
13252 by looking for innder INDIRECT_REF expression and turing it
13253 into simple arithmetics. */
13255 static dw_loc_list_ref
13256 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev)
13259 HOST_WIDE_INT bitsize, bitpos, bytepos;
13260 enum machine_mode mode;
13262 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
13263 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
13265 obj = get_inner_reference (TREE_OPERAND (loc, 0),
13266 &bitsize, &bitpos, &offset, &mode,
13267 &unsignedp, &volatilep, false);
13269 if (bitpos % BITS_PER_UNIT)
13271 expansion_failed (loc, NULL_RTX, "bitfield access");
13274 if (!INDIRECT_REF_P (obj))
13276 expansion_failed (obj,
13277 NULL_RTX, "no indirect ref in inner refrence");
13280 if (!offset && !bitpos)
13281 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1);
13283 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
13284 && (dwarf_version >= 4 || !dwarf_strict))
13286 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0);
13291 /* Variable offset. */
13292 list_ret1 = loc_list_from_tree (offset, 0);
13293 if (list_ret1 == 0)
13295 add_loc_list (&list_ret, list_ret1);
13298 add_loc_descr_to_each (list_ret,
13299 new_loc_descr (DW_OP_plus, 0, 0));
13301 bytepos = bitpos / BITS_PER_UNIT;
13303 add_loc_descr_to_each (list_ret,
13304 new_loc_descr (DW_OP_plus_uconst,
13306 else if (bytepos < 0)
13307 loc_list_plus_const (list_ret, bytepos);
13308 add_loc_descr_to_each (list_ret,
13309 new_loc_descr (DW_OP_stack_value, 0, 0));
13315 /* Generate Dwarf location list representing LOC.
13316 If WANT_ADDRESS is false, expression computing LOC will be computed
13317 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
13318 if WANT_ADDRESS is 2, expression computing address useable in location
13319 will be returned (i.e. DW_OP_reg can be used
13320 to refer to register values). */
13322 static dw_loc_list_ref
13323 loc_list_from_tree (tree loc, int want_address)
13325 dw_loc_descr_ref ret = NULL, ret1 = NULL;
13326 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
13327 int have_address = 0;
13328 enum dwarf_location_atom op;
13330 /* ??? Most of the time we do not take proper care for sign/zero
13331 extending the values properly. Hopefully this won't be a real
13334 switch (TREE_CODE (loc))
13337 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
13340 case PLACEHOLDER_EXPR:
13341 /* This case involves extracting fields from an object to determine the
13342 position of other fields. We don't try to encode this here. The
13343 only user of this is Ada, which encodes the needed information using
13344 the names of types. */
13345 expansion_failed (loc, NULL_RTX, "PLACEHOLDER_EXPR");
13349 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
13350 /* There are no opcodes for these operations. */
13353 case PREINCREMENT_EXPR:
13354 case PREDECREMENT_EXPR:
13355 case POSTINCREMENT_EXPR:
13356 case POSTDECREMENT_EXPR:
13357 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
13358 /* There are no opcodes for these operations. */
13362 /* If we already want an address, see if there is INDIRECT_REF inside
13363 e.g. for &this->field. */
13366 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
13367 (loc, want_address == 2);
13370 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
13371 && (ret = cst_pool_loc_descr (loc)))
13374 /* Otherwise, process the argument and look for the address. */
13375 if (!list_ret && !ret)
13376 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1);
13380 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
13386 if (DECL_THREAD_LOCAL_P (loc))
13389 enum dwarf_location_atom first_op;
13390 enum dwarf_location_atom second_op;
13391 bool dtprel = false;
13393 if (targetm.have_tls)
13395 /* If this is not defined, we have no way to emit the
13397 if (!targetm.asm_out.output_dwarf_dtprel)
13400 /* The way DW_OP_GNU_push_tls_address is specified, we
13401 can only look up addresses of objects in the current
13402 module. We used DW_OP_addr as first op, but that's
13403 wrong, because DW_OP_addr is relocated by the debug
13404 info consumer, while DW_OP_GNU_push_tls_address
13405 operand shouldn't be. */
13406 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
13408 first_op = DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u;
13410 second_op = DW_OP_GNU_push_tls_address;
13414 if (!targetm.emutls.debug_form_tls_address
13415 || !(dwarf_version >= 3 || !dwarf_strict))
13417 /* We stuffed the control variable into the DECL_VALUE_EXPR
13418 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
13419 no longer appear in gimple code. We used the control
13420 variable in specific so that we could pick it up here. */
13421 loc = DECL_VALUE_EXPR (loc);
13422 first_op = DW_OP_addr;
13423 second_op = DW_OP_form_tls_address;
13426 rtl = rtl_for_decl_location (loc);
13427 if (rtl == NULL_RTX)
13432 rtl = XEXP (rtl, 0);
13433 if (! CONSTANT_P (rtl))
13436 ret = new_loc_descr (first_op, 0, 0);
13437 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
13438 ret->dw_loc_oprnd1.v.val_addr = rtl;
13439 ret->dtprel = dtprel;
13441 ret1 = new_loc_descr (second_op, 0, 0);
13442 add_loc_descr (&ret, ret1);
13451 if (DECL_HAS_VALUE_EXPR_P (loc))
13452 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
13456 case FUNCTION_DECL:
13459 var_loc_list *loc_list = lookup_decl_loc (loc);
13461 if (loc_list && loc_list->first)
13463 list_ret = dw_loc_list (loc_list, loc, want_address);
13464 have_address = want_address != 0;
13467 rtl = rtl_for_decl_location (loc);
13468 if (rtl == NULL_RTX)
13470 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
13473 else if (CONST_INT_P (rtl))
13475 HOST_WIDE_INT val = INTVAL (rtl);
13476 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
13477 val &= GET_MODE_MASK (DECL_MODE (loc));
13478 ret = int_loc_descriptor (val);
13480 else if (GET_CODE (rtl) == CONST_STRING)
13482 expansion_failed (loc, NULL_RTX, "CONST_STRING");
13485 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
13487 ret = new_loc_descr (DW_OP_addr, 0, 0);
13488 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
13489 ret->dw_loc_oprnd1.v.val_addr = rtl;
13493 enum machine_mode mode, mem_mode;
13495 /* Certain constructs can only be represented at top-level. */
13496 if (want_address == 2)
13498 ret = loc_descriptor (rtl, VOIDmode,
13499 VAR_INIT_STATUS_INITIALIZED);
13504 mode = GET_MODE (rtl);
13505 mem_mode = VOIDmode;
13509 mode = get_address_mode (rtl);
13510 rtl = XEXP (rtl, 0);
13513 ret = mem_loc_descriptor (rtl, mode, mem_mode,
13514 VAR_INIT_STATUS_INITIALIZED);
13517 expansion_failed (loc, rtl,
13518 "failed to produce loc descriptor for rtl");
13525 if (!integer_zerop (TREE_OPERAND (loc, 1)))
13529 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
13533 case COMPOUND_EXPR:
13534 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address);
13537 case VIEW_CONVERT_EXPR:
13540 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address);
13542 case COMPONENT_REF:
13543 case BIT_FIELD_REF:
13545 case ARRAY_RANGE_REF:
13546 case REALPART_EXPR:
13547 case IMAGPART_EXPR:
13550 HOST_WIDE_INT bitsize, bitpos, bytepos;
13551 enum machine_mode mode;
13553 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
13555 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
13556 &unsignedp, &volatilep, false);
13558 gcc_assert (obj != loc);
13560 list_ret = loc_list_from_tree (obj,
13562 && !bitpos && !offset ? 2 : 1);
13563 /* TODO: We can extract value of the small expression via shifting even
13564 for nonzero bitpos. */
13567 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
13569 expansion_failed (loc, NULL_RTX,
13570 "bitfield access");
13574 if (offset != NULL_TREE)
13576 /* Variable offset. */
13577 list_ret1 = loc_list_from_tree (offset, 0);
13578 if (list_ret1 == 0)
13580 add_loc_list (&list_ret, list_ret1);
13583 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
13586 bytepos = bitpos / BITS_PER_UNIT;
13588 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
13589 else if (bytepos < 0)
13590 loc_list_plus_const (list_ret, bytepos);
13597 if ((want_address || !host_integerp (loc, 0))
13598 && (ret = cst_pool_loc_descr (loc)))
13600 else if (want_address == 2
13601 && host_integerp (loc, 0)
13602 && (ret = address_of_int_loc_descriptor
13603 (int_size_in_bytes (TREE_TYPE (loc)),
13604 tree_low_cst (loc, 0))))
13606 else if (host_integerp (loc, 0))
13607 ret = int_loc_descriptor (tree_low_cst (loc, 0));
13610 expansion_failed (loc, NULL_RTX,
13611 "Integer operand is not host integer");
13620 if ((ret = cst_pool_loc_descr (loc)))
13623 /* We can construct small constants here using int_loc_descriptor. */
13624 expansion_failed (loc, NULL_RTX,
13625 "constructor or constant not in constant pool");
13628 case TRUTH_AND_EXPR:
13629 case TRUTH_ANDIF_EXPR:
13634 case TRUTH_XOR_EXPR:
13639 case TRUTH_OR_EXPR:
13640 case TRUTH_ORIF_EXPR:
13645 case FLOOR_DIV_EXPR:
13646 case CEIL_DIV_EXPR:
13647 case ROUND_DIV_EXPR:
13648 case TRUNC_DIV_EXPR:
13649 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
13658 case FLOOR_MOD_EXPR:
13659 case CEIL_MOD_EXPR:
13660 case ROUND_MOD_EXPR:
13661 case TRUNC_MOD_EXPR:
13662 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
13667 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
13668 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
13669 if (list_ret == 0 || list_ret1 == 0)
13672 add_loc_list (&list_ret, list_ret1);
13675 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
13676 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
13677 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0));
13678 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
13679 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
13691 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
13694 case POINTER_PLUS_EXPR:
13696 if (host_integerp (TREE_OPERAND (loc, 1), 0))
13698 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
13702 loc_list_plus_const (list_ret, tree_low_cst (TREE_OPERAND (loc, 1), 0));
13710 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
13717 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
13724 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
13731 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
13746 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
13747 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
13748 if (list_ret == 0 || list_ret1 == 0)
13751 add_loc_list (&list_ret, list_ret1);
13754 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
13757 case TRUTH_NOT_EXPR:
13771 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
13775 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
13781 const enum tree_code code =
13782 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
13784 loc = build3 (COND_EXPR, TREE_TYPE (loc),
13785 build2 (code, integer_type_node,
13786 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
13787 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
13790 /* ... fall through ... */
13794 dw_loc_descr_ref lhs
13795 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
13796 dw_loc_list_ref rhs
13797 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0);
13798 dw_loc_descr_ref bra_node, jump_node, tmp;
13800 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
13801 if (list_ret == 0 || lhs == 0 || rhs == 0)
13804 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
13805 add_loc_descr_to_each (list_ret, bra_node);
13807 add_loc_list (&list_ret, rhs);
13808 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
13809 add_loc_descr_to_each (list_ret, jump_node);
13811 add_loc_descr_to_each (list_ret, lhs);
13812 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
13813 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
13815 /* ??? Need a node to point the skip at. Use a nop. */
13816 tmp = new_loc_descr (DW_OP_nop, 0, 0);
13817 add_loc_descr_to_each (list_ret, tmp);
13818 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
13819 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
13823 case FIX_TRUNC_EXPR:
13827 /* Leave front-end specific codes as simply unknown. This comes
13828 up, for instance, with the C STMT_EXPR. */
13829 if ((unsigned int) TREE_CODE (loc)
13830 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
13832 expansion_failed (loc, NULL_RTX,
13833 "language specific tree node");
13837 #ifdef ENABLE_CHECKING
13838 /* Otherwise this is a generic code; we should just lists all of
13839 these explicitly. We forgot one. */
13840 gcc_unreachable ();
13842 /* In a release build, we want to degrade gracefully: better to
13843 generate incomplete debugging information than to crash. */
13848 if (!ret && !list_ret)
13851 if (want_address == 2 && !have_address
13852 && (dwarf_version >= 4 || !dwarf_strict))
13854 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
13856 expansion_failed (loc, NULL_RTX,
13857 "DWARF address size mismatch");
13861 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
13863 add_loc_descr_to_each (list_ret,
13864 new_loc_descr (DW_OP_stack_value, 0, 0));
13867 /* Show if we can't fill the request for an address. */
13868 if (want_address && !have_address)
13870 expansion_failed (loc, NULL_RTX,
13871 "Want address and only have value");
13875 gcc_assert (!ret || !list_ret);
13877 /* If we've got an address and don't want one, dereference. */
13878 if (!want_address && have_address)
13880 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
13882 if (size > DWARF2_ADDR_SIZE || size == -1)
13884 expansion_failed (loc, NULL_RTX,
13885 "DWARF address size mismatch");
13888 else if (size == DWARF2_ADDR_SIZE)
13891 op = DW_OP_deref_size;
13894 add_loc_descr (&ret, new_loc_descr (op, size, 0));
13896 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
13899 list_ret = new_loc_list (ret, NULL, NULL, NULL);
13904 /* Same as above but return only single location expression. */
13905 static dw_loc_descr_ref
13906 loc_descriptor_from_tree (tree loc, int want_address)
13908 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address);
13911 if (ret->dw_loc_next)
13913 expansion_failed (loc, NULL_RTX,
13914 "Location list where only loc descriptor needed");
13920 /* Given a value, round it up to the lowest multiple of `boundary'
13921 which is not less than the value itself. */
13923 static inline HOST_WIDE_INT
13924 ceiling (HOST_WIDE_INT value, unsigned int boundary)
13926 return (((value + boundary - 1) / boundary) * boundary);
13929 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
13930 pointer to the declared type for the relevant field variable, or return
13931 `integer_type_node' if the given node turns out to be an
13932 ERROR_MARK node. */
13935 field_type (const_tree decl)
13939 if (TREE_CODE (decl) == ERROR_MARK)
13940 return integer_type_node;
13942 type = DECL_BIT_FIELD_TYPE (decl);
13943 if (type == NULL_TREE)
13944 type = TREE_TYPE (decl);
13949 /* Given a pointer to a tree node, return the alignment in bits for
13950 it, or else return BITS_PER_WORD if the node actually turns out to
13951 be an ERROR_MARK node. */
13953 static inline unsigned
13954 simple_type_align_in_bits (const_tree type)
13956 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
13959 static inline unsigned
13960 simple_decl_align_in_bits (const_tree decl)
13962 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
13965 /* Return the result of rounding T up to ALIGN. */
13967 static inline double_int
13968 round_up_to_align (double_int t, unsigned int align)
13970 double_int alignd = uhwi_to_double_int (align);
13971 t = double_int_add (t, alignd);
13972 t = double_int_add (t, double_int_minus_one);
13973 t = double_int_div (t, alignd, true, TRUNC_DIV_EXPR);
13974 t = double_int_mul (t, alignd);
13978 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
13979 lowest addressed byte of the "containing object" for the given FIELD_DECL,
13980 or return 0 if we are unable to determine what that offset is, either
13981 because the argument turns out to be a pointer to an ERROR_MARK node, or
13982 because the offset is actually variable. (We can't handle the latter case
13985 static HOST_WIDE_INT
13986 field_byte_offset (const_tree decl)
13988 double_int object_offset_in_bits;
13989 double_int object_offset_in_bytes;
13990 double_int bitpos_int;
13992 if (TREE_CODE (decl) == ERROR_MARK)
13995 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
13997 /* We cannot yet cope with fields whose positions are variable, so
13998 for now, when we see such things, we simply return 0. Someday, we may
13999 be able to handle such cases, but it will be damn difficult. */
14000 if (TREE_CODE (bit_position (decl)) != INTEGER_CST)
14003 bitpos_int = tree_to_double_int (bit_position (decl));
14005 #ifdef PCC_BITFIELD_TYPE_MATTERS
14006 if (PCC_BITFIELD_TYPE_MATTERS)
14009 tree field_size_tree;
14010 double_int deepest_bitpos;
14011 double_int field_size_in_bits;
14012 unsigned int type_align_in_bits;
14013 unsigned int decl_align_in_bits;
14014 double_int type_size_in_bits;
14016 type = field_type (decl);
14017 type_size_in_bits = double_int_type_size_in_bits (type);
14018 type_align_in_bits = simple_type_align_in_bits (type);
14020 field_size_tree = DECL_SIZE (decl);
14022 /* The size could be unspecified if there was an error, or for
14023 a flexible array member. */
14024 if (!field_size_tree)
14025 field_size_tree = bitsize_zero_node;
14027 /* If the size of the field is not constant, use the type size. */
14028 if (TREE_CODE (field_size_tree) == INTEGER_CST)
14029 field_size_in_bits = tree_to_double_int (field_size_tree);
14031 field_size_in_bits = type_size_in_bits;
14033 decl_align_in_bits = simple_decl_align_in_bits (decl);
14035 /* The GCC front-end doesn't make any attempt to keep track of the
14036 starting bit offset (relative to the start of the containing
14037 structure type) of the hypothetical "containing object" for a
14038 bit-field. Thus, when computing the byte offset value for the
14039 start of the "containing object" of a bit-field, we must deduce
14040 this information on our own. This can be rather tricky to do in
14041 some cases. For example, handling the following structure type
14042 definition when compiling for an i386/i486 target (which only
14043 aligns long long's to 32-bit boundaries) can be very tricky:
14045 struct S { int field1; long long field2:31; };
14047 Fortunately, there is a simple rule-of-thumb which can be used
14048 in such cases. When compiling for an i386/i486, GCC will
14049 allocate 8 bytes for the structure shown above. It decides to
14050 do this based upon one simple rule for bit-field allocation.
14051 GCC allocates each "containing object" for each bit-field at
14052 the first (i.e. lowest addressed) legitimate alignment boundary
14053 (based upon the required minimum alignment for the declared
14054 type of the field) which it can possibly use, subject to the
14055 condition that there is still enough available space remaining
14056 in the containing object (when allocated at the selected point)
14057 to fully accommodate all of the bits of the bit-field itself.
14059 This simple rule makes it obvious why GCC allocates 8 bytes for
14060 each object of the structure type shown above. When looking
14061 for a place to allocate the "containing object" for `field2',
14062 the compiler simply tries to allocate a 64-bit "containing
14063 object" at each successive 32-bit boundary (starting at zero)
14064 until it finds a place to allocate that 64- bit field such that
14065 at least 31 contiguous (and previously unallocated) bits remain
14066 within that selected 64 bit field. (As it turns out, for the
14067 example above, the compiler finds it is OK to allocate the
14068 "containing object" 64-bit field at bit-offset zero within the
14071 Here we attempt to work backwards from the limited set of facts
14072 we're given, and we try to deduce from those facts, where GCC
14073 must have believed that the containing object started (within
14074 the structure type). The value we deduce is then used (by the
14075 callers of this routine) to generate DW_AT_location and
14076 DW_AT_bit_offset attributes for fields (both bit-fields and, in
14077 the case of DW_AT_location, regular fields as well). */
14079 /* Figure out the bit-distance from the start of the structure to
14080 the "deepest" bit of the bit-field. */
14081 deepest_bitpos = double_int_add (bitpos_int, field_size_in_bits);
14083 /* This is the tricky part. Use some fancy footwork to deduce
14084 where the lowest addressed bit of the containing object must
14086 object_offset_in_bits
14087 = double_int_sub (deepest_bitpos, type_size_in_bits);
14089 /* Round up to type_align by default. This works best for
14091 object_offset_in_bits
14092 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
14094 if (double_int_ucmp (object_offset_in_bits, bitpos_int) > 0)
14096 object_offset_in_bits
14097 = double_int_sub (deepest_bitpos, type_size_in_bits);
14099 /* Round up to decl_align instead. */
14100 object_offset_in_bits
14101 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
14105 #endif /* PCC_BITFIELD_TYPE_MATTERS */
14106 object_offset_in_bits = bitpos_int;
14108 object_offset_in_bytes
14109 = double_int_div (object_offset_in_bits,
14110 uhwi_to_double_int (BITS_PER_UNIT), true,
14112 return double_int_to_shwi (object_offset_in_bytes);
14115 /* The following routines define various Dwarf attributes and any data
14116 associated with them. */
14118 /* Add a location description attribute value to a DIE.
14120 This emits location attributes suitable for whole variables and
14121 whole parameters. Note that the location attributes for struct fields are
14122 generated by the routine `data_member_location_attribute' below. */
14125 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
14126 dw_loc_list_ref descr)
14130 if (single_element_loc_list_p (descr))
14131 add_AT_loc (die, attr_kind, descr->expr);
14133 add_AT_loc_list (die, attr_kind, descr);
14136 /* Add DW_AT_accessibility attribute to DIE if needed. */
14139 add_accessibility_attribute (dw_die_ref die, tree decl)
14141 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
14142 children, otherwise the default is DW_ACCESS_public. In DWARF2
14143 the default has always been DW_ACCESS_public. */
14144 if (TREE_PROTECTED (decl))
14145 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
14146 else if (TREE_PRIVATE (decl))
14148 if (dwarf_version == 2
14149 || die->die_parent == NULL
14150 || die->die_parent->die_tag != DW_TAG_class_type)
14151 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
14153 else if (dwarf_version > 2
14155 && die->die_parent->die_tag == DW_TAG_class_type)
14156 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
14159 /* Attach the specialized form of location attribute used for data members of
14160 struct and union types. In the special case of a FIELD_DECL node which
14161 represents a bit-field, the "offset" part of this special location
14162 descriptor must indicate the distance in bytes from the lowest-addressed
14163 byte of the containing struct or union type to the lowest-addressed byte of
14164 the "containing object" for the bit-field. (See the `field_byte_offset'
14167 For any given bit-field, the "containing object" is a hypothetical object
14168 (of some integral or enum type) within which the given bit-field lives. The
14169 type of this hypothetical "containing object" is always the same as the
14170 declared type of the individual bit-field itself (for GCC anyway... the
14171 DWARF spec doesn't actually mandate this). Note that it is the size (in
14172 bytes) of the hypothetical "containing object" which will be given in the
14173 DW_AT_byte_size attribute for this bit-field. (See the
14174 `byte_size_attribute' function below.) It is also used when calculating the
14175 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
14176 function below.) */
14179 add_data_member_location_attribute (dw_die_ref die, tree decl)
14181 HOST_WIDE_INT offset;
14182 dw_loc_descr_ref loc_descr = 0;
14184 if (TREE_CODE (decl) == TREE_BINFO)
14186 /* We're working on the TAG_inheritance for a base class. */
14187 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
14189 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
14190 aren't at a fixed offset from all (sub)objects of the same
14191 type. We need to extract the appropriate offset from our
14192 vtable. The following dwarf expression means
14194 BaseAddr = ObAddr + *((*ObAddr) - Offset)
14196 This is specific to the V3 ABI, of course. */
14198 dw_loc_descr_ref tmp;
14200 /* Make a copy of the object address. */
14201 tmp = new_loc_descr (DW_OP_dup, 0, 0);
14202 add_loc_descr (&loc_descr, tmp);
14204 /* Extract the vtable address. */
14205 tmp = new_loc_descr (DW_OP_deref, 0, 0);
14206 add_loc_descr (&loc_descr, tmp);
14208 /* Calculate the address of the offset. */
14209 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
14210 gcc_assert (offset < 0);
14212 tmp = int_loc_descriptor (-offset);
14213 add_loc_descr (&loc_descr, tmp);
14214 tmp = new_loc_descr (DW_OP_minus, 0, 0);
14215 add_loc_descr (&loc_descr, tmp);
14217 /* Extract the offset. */
14218 tmp = new_loc_descr (DW_OP_deref, 0, 0);
14219 add_loc_descr (&loc_descr, tmp);
14221 /* Add it to the object address. */
14222 tmp = new_loc_descr (DW_OP_plus, 0, 0);
14223 add_loc_descr (&loc_descr, tmp);
14226 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
14229 offset = field_byte_offset (decl);
14233 if (dwarf_version > 2)
14235 /* Don't need to output a location expression, just the constant. */
14237 add_AT_int (die, DW_AT_data_member_location, offset);
14239 add_AT_unsigned (die, DW_AT_data_member_location, offset);
14244 enum dwarf_location_atom op;
14246 /* The DWARF2 standard says that we should assume that the structure
14247 address is already on the stack, so we can specify a structure
14248 field address by using DW_OP_plus_uconst. */
14250 #ifdef MIPS_DEBUGGING_INFO
14251 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
14252 operator correctly. It works only if we leave the offset on the
14256 op = DW_OP_plus_uconst;
14259 loc_descr = new_loc_descr (op, offset, 0);
14263 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
14266 /* Writes integer values to dw_vec_const array. */
14269 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
14273 *dest++ = val & 0xff;
14279 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
14281 static HOST_WIDE_INT
14282 extract_int (const unsigned char *src, unsigned int size)
14284 HOST_WIDE_INT val = 0;
14290 val |= *--src & 0xff;
14296 /* Writes double_int values to dw_vec_const array. */
14299 insert_double (double_int val, unsigned char *dest)
14301 unsigned char *p0 = dest;
14302 unsigned char *p1 = dest + sizeof (HOST_WIDE_INT);
14304 if (WORDS_BIG_ENDIAN)
14310 insert_int ((HOST_WIDE_INT) val.low, sizeof (HOST_WIDE_INT), p0);
14311 insert_int ((HOST_WIDE_INT) val.high, sizeof (HOST_WIDE_INT), p1);
14314 /* Writes floating point values to dw_vec_const array. */
14317 insert_float (const_rtx rtl, unsigned char *array)
14319 REAL_VALUE_TYPE rv;
14323 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
14324 real_to_target (val, &rv, GET_MODE (rtl));
14326 /* real_to_target puts 32-bit pieces in each long. Pack them. */
14327 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
14329 insert_int (val[i], 4, array);
14334 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
14335 does not have a "location" either in memory or in a register. These
14336 things can arise in GNU C when a constant is passed as an actual parameter
14337 to an inlined function. They can also arise in C++ where declared
14338 constants do not necessarily get memory "homes". */
14341 add_const_value_attribute (dw_die_ref die, rtx rtl)
14343 switch (GET_CODE (rtl))
14347 HOST_WIDE_INT val = INTVAL (rtl);
14350 add_AT_int (die, DW_AT_const_value, val);
14352 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
14357 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
14358 floating-point constant. A CONST_DOUBLE is used whenever the
14359 constant requires more than one word in order to be adequately
14362 enum machine_mode mode = GET_MODE (rtl);
14364 if (SCALAR_FLOAT_MODE_P (mode))
14366 unsigned int length = GET_MODE_SIZE (mode);
14367 unsigned char *array = (unsigned char *) ggc_alloc_atomic (length);
14369 insert_float (rtl, array);
14370 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
14373 add_AT_double (die, DW_AT_const_value,
14374 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
14380 enum machine_mode mode = GET_MODE (rtl);
14381 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
14382 unsigned int length = CONST_VECTOR_NUNITS (rtl);
14383 unsigned char *array = (unsigned char *) ggc_alloc_atomic
14384 (length * elt_size);
14388 switch (GET_MODE_CLASS (mode))
14390 case MODE_VECTOR_INT:
14391 for (i = 0, p = array; i < length; i++, p += elt_size)
14393 rtx elt = CONST_VECTOR_ELT (rtl, i);
14394 double_int val = rtx_to_double_int (elt);
14396 if (elt_size <= sizeof (HOST_WIDE_INT))
14397 insert_int (double_int_to_shwi (val), elt_size, p);
14400 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
14401 insert_double (val, p);
14406 case MODE_VECTOR_FLOAT:
14407 for (i = 0, p = array; i < length; i++, p += elt_size)
14409 rtx elt = CONST_VECTOR_ELT (rtl, i);
14410 insert_float (elt, p);
14415 gcc_unreachable ();
14418 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
14423 if (dwarf_version >= 4 || !dwarf_strict)
14425 dw_loc_descr_ref loc_result;
14426 resolve_one_addr (&rtl, NULL);
14428 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
14429 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
14430 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
14431 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
14432 add_AT_loc (die, DW_AT_location, loc_result);
14433 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
14439 if (CONSTANT_P (XEXP (rtl, 0)))
14440 return add_const_value_attribute (die, XEXP (rtl, 0));
14443 if (!const_ok_for_output (rtl))
14446 if (dwarf_version >= 4 || !dwarf_strict)
14451 /* In cases where an inlined instance of an inline function is passed
14452 the address of an `auto' variable (which is local to the caller) we
14453 can get a situation where the DECL_RTL of the artificial local
14454 variable (for the inlining) which acts as a stand-in for the
14455 corresponding formal parameter (of the inline function) will look
14456 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
14457 exactly a compile-time constant expression, but it isn't the address
14458 of the (artificial) local variable either. Rather, it represents the
14459 *value* which the artificial local variable always has during its
14460 lifetime. We currently have no way to represent such quasi-constant
14461 values in Dwarf, so for now we just punt and generate nothing. */
14469 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
14470 && MEM_READONLY_P (rtl)
14471 && GET_MODE (rtl) == BLKmode)
14473 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
14479 /* No other kinds of rtx should be possible here. */
14480 gcc_unreachable ();
14485 /* Determine whether the evaluation of EXPR references any variables
14486 or functions which aren't otherwise used (and therefore may not be
14489 reference_to_unused (tree * tp, int * walk_subtrees,
14490 void * data ATTRIBUTE_UNUSED)
14492 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
14493 *walk_subtrees = 0;
14495 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
14496 && ! TREE_ASM_WRITTEN (*tp))
14498 /* ??? The C++ FE emits debug information for using decls, so
14499 putting gcc_unreachable here falls over. See PR31899. For now
14500 be conservative. */
14501 else if (!cgraph_global_info_ready
14502 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
14504 else if (TREE_CODE (*tp) == VAR_DECL)
14506 struct varpool_node *node = varpool_get_node (*tp);
14507 if (!node || !node->needed)
14510 else if (TREE_CODE (*tp) == FUNCTION_DECL
14511 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
14513 /* The call graph machinery must have finished analyzing,
14514 optimizing and gimplifying the CU by now.
14515 So if *TP has no call graph node associated
14516 to it, it means *TP will not be emitted. */
14517 if (!cgraph_get_node (*tp))
14520 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
14526 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
14527 for use in a later add_const_value_attribute call. */
14530 rtl_for_decl_init (tree init, tree type)
14532 rtx rtl = NULL_RTX;
14536 /* If a variable is initialized with a string constant without embedded
14537 zeros, build CONST_STRING. */
14538 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
14540 tree enttype = TREE_TYPE (type);
14541 tree domain = TYPE_DOMAIN (type);
14542 enum machine_mode mode = TYPE_MODE (enttype);
14544 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
14546 && integer_zerop (TYPE_MIN_VALUE (domain))
14547 && compare_tree_int (TYPE_MAX_VALUE (domain),
14548 TREE_STRING_LENGTH (init) - 1) == 0
14549 && ((size_t) TREE_STRING_LENGTH (init)
14550 == strlen (TREE_STRING_POINTER (init)) + 1))
14552 rtl = gen_rtx_CONST_STRING (VOIDmode,
14553 ggc_strdup (TREE_STRING_POINTER (init)));
14554 rtl = gen_rtx_MEM (BLKmode, rtl);
14555 MEM_READONLY_P (rtl) = 1;
14558 /* Other aggregates, and complex values, could be represented using
14560 else if (AGGREGATE_TYPE_P (type)
14561 || (TREE_CODE (init) == VIEW_CONVERT_EXPR
14562 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init, 0))))
14563 || TREE_CODE (type) == COMPLEX_TYPE)
14565 /* Vectors only work if their mode is supported by the target.
14566 FIXME: generic vectors ought to work too. */
14567 else if (TREE_CODE (type) == VECTOR_TYPE
14568 && !VECTOR_MODE_P (TYPE_MODE (type)))
14570 /* If the initializer is something that we know will expand into an
14571 immediate RTL constant, expand it now. We must be careful not to
14572 reference variables which won't be output. */
14573 else if (initializer_constant_valid_p (init, type)
14574 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
14576 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
14578 if (TREE_CODE (type) == VECTOR_TYPE)
14579 switch (TREE_CODE (init))
14584 if (TREE_CONSTANT (init))
14586 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
14587 bool constant_p = true;
14589 unsigned HOST_WIDE_INT ix;
14591 /* Even when ctor is constant, it might contain non-*_CST
14592 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
14593 belong into VECTOR_CST nodes. */
14594 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
14595 if (!CONSTANT_CLASS_P (value))
14597 constant_p = false;
14603 init = build_vector_from_ctor (type, elts);
14613 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
14615 /* If expand_expr returns a MEM, it wasn't immediate. */
14616 gcc_assert (!rtl || !MEM_P (rtl));
14622 /* Generate RTL for the variable DECL to represent its location. */
14625 rtl_for_decl_location (tree decl)
14629 /* Here we have to decide where we are going to say the parameter "lives"
14630 (as far as the debugger is concerned). We only have a couple of
14631 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
14633 DECL_RTL normally indicates where the parameter lives during most of the
14634 activation of the function. If optimization is enabled however, this
14635 could be either NULL or else a pseudo-reg. Both of those cases indicate
14636 that the parameter doesn't really live anywhere (as far as the code
14637 generation parts of GCC are concerned) during most of the function's
14638 activation. That will happen (for example) if the parameter is never
14639 referenced within the function.
14641 We could just generate a location descriptor here for all non-NULL
14642 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
14643 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
14644 where DECL_RTL is NULL or is a pseudo-reg.
14646 Note however that we can only get away with using DECL_INCOMING_RTL as
14647 a backup substitute for DECL_RTL in certain limited cases. In cases
14648 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
14649 we can be sure that the parameter was passed using the same type as it is
14650 declared to have within the function, and that its DECL_INCOMING_RTL
14651 points us to a place where a value of that type is passed.
14653 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
14654 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
14655 because in these cases DECL_INCOMING_RTL points us to a value of some
14656 type which is *different* from the type of the parameter itself. Thus,
14657 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
14658 such cases, the debugger would end up (for example) trying to fetch a
14659 `float' from a place which actually contains the first part of a
14660 `double'. That would lead to really incorrect and confusing
14661 output at debug-time.
14663 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
14664 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
14665 are a couple of exceptions however. On little-endian machines we can
14666 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
14667 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
14668 an integral type that is smaller than TREE_TYPE (decl). These cases arise
14669 when (on a little-endian machine) a non-prototyped function has a
14670 parameter declared to be of type `short' or `char'. In such cases,
14671 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
14672 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
14673 passed `int' value. If the debugger then uses that address to fetch
14674 a `short' or a `char' (on a little-endian machine) the result will be
14675 the correct data, so we allow for such exceptional cases below.
14677 Note that our goal here is to describe the place where the given formal
14678 parameter lives during most of the function's activation (i.e. between the
14679 end of the prologue and the start of the epilogue). We'll do that as best
14680 as we can. Note however that if the given formal parameter is modified
14681 sometime during the execution of the function, then a stack backtrace (at
14682 debug-time) will show the function as having been called with the *new*
14683 value rather than the value which was originally passed in. This happens
14684 rarely enough that it is not a major problem, but it *is* a problem, and
14685 I'd like to fix it.
14687 A future version of dwarf2out.c may generate two additional attributes for
14688 any given DW_TAG_formal_parameter DIE which will describe the "passed
14689 type" and the "passed location" for the given formal parameter in addition
14690 to the attributes we now generate to indicate the "declared type" and the
14691 "active location" for each parameter. This additional set of attributes
14692 could be used by debuggers for stack backtraces. Separately, note that
14693 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
14694 This happens (for example) for inlined-instances of inline function formal
14695 parameters which are never referenced. This really shouldn't be
14696 happening. All PARM_DECL nodes should get valid non-NULL
14697 DECL_INCOMING_RTL values. FIXME. */
14699 /* Use DECL_RTL as the "location" unless we find something better. */
14700 rtl = DECL_RTL_IF_SET (decl);
14702 /* When generating abstract instances, ignore everything except
14703 constants, symbols living in memory, and symbols living in
14704 fixed registers. */
14705 if (! reload_completed)
14708 && (CONSTANT_P (rtl)
14710 && CONSTANT_P (XEXP (rtl, 0)))
14712 && TREE_CODE (decl) == VAR_DECL
14713 && TREE_STATIC (decl))))
14715 rtl = targetm.delegitimize_address (rtl);
14720 else if (TREE_CODE (decl) == PARM_DECL)
14722 if (rtl == NULL_RTX
14723 || is_pseudo_reg (rtl)
14725 && is_pseudo_reg (XEXP (rtl, 0))
14726 && DECL_INCOMING_RTL (decl)
14727 && MEM_P (DECL_INCOMING_RTL (decl))
14728 && GET_MODE (rtl) == GET_MODE (DECL_INCOMING_RTL (decl))))
14730 tree declared_type = TREE_TYPE (decl);
14731 tree passed_type = DECL_ARG_TYPE (decl);
14732 enum machine_mode dmode = TYPE_MODE (declared_type);
14733 enum machine_mode pmode = TYPE_MODE (passed_type);
14735 /* This decl represents a formal parameter which was optimized out.
14736 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
14737 all cases where (rtl == NULL_RTX) just below. */
14738 if (dmode == pmode)
14739 rtl = DECL_INCOMING_RTL (decl);
14740 else if ((rtl == NULL_RTX || is_pseudo_reg (rtl))
14741 && SCALAR_INT_MODE_P (dmode)
14742 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
14743 && DECL_INCOMING_RTL (decl))
14745 rtx inc = DECL_INCOMING_RTL (decl);
14748 else if (MEM_P (inc))
14750 if (BYTES_BIG_ENDIAN)
14751 rtl = adjust_address_nv (inc, dmode,
14752 GET_MODE_SIZE (pmode)
14753 - GET_MODE_SIZE (dmode));
14760 /* If the parm was passed in registers, but lives on the stack, then
14761 make a big endian correction if the mode of the type of the
14762 parameter is not the same as the mode of the rtl. */
14763 /* ??? This is the same series of checks that are made in dbxout.c before
14764 we reach the big endian correction code there. It isn't clear if all
14765 of these checks are necessary here, but keeping them all is the safe
14767 else if (MEM_P (rtl)
14768 && XEXP (rtl, 0) != const0_rtx
14769 && ! CONSTANT_P (XEXP (rtl, 0))
14770 /* Not passed in memory. */
14771 && !MEM_P (DECL_INCOMING_RTL (decl))
14772 /* Not passed by invisible reference. */
14773 && (!REG_P (XEXP (rtl, 0))
14774 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
14775 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
14776 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
14777 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
14780 /* Big endian correction check. */
14781 && BYTES_BIG_ENDIAN
14782 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
14783 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
14786 int offset = (UNITS_PER_WORD
14787 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
14789 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
14790 plus_constant (XEXP (rtl, 0), offset));
14793 else if (TREE_CODE (decl) == VAR_DECL
14796 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
14797 && BYTES_BIG_ENDIAN)
14799 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
14800 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
14802 /* If a variable is declared "register" yet is smaller than
14803 a register, then if we store the variable to memory, it
14804 looks like we're storing a register-sized value, when in
14805 fact we are not. We need to adjust the offset of the
14806 storage location to reflect the actual value's bytes,
14807 else gdb will not be able to display it. */
14809 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
14810 plus_constant (XEXP (rtl, 0), rsize-dsize));
14813 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
14814 and will have been substituted directly into all expressions that use it.
14815 C does not have such a concept, but C++ and other languages do. */
14816 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
14817 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
14820 rtl = targetm.delegitimize_address (rtl);
14822 /* If we don't look past the constant pool, we risk emitting a
14823 reference to a constant pool entry that isn't referenced from
14824 code, and thus is not emitted. */
14826 rtl = avoid_constant_pool_reference (rtl);
14828 /* Try harder to get a rtl. If this symbol ends up not being emitted
14829 in the current CU, resolve_addr will remove the expression referencing
14831 if (rtl == NULL_RTX
14832 && TREE_CODE (decl) == VAR_DECL
14833 && !DECL_EXTERNAL (decl)
14834 && TREE_STATIC (decl)
14835 && DECL_NAME (decl)
14836 && !DECL_HARD_REGISTER (decl)
14837 && DECL_MODE (decl) != VOIDmode)
14839 rtl = make_decl_rtl_for_debug (decl);
14841 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
14842 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
14849 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
14850 returned. If so, the decl for the COMMON block is returned, and the
14851 value is the offset into the common block for the symbol. */
14854 fortran_common (tree decl, HOST_WIDE_INT *value)
14856 tree val_expr, cvar;
14857 enum machine_mode mode;
14858 HOST_WIDE_INT bitsize, bitpos;
14860 int volatilep = 0, unsignedp = 0;
14862 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
14863 it does not have a value (the offset into the common area), or if it
14864 is thread local (as opposed to global) then it isn't common, and shouldn't
14865 be handled as such. */
14866 if (TREE_CODE (decl) != VAR_DECL
14867 || !TREE_STATIC (decl)
14868 || !DECL_HAS_VALUE_EXPR_P (decl)
14872 val_expr = DECL_VALUE_EXPR (decl);
14873 if (TREE_CODE (val_expr) != COMPONENT_REF)
14876 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
14877 &mode, &unsignedp, &volatilep, true);
14879 if (cvar == NULL_TREE
14880 || TREE_CODE (cvar) != VAR_DECL
14881 || DECL_ARTIFICIAL (cvar)
14882 || !TREE_PUBLIC (cvar))
14886 if (offset != NULL)
14888 if (!host_integerp (offset, 0))
14890 *value = tree_low_cst (offset, 0);
14893 *value += bitpos / BITS_PER_UNIT;
14898 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
14899 data attribute for a variable or a parameter. We generate the
14900 DW_AT_const_value attribute only in those cases where the given variable
14901 or parameter does not have a true "location" either in memory or in a
14902 register. This can happen (for example) when a constant is passed as an
14903 actual argument in a call to an inline function. (It's possible that
14904 these things can crop up in other ways also.) Note that one type of
14905 constant value which can be passed into an inlined function is a constant
14906 pointer. This can happen for example if an actual argument in an inlined
14907 function call evaluates to a compile-time constant address.
14909 CACHE_P is true if it is worth caching the location list for DECL,
14910 so that future calls can reuse it rather than regenerate it from scratch.
14911 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
14912 since we will need to refer to them each time the function is inlined. */
14915 add_location_or_const_value_attribute (dw_die_ref die, tree decl, bool cache_p,
14916 enum dwarf_attribute attr)
14919 dw_loc_list_ref list;
14920 var_loc_list *loc_list;
14921 cached_dw_loc_list *cache;
14924 if (TREE_CODE (decl) == ERROR_MARK)
14927 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
14928 || TREE_CODE (decl) == RESULT_DECL);
14930 /* Try to get some constant RTL for this decl, and use that as the value of
14933 rtl = rtl_for_decl_location (decl);
14934 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
14935 && add_const_value_attribute (die, rtl))
14938 /* See if we have single element location list that is equivalent to
14939 a constant value. That way we are better to use add_const_value_attribute
14940 rather than expanding constant value equivalent. */
14941 loc_list = lookup_decl_loc (decl);
14944 && loc_list->first->next == NULL
14945 && NOTE_P (loc_list->first->loc)
14946 && NOTE_VAR_LOCATION (loc_list->first->loc)
14947 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc))
14949 struct var_loc_node *node;
14951 node = loc_list->first;
14952 rtl = NOTE_VAR_LOCATION_LOC (node->loc);
14953 if (GET_CODE (rtl) == EXPR_LIST)
14954 rtl = XEXP (rtl, 0);
14955 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
14956 && add_const_value_attribute (die, rtl))
14959 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
14960 list several times. See if we've already cached the contents. */
14962 if (loc_list == NULL || cached_dw_loc_list_table == NULL)
14966 cache = (cached_dw_loc_list *)
14967 htab_find_with_hash (cached_dw_loc_list_table, decl, DECL_UID (decl));
14969 list = cache->loc_list;
14973 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2);
14974 /* It is usually worth caching this result if the decl is from
14975 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
14976 if (cache_p && list && list->dw_loc_next)
14978 slot = htab_find_slot_with_hash (cached_dw_loc_list_table, decl,
14979 DECL_UID (decl), INSERT);
14980 cache = ggc_alloc_cleared_cached_dw_loc_list ();
14981 cache->decl_id = DECL_UID (decl);
14982 cache->loc_list = list;
14988 add_AT_location_description (die, attr, list);
14991 /* None of that worked, so it must not really have a location;
14992 try adding a constant value attribute from the DECL_INITIAL. */
14993 return tree_add_const_value_attribute_for_decl (die, decl);
14996 /* Add VARIABLE and DIE into deferred locations list. */
14999 defer_location (tree variable, dw_die_ref die)
15001 deferred_locations entry;
15002 entry.variable = variable;
15004 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
15007 /* Helper function for tree_add_const_value_attribute. Natively encode
15008 initializer INIT into an array. Return true if successful. */
15011 native_encode_initializer (tree init, unsigned char *array, int size)
15015 if (init == NULL_TREE)
15019 switch (TREE_CODE (init))
15022 type = TREE_TYPE (init);
15023 if (TREE_CODE (type) == ARRAY_TYPE)
15025 tree enttype = TREE_TYPE (type);
15026 enum machine_mode mode = TYPE_MODE (enttype);
15028 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
15030 if (int_size_in_bytes (type) != size)
15032 if (size > TREE_STRING_LENGTH (init))
15034 memcpy (array, TREE_STRING_POINTER (init),
15035 TREE_STRING_LENGTH (init));
15036 memset (array + TREE_STRING_LENGTH (init),
15037 '\0', size - TREE_STRING_LENGTH (init));
15040 memcpy (array, TREE_STRING_POINTER (init), size);
15045 type = TREE_TYPE (init);
15046 if (int_size_in_bytes (type) != size)
15048 if (TREE_CODE (type) == ARRAY_TYPE)
15050 HOST_WIDE_INT min_index;
15051 unsigned HOST_WIDE_INT cnt;
15052 int curpos = 0, fieldsize;
15053 constructor_elt *ce;
15055 if (TYPE_DOMAIN (type) == NULL_TREE
15056 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
15059 fieldsize = int_size_in_bytes (TREE_TYPE (type));
15060 if (fieldsize <= 0)
15063 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
15064 memset (array, '\0', size);
15065 FOR_EACH_VEC_ELT (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce)
15067 tree val = ce->value;
15068 tree index = ce->index;
15070 if (index && TREE_CODE (index) == RANGE_EXPR)
15071 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
15074 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
15079 if (!native_encode_initializer (val, array + pos, fieldsize))
15082 curpos = pos + fieldsize;
15083 if (index && TREE_CODE (index) == RANGE_EXPR)
15085 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
15086 - tree_low_cst (TREE_OPERAND (index, 0), 0);
15087 while (count-- > 0)
15090 memcpy (array + curpos, array + pos, fieldsize);
15091 curpos += fieldsize;
15094 gcc_assert (curpos <= size);
15098 else if (TREE_CODE (type) == RECORD_TYPE
15099 || TREE_CODE (type) == UNION_TYPE)
15101 tree field = NULL_TREE;
15102 unsigned HOST_WIDE_INT cnt;
15103 constructor_elt *ce;
15105 if (int_size_in_bytes (type) != size)
15108 if (TREE_CODE (type) == RECORD_TYPE)
15109 field = TYPE_FIELDS (type);
15111 FOR_EACH_VEC_ELT (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce)
15113 tree val = ce->value;
15114 int pos, fieldsize;
15116 if (ce->index != 0)
15122 if (field == NULL_TREE || DECL_BIT_FIELD (field))
15125 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
15126 && TYPE_DOMAIN (TREE_TYPE (field))
15127 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
15129 else if (DECL_SIZE_UNIT (field) == NULL_TREE
15130 || !host_integerp (DECL_SIZE_UNIT (field), 0))
15132 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
15133 pos = int_byte_position (field);
15134 gcc_assert (pos + fieldsize <= size);
15136 && !native_encode_initializer (val, array + pos, fieldsize))
15142 case VIEW_CONVERT_EXPR:
15143 case NON_LVALUE_EXPR:
15144 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
15146 return native_encode_expr (init, array, size) == size;
15150 /* Attach a DW_AT_const_value attribute to DIE. The value of the
15151 attribute is the const value T. */
15154 tree_add_const_value_attribute (dw_die_ref die, tree t)
15157 tree type = TREE_TYPE (t);
15160 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
15164 gcc_assert (!DECL_P (init));
15166 rtl = rtl_for_decl_init (init, type);
15168 return add_const_value_attribute (die, rtl);
15169 /* If the host and target are sane, try harder. */
15170 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
15171 && initializer_constant_valid_p (init, type))
15173 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
15174 if (size > 0 && (int) size == size)
15176 unsigned char *array = (unsigned char *)
15177 ggc_alloc_cleared_atomic (size);
15179 if (native_encode_initializer (init, array, size))
15181 add_AT_vec (die, DW_AT_const_value, size, 1, array);
15189 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
15190 attribute is the const value of T, where T is an integral constant
15191 variable with static storage duration
15192 (so it can't be a PARM_DECL or a RESULT_DECL). */
15195 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
15199 || (TREE_CODE (decl) != VAR_DECL
15200 && TREE_CODE (decl) != CONST_DECL)
15201 || (TREE_CODE (decl) == VAR_DECL
15202 && !TREE_STATIC (decl)))
15205 if (TREE_READONLY (decl)
15206 && ! TREE_THIS_VOLATILE (decl)
15207 && DECL_INITIAL (decl))
15212 /* Don't add DW_AT_const_value if abstract origin already has one. */
15213 if (get_AT (var_die, DW_AT_const_value))
15216 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
15219 /* Convert the CFI instructions for the current function into a
15220 location list. This is used for DW_AT_frame_base when we targeting
15221 a dwarf2 consumer that does not support the dwarf3
15222 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
15225 static dw_loc_list_ref
15226 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
15230 dw_loc_list_ref list, *list_tail;
15232 dw_cfa_location last_cfa, next_cfa;
15233 const char *start_label, *last_label, *section;
15234 dw_cfa_location remember;
15237 gcc_assert (fde != NULL);
15239 section = secname_for_decl (current_function_decl);
15243 memset (&next_cfa, 0, sizeof (next_cfa));
15244 next_cfa.reg = INVALID_REGNUM;
15245 remember = next_cfa;
15247 start_label = fde->dw_fde_begin;
15249 /* ??? Bald assumption that the CIE opcode list does not contain
15250 advance opcodes. */
15251 FOR_EACH_VEC_ELT (dw_cfi_ref, cie_cfi_vec, ix, cfi)
15252 lookup_cfa_1 (cfi, &next_cfa, &remember);
15254 last_cfa = next_cfa;
15255 last_label = start_label;
15257 if (fde->dw_fde_second_begin && fde->dw_fde_switch_cfi_index == 0)
15259 /* If the first partition contained no CFI adjustments, the
15260 CIE opcodes apply to the whole first partition. */
15261 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
15262 fde->dw_fde_begin, fde->dw_fde_end, section);
15263 list_tail =&(*list_tail)->dw_loc_next;
15264 start_label = last_label = fde->dw_fde_second_begin;
15267 FOR_EACH_VEC_ELT (dw_cfi_ref, fde->dw_fde_cfi, ix, cfi)
15269 switch (cfi->dw_cfi_opc)
15271 case DW_CFA_set_loc:
15272 case DW_CFA_advance_loc1:
15273 case DW_CFA_advance_loc2:
15274 case DW_CFA_advance_loc4:
15275 if (!cfa_equal_p (&last_cfa, &next_cfa))
15277 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
15278 start_label, last_label, section);
15280 list_tail = &(*list_tail)->dw_loc_next;
15281 last_cfa = next_cfa;
15282 start_label = last_label;
15284 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
15287 case DW_CFA_advance_loc:
15288 /* The encoding is complex enough that we should never emit this. */
15289 gcc_unreachable ();
15292 lookup_cfa_1 (cfi, &next_cfa, &remember);
15295 if (ix + 1 == fde->dw_fde_switch_cfi_index)
15297 if (!cfa_equal_p (&last_cfa, &next_cfa))
15299 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
15300 start_label, last_label, section);
15302 list_tail = &(*list_tail)->dw_loc_next;
15303 last_cfa = next_cfa;
15304 start_label = last_label;
15306 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
15307 start_label, fde->dw_fde_end, section);
15308 list_tail = &(*list_tail)->dw_loc_next;
15309 start_label = last_label = fde->dw_fde_second_begin;
15313 if (!cfa_equal_p (&last_cfa, &next_cfa))
15315 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
15316 start_label, last_label, section);
15317 list_tail = &(*list_tail)->dw_loc_next;
15318 start_label = last_label;
15321 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
15323 fde->dw_fde_second_begin
15324 ? fde->dw_fde_second_end : fde->dw_fde_end,
15327 if (list && list->dw_loc_next)
15333 /* Compute a displacement from the "steady-state frame pointer" to the
15334 frame base (often the same as the CFA), and store it in
15335 frame_pointer_fb_offset. OFFSET is added to the displacement
15336 before the latter is negated. */
15339 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
15343 #ifdef FRAME_POINTER_CFA_OFFSET
15344 reg = frame_pointer_rtx;
15345 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
15347 reg = arg_pointer_rtx;
15348 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
15351 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
15352 if (GET_CODE (elim) == PLUS)
15354 offset += INTVAL (XEXP (elim, 1));
15355 elim = XEXP (elim, 0);
15358 frame_pointer_fb_offset = -offset;
15360 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
15361 in which to eliminate. This is because it's stack pointer isn't
15362 directly accessible as a register within the ISA. To work around
15363 this, assume that while we cannot provide a proper value for
15364 frame_pointer_fb_offset, we won't need one either. */
15365 frame_pointer_fb_offset_valid
15366 = ((SUPPORTS_STACK_ALIGNMENT
15367 && (elim == hard_frame_pointer_rtx
15368 || elim == stack_pointer_rtx))
15369 || elim == (frame_pointer_needed
15370 ? hard_frame_pointer_rtx
15371 : stack_pointer_rtx));
15374 /* Generate a DW_AT_name attribute given some string value to be included as
15375 the value of the attribute. */
15378 add_name_attribute (dw_die_ref die, const char *name_string)
15380 if (name_string != NULL && *name_string != 0)
15382 if (demangle_name_func)
15383 name_string = (*demangle_name_func) (name_string);
15385 add_AT_string (die, DW_AT_name, name_string);
15389 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
15390 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
15391 of TYPE accordingly.
15393 ??? This is a temporary measure until after we're able to generate
15394 regular DWARF for the complex Ada type system. */
15397 add_gnat_descriptive_type_attribute (dw_die_ref die, tree type,
15398 dw_die_ref context_die)
15401 dw_die_ref dtype_die;
15403 if (!lang_hooks.types.descriptive_type)
15406 dtype = lang_hooks.types.descriptive_type (type);
15410 dtype_die = lookup_type_die (dtype);
15413 gen_type_die (dtype, context_die);
15414 dtype_die = lookup_type_die (dtype);
15415 gcc_assert (dtype_die);
15418 add_AT_die_ref (die, DW_AT_GNAT_descriptive_type, dtype_die);
15421 /* Generate a DW_AT_comp_dir attribute for DIE. */
15424 add_comp_dir_attribute (dw_die_ref die)
15426 const char *wd = get_src_pwd ();
15432 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
15436 wdlen = strlen (wd);
15437 wd1 = (char *) ggc_alloc_atomic (wdlen + 2);
15439 wd1 [wdlen] = DIR_SEPARATOR;
15440 wd1 [wdlen + 1] = 0;
15444 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
15447 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
15451 lower_bound_default (void)
15453 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
15458 case DW_LANG_C_plus_plus:
15460 case DW_LANG_ObjC_plus_plus:
15463 case DW_LANG_Fortran77:
15464 case DW_LANG_Fortran90:
15465 case DW_LANG_Fortran95:
15469 case DW_LANG_Python:
15470 return dwarf_version >= 4 ? 0 : -1;
15471 case DW_LANG_Ada95:
15472 case DW_LANG_Ada83:
15473 case DW_LANG_Cobol74:
15474 case DW_LANG_Cobol85:
15475 case DW_LANG_Pascal83:
15476 case DW_LANG_Modula2:
15478 return dwarf_version >= 4 ? 1 : -1;
15484 /* Given a tree node describing an array bound (either lower or upper) output
15485 a representation for that bound. */
15488 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
15490 switch (TREE_CODE (bound))
15495 /* All fixed-bounds are represented by INTEGER_CST nodes. */
15498 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (bound));
15501 /* Use the default if possible. */
15502 if (bound_attr == DW_AT_lower_bound
15503 && host_integerp (bound, 0)
15504 && (dflt = lower_bound_default ()) != -1
15505 && tree_low_cst (bound, 0) == dflt)
15508 /* Otherwise represent the bound as an unsigned value with the
15509 precision of its type. The precision and signedness of the
15510 type will be necessary to re-interpret it unambiguously. */
15511 else if (prec < HOST_BITS_PER_WIDE_INT)
15513 unsigned HOST_WIDE_INT mask
15514 = ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
15515 add_AT_unsigned (subrange_die, bound_attr,
15516 TREE_INT_CST_LOW (bound) & mask);
15518 else if (prec == HOST_BITS_PER_WIDE_INT
15519 || TREE_INT_CST_HIGH (bound) == 0)
15520 add_AT_unsigned (subrange_die, bound_attr,
15521 TREE_INT_CST_LOW (bound));
15523 add_AT_double (subrange_die, bound_attr, TREE_INT_CST_HIGH (bound),
15524 TREE_INT_CST_LOW (bound));
15529 case VIEW_CONVERT_EXPR:
15530 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
15540 dw_die_ref decl_die = lookup_decl_die (bound);
15542 /* ??? Can this happen, or should the variable have been bound
15543 first? Probably it can, since I imagine that we try to create
15544 the types of parameters in the order in which they exist in
15545 the list, and won't have created a forward reference to a
15546 later parameter. */
15547 if (decl_die != NULL)
15549 add_AT_die_ref (subrange_die, bound_attr, decl_die);
15557 /* Otherwise try to create a stack operation procedure to
15558 evaluate the value of the array bound. */
15560 dw_die_ref ctx, decl_die;
15561 dw_loc_list_ref list;
15563 list = loc_list_from_tree (bound, 2);
15564 if (list == NULL || single_element_loc_list_p (list))
15566 /* If DW_AT_*bound is not a reference nor constant, it is
15567 a DWARF expression rather than location description.
15568 For that loc_list_from_tree (bound, 0) is needed.
15569 If that fails to give a single element list,
15570 fall back to outputting this as a reference anyway. */
15571 dw_loc_list_ref list2 = loc_list_from_tree (bound, 0);
15572 if (list2 && single_element_loc_list_p (list2))
15574 add_AT_loc (subrange_die, bound_attr, list2->expr);
15581 if (current_function_decl == 0)
15582 ctx = comp_unit_die ();
15584 ctx = lookup_decl_die (current_function_decl);
15586 decl_die = new_die (DW_TAG_variable, ctx, bound);
15587 add_AT_flag (decl_die, DW_AT_artificial, 1);
15588 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
15589 add_AT_location_description (decl_die, DW_AT_location, list);
15590 add_AT_die_ref (subrange_die, bound_attr, decl_die);
15596 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
15597 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
15598 Note that the block of subscript information for an array type also
15599 includes information about the element type of the given array type. */
15602 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
15604 unsigned dimension_number;
15606 dw_die_ref subrange_die;
15608 for (dimension_number = 0;
15609 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
15610 type = TREE_TYPE (type), dimension_number++)
15612 tree domain = TYPE_DOMAIN (type);
15614 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
15617 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
15618 and (in GNU C only) variable bounds. Handle all three forms
15620 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
15623 /* We have an array type with specified bounds. */
15624 lower = TYPE_MIN_VALUE (domain);
15625 upper = TYPE_MAX_VALUE (domain);
15627 /* Define the index type. */
15628 if (TREE_TYPE (domain))
15630 /* ??? This is probably an Ada unnamed subrange type. Ignore the
15631 TREE_TYPE field. We can't emit debug info for this
15632 because it is an unnamed integral type. */
15633 if (TREE_CODE (domain) == INTEGER_TYPE
15634 && TYPE_NAME (domain) == NULL_TREE
15635 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
15636 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
15639 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
15643 /* ??? If upper is NULL, the array has unspecified length,
15644 but it does have a lower bound. This happens with Fortran
15646 Since the debugger is definitely going to need to know N
15647 to produce useful results, go ahead and output the lower
15648 bound solo, and hope the debugger can cope. */
15650 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
15652 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
15655 /* Otherwise we have an array type with an unspecified length. The
15656 DWARF-2 spec does not say how to handle this; let's just leave out the
15662 add_byte_size_attribute (dw_die_ref die, tree tree_node)
15666 switch (TREE_CODE (tree_node))
15671 case ENUMERAL_TYPE:
15674 case QUAL_UNION_TYPE:
15675 size = int_size_in_bytes (tree_node);
15678 /* For a data member of a struct or union, the DW_AT_byte_size is
15679 generally given as the number of bytes normally allocated for an
15680 object of the *declared* type of the member itself. This is true
15681 even for bit-fields. */
15682 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
15685 gcc_unreachable ();
15688 /* Note that `size' might be -1 when we get to this point. If it is, that
15689 indicates that the byte size of the entity in question is variable. We
15690 have no good way of expressing this fact in Dwarf at the present time,
15691 so just let the -1 pass on through. */
15692 add_AT_unsigned (die, DW_AT_byte_size, size);
15695 /* For a FIELD_DECL node which represents a bit-field, output an attribute
15696 which specifies the distance in bits from the highest order bit of the
15697 "containing object" for the bit-field to the highest order bit of the
15700 For any given bit-field, the "containing object" is a hypothetical object
15701 (of some integral or enum type) within which the given bit-field lives. The
15702 type of this hypothetical "containing object" is always the same as the
15703 declared type of the individual bit-field itself. The determination of the
15704 exact location of the "containing object" for a bit-field is rather
15705 complicated. It's handled by the `field_byte_offset' function (above).
15707 Note that it is the size (in bytes) of the hypothetical "containing object"
15708 which will be given in the DW_AT_byte_size attribute for this bit-field.
15709 (See `byte_size_attribute' above). */
15712 add_bit_offset_attribute (dw_die_ref die, tree decl)
15714 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
15715 tree type = DECL_BIT_FIELD_TYPE (decl);
15716 HOST_WIDE_INT bitpos_int;
15717 HOST_WIDE_INT highest_order_object_bit_offset;
15718 HOST_WIDE_INT highest_order_field_bit_offset;
15719 HOST_WIDE_INT bit_offset;
15721 /* Must be a field and a bit field. */
15722 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
15724 /* We can't yet handle bit-fields whose offsets are variable, so if we
15725 encounter such things, just return without generating any attribute
15726 whatsoever. Likewise for variable or too large size. */
15727 if (! host_integerp (bit_position (decl), 0)
15728 || ! host_integerp (DECL_SIZE (decl), 1))
15731 bitpos_int = int_bit_position (decl);
15733 /* Note that the bit offset is always the distance (in bits) from the
15734 highest-order bit of the "containing object" to the highest-order bit of
15735 the bit-field itself. Since the "high-order end" of any object or field
15736 is different on big-endian and little-endian machines, the computation
15737 below must take account of these differences. */
15738 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
15739 highest_order_field_bit_offset = bitpos_int;
15741 if (! BYTES_BIG_ENDIAN)
15743 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
15744 highest_order_object_bit_offset += simple_type_size_in_bits (type);
15748 = (! BYTES_BIG_ENDIAN
15749 ? highest_order_object_bit_offset - highest_order_field_bit_offset
15750 : highest_order_field_bit_offset - highest_order_object_bit_offset);
15752 if (bit_offset < 0)
15753 add_AT_int (die, DW_AT_bit_offset, bit_offset);
15755 add_AT_unsigned (die, DW_AT_bit_offset, (unsigned HOST_WIDE_INT) bit_offset);
15758 /* For a FIELD_DECL node which represents a bit field, output an attribute
15759 which specifies the length in bits of the given field. */
15762 add_bit_size_attribute (dw_die_ref die, tree decl)
15764 /* Must be a field and a bit field. */
15765 gcc_assert (TREE_CODE (decl) == FIELD_DECL
15766 && DECL_BIT_FIELD_TYPE (decl));
15768 if (host_integerp (DECL_SIZE (decl), 1))
15769 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
15772 /* If the compiled language is ANSI C, then add a 'prototyped'
15773 attribute, if arg types are given for the parameters of a function. */
15776 add_prototyped_attribute (dw_die_ref die, tree func_type)
15778 if (get_AT_unsigned (comp_unit_die (), DW_AT_language) == DW_LANG_C89
15779 && prototype_p (func_type))
15780 add_AT_flag (die, DW_AT_prototyped, 1);
15783 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
15784 by looking in either the type declaration or object declaration
15787 static inline dw_die_ref
15788 add_abstract_origin_attribute (dw_die_ref die, tree origin)
15790 dw_die_ref origin_die = NULL;
15792 if (TREE_CODE (origin) != FUNCTION_DECL)
15794 /* We may have gotten separated from the block for the inlined
15795 function, if we're in an exception handler or some such; make
15796 sure that the abstract function has been written out.
15798 Doing this for nested functions is wrong, however; functions are
15799 distinct units, and our context might not even be inline. */
15803 fn = TYPE_STUB_DECL (fn);
15805 fn = decl_function_context (fn);
15807 dwarf2out_abstract_function (fn);
15810 if (DECL_P (origin))
15811 origin_die = lookup_decl_die (origin);
15812 else if (TYPE_P (origin))
15813 origin_die = lookup_type_die (origin);
15815 /* XXX: Functions that are never lowered don't always have correct block
15816 trees (in the case of java, they simply have no block tree, in some other
15817 languages). For these functions, there is nothing we can really do to
15818 output correct debug info for inlined functions in all cases. Rather
15819 than die, we'll just produce deficient debug info now, in that we will
15820 have variables without a proper abstract origin. In the future, when all
15821 functions are lowered, we should re-add a gcc_assert (origin_die)
15825 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
15829 /* We do not currently support the pure_virtual attribute. */
15832 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
15834 if (DECL_VINDEX (func_decl))
15836 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
15838 if (host_integerp (DECL_VINDEX (func_decl), 0))
15839 add_AT_loc (die, DW_AT_vtable_elem_location,
15840 new_loc_descr (DW_OP_constu,
15841 tree_low_cst (DECL_VINDEX (func_decl), 0),
15844 /* GNU extension: Record what type this method came from originally. */
15845 if (debug_info_level > DINFO_LEVEL_TERSE
15846 && DECL_CONTEXT (func_decl))
15847 add_AT_die_ref (die, DW_AT_containing_type,
15848 lookup_type_die (DECL_CONTEXT (func_decl)));
15852 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
15853 given decl. This used to be a vendor extension until after DWARF 4
15854 standardized it. */
15857 add_linkage_attr (dw_die_ref die, tree decl)
15859 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
15861 /* Mimic what assemble_name_raw does with a leading '*'. */
15862 if (name[0] == '*')
15865 if (dwarf_version >= 4)
15866 add_AT_string (die, DW_AT_linkage_name, name);
15868 add_AT_string (die, DW_AT_MIPS_linkage_name, name);
15871 /* Add source coordinate attributes for the given decl. */
15874 add_src_coords_attributes (dw_die_ref die, tree decl)
15876 expanded_location s;
15878 if (DECL_SOURCE_LOCATION (decl) == UNKNOWN_LOCATION)
15880 s = expand_location (DECL_SOURCE_LOCATION (decl));
15881 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
15882 add_AT_unsigned (die, DW_AT_decl_line, s.line);
15885 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
15888 add_linkage_name (dw_die_ref die, tree decl)
15890 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
15891 && TREE_PUBLIC (decl)
15892 && !DECL_ABSTRACT (decl)
15893 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
15894 && die->die_tag != DW_TAG_member)
15896 /* Defer until we have an assembler name set. */
15897 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
15899 limbo_die_node *asm_name;
15901 asm_name = ggc_alloc_cleared_limbo_die_node ();
15902 asm_name->die = die;
15903 asm_name->created_for = decl;
15904 asm_name->next = deferred_asm_name;
15905 deferred_asm_name = asm_name;
15907 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
15908 add_linkage_attr (die, decl);
15912 /* Add a DW_AT_name attribute and source coordinate attribute for the
15913 given decl, but only if it actually has a name. */
15916 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
15920 decl_name = DECL_NAME (decl);
15921 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
15923 const char *name = dwarf2_name (decl, 0);
15925 add_name_attribute (die, name);
15926 if (! DECL_ARTIFICIAL (decl))
15927 add_src_coords_attributes (die, decl);
15929 add_linkage_name (die, decl);
15932 #ifdef VMS_DEBUGGING_INFO
15933 /* Get the function's name, as described by its RTL. This may be different
15934 from the DECL_NAME name used in the source file. */
15935 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
15937 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
15938 XEXP (DECL_RTL (decl), 0));
15939 VEC_safe_push (rtx, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
15941 #endif /* VMS_DEBUGGING_INFO */
15944 #ifdef VMS_DEBUGGING_INFO
15945 /* Output the debug main pointer die for VMS */
15948 dwarf2out_vms_debug_main_pointer (void)
15950 char label[MAX_ARTIFICIAL_LABEL_BYTES];
15953 /* Allocate the VMS debug main subprogram die. */
15954 die = ggc_alloc_cleared_die_node ();
15955 die->die_tag = DW_TAG_subprogram;
15956 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER);
15957 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
15958 current_function_funcdef_no);
15959 add_AT_lbl_id (die, DW_AT_entry_pc, label);
15961 /* Make it the first child of comp_unit_die (). */
15962 die->die_parent = comp_unit_die ();
15963 if (comp_unit_die ()->die_child)
15965 die->die_sib = comp_unit_die ()->die_child->die_sib;
15966 comp_unit_die ()->die_child->die_sib = die;
15970 die->die_sib = die;
15971 comp_unit_die ()->die_child = die;
15974 #endif /* VMS_DEBUGGING_INFO */
15976 /* Push a new declaration scope. */
15979 push_decl_scope (tree scope)
15981 VEC_safe_push (tree, gc, decl_scope_table, scope);
15984 /* Pop a declaration scope. */
15987 pop_decl_scope (void)
15989 VEC_pop (tree, decl_scope_table);
15992 /* Return the DIE for the scope that immediately contains this type.
15993 Non-named types get global scope. Named types nested in other
15994 types get their containing scope if it's open, or global scope
15995 otherwise. All other types (i.e. function-local named types) get
15996 the current active scope. */
15999 scope_die_for (tree t, dw_die_ref context_die)
16001 dw_die_ref scope_die = NULL;
16002 tree containing_scope;
16005 /* Non-types always go in the current scope. */
16006 gcc_assert (TYPE_P (t));
16008 containing_scope = TYPE_CONTEXT (t);
16010 /* Use the containing namespace if it was passed in (for a declaration). */
16011 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
16013 if (context_die == lookup_decl_die (containing_scope))
16016 containing_scope = NULL_TREE;
16019 /* Ignore function type "scopes" from the C frontend. They mean that
16020 a tagged type is local to a parmlist of a function declarator, but
16021 that isn't useful to DWARF. */
16022 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
16023 containing_scope = NULL_TREE;
16025 if (SCOPE_FILE_SCOPE_P (containing_scope))
16026 scope_die = comp_unit_die ();
16027 else if (TYPE_P (containing_scope))
16029 /* For types, we can just look up the appropriate DIE. But
16030 first we check to see if we're in the middle of emitting it
16031 so we know where the new DIE should go. */
16032 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
16033 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
16038 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
16039 || TREE_ASM_WRITTEN (containing_scope));
16040 /*We are not in the middle of emitting the type
16041 CONTAINING_SCOPE. Let's see if it's emitted already. */
16042 scope_die = lookup_type_die (containing_scope);
16044 /* If none of the current dies are suitable, we get file scope. */
16045 if (scope_die == NULL)
16046 scope_die = comp_unit_die ();
16049 scope_die = lookup_type_die_strip_naming_typedef (containing_scope);
16052 scope_die = context_die;
16057 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
16060 local_scope_p (dw_die_ref context_die)
16062 for (; context_die; context_die = context_die->die_parent)
16063 if (context_die->die_tag == DW_TAG_inlined_subroutine
16064 || context_die->die_tag == DW_TAG_subprogram)
16070 /* Returns nonzero if CONTEXT_DIE is a class. */
16073 class_scope_p (dw_die_ref context_die)
16075 return (context_die
16076 && (context_die->die_tag == DW_TAG_structure_type
16077 || context_die->die_tag == DW_TAG_class_type
16078 || context_die->die_tag == DW_TAG_interface_type
16079 || context_die->die_tag == DW_TAG_union_type));
16082 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
16083 whether or not to treat a DIE in this context as a declaration. */
16086 class_or_namespace_scope_p (dw_die_ref context_die)
16088 return (class_scope_p (context_die)
16089 || (context_die && context_die->die_tag == DW_TAG_namespace));
16092 /* Many forms of DIEs require a "type description" attribute. This
16093 routine locates the proper "type descriptor" die for the type given
16094 by 'type', and adds a DW_AT_type attribute below the given die. */
16097 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
16098 int decl_volatile, dw_die_ref context_die)
16100 enum tree_code code = TREE_CODE (type);
16101 dw_die_ref type_die = NULL;
16103 /* ??? If this type is an unnamed subrange type of an integral, floating-point
16104 or fixed-point type, use the inner type. This is because we have no
16105 support for unnamed types in base_type_die. This can happen if this is
16106 an Ada subrange type. Correct solution is emit a subrange type die. */
16107 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
16108 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
16109 type = TREE_TYPE (type), code = TREE_CODE (type);
16111 if (code == ERROR_MARK
16112 /* Handle a special case. For functions whose return type is void, we
16113 generate *no* type attribute. (Note that no object may have type
16114 `void', so this only applies to function return types). */
16115 || code == VOID_TYPE)
16118 type_die = modified_type_die (type,
16119 decl_const || TYPE_READONLY (type),
16120 decl_volatile || TYPE_VOLATILE (type),
16123 if (type_die != NULL)
16124 add_AT_die_ref (object_die, DW_AT_type, type_die);
16127 /* Given an object die, add the calling convention attribute for the
16128 function call type. */
16130 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
16132 enum dwarf_calling_convention value = DW_CC_normal;
16134 value = ((enum dwarf_calling_convention)
16135 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
16138 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
16140 /* DWARF 2 doesn't provide a way to identify a program's source-level
16141 entry point. DW_AT_calling_convention attributes are only meant
16142 to describe functions' calling conventions. However, lacking a
16143 better way to signal the Fortran main program, we used this for
16144 a long time, following existing custom. Now, DWARF 4 has
16145 DW_AT_main_subprogram, which we add below, but some tools still
16146 rely on the old way, which we thus keep. */
16147 value = DW_CC_program;
16149 if (dwarf_version >= 4 || !dwarf_strict)
16150 add_AT_flag (subr_die, DW_AT_main_subprogram, 1);
16153 /* Only add the attribute if the backend requests it, and
16154 is not DW_CC_normal. */
16155 if (value && (value != DW_CC_normal))
16156 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
16159 /* Given a tree pointer to a struct, class, union, or enum type node, return
16160 a pointer to the (string) tag name for the given type, or zero if the type
16161 was declared without a tag. */
16163 static const char *
16164 type_tag (const_tree type)
16166 const char *name = 0;
16168 if (TYPE_NAME (type) != 0)
16172 /* Find the IDENTIFIER_NODE for the type name. */
16173 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
16174 && !TYPE_NAMELESS (type))
16175 t = TYPE_NAME (type);
16177 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
16178 a TYPE_DECL node, regardless of whether or not a `typedef' was
16180 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
16181 && ! DECL_IGNORED_P (TYPE_NAME (type)))
16183 /* We want to be extra verbose. Don't call dwarf_name if
16184 DECL_NAME isn't set. The default hook for decl_printable_name
16185 doesn't like that, and in this context it's correct to return
16186 0, instead of "<anonymous>" or the like. */
16187 if (DECL_NAME (TYPE_NAME (type))
16188 && !DECL_NAMELESS (TYPE_NAME (type)))
16189 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
16192 /* Now get the name as a string, or invent one. */
16193 if (!name && t != 0)
16194 name = IDENTIFIER_POINTER (t);
16197 return (name == 0 || *name == '\0') ? 0 : name;
16200 /* Return the type associated with a data member, make a special check
16201 for bit field types. */
16204 member_declared_type (const_tree member)
16206 return (DECL_BIT_FIELD_TYPE (member)
16207 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
16210 /* Get the decl's label, as described by its RTL. This may be different
16211 from the DECL_NAME name used in the source file. */
16214 static const char *
16215 decl_start_label (tree decl)
16218 const char *fnname;
16220 x = DECL_RTL (decl);
16221 gcc_assert (MEM_P (x));
16224 gcc_assert (GET_CODE (x) == SYMBOL_REF);
16226 fnname = XSTR (x, 0);
16231 /* These routines generate the internal representation of the DIE's for
16232 the compilation unit. Debugging information is collected by walking
16233 the declaration trees passed in from dwarf2out_decl(). */
16236 gen_array_type_die (tree type, dw_die_ref context_die)
16238 dw_die_ref scope_die = scope_die_for (type, context_die);
16239 dw_die_ref array_die;
16241 /* GNU compilers represent multidimensional array types as sequences of one
16242 dimensional array types whose element types are themselves array types.
16243 We sometimes squish that down to a single array_type DIE with multiple
16244 subscripts in the Dwarf debugging info. The draft Dwarf specification
16245 say that we are allowed to do this kind of compression in C, because
16246 there is no difference between an array of arrays and a multidimensional
16247 array. We don't do this for Ada to remain as close as possible to the
16248 actual representation, which is especially important against the language
16249 flexibilty wrt arrays of variable size. */
16251 bool collapse_nested_arrays = !is_ada ();
16254 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
16255 DW_TAG_string_type doesn't have DW_AT_type attribute). */
16256 if (TYPE_STRING_FLAG (type)
16257 && TREE_CODE (type) == ARRAY_TYPE
16259 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
16261 HOST_WIDE_INT size;
16263 array_die = new_die (DW_TAG_string_type, scope_die, type);
16264 add_name_attribute (array_die, type_tag (type));
16265 equate_type_number_to_die (type, array_die);
16266 size = int_size_in_bytes (type);
16268 add_AT_unsigned (array_die, DW_AT_byte_size, size);
16269 else if (TYPE_DOMAIN (type) != NULL_TREE
16270 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
16271 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
16273 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
16274 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2);
16276 size = int_size_in_bytes (TREE_TYPE (szdecl));
16277 if (loc && size > 0)
16279 add_AT_location_description (array_die, DW_AT_string_length, loc);
16280 if (size != DWARF2_ADDR_SIZE)
16281 add_AT_unsigned (array_die, DW_AT_byte_size, size);
16287 /* ??? The SGI dwarf reader fails for array of array of enum types
16288 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
16289 array type comes before the outer array type. We thus call gen_type_die
16290 before we new_die and must prevent nested array types collapsing for this
16293 #ifdef MIPS_DEBUGGING_INFO
16294 gen_type_die (TREE_TYPE (type), context_die);
16295 collapse_nested_arrays = false;
16298 array_die = new_die (DW_TAG_array_type, scope_die, type);
16299 add_name_attribute (array_die, type_tag (type));
16300 add_gnat_descriptive_type_attribute (array_die, type, context_die);
16301 if (TYPE_ARTIFICIAL (type))
16302 add_AT_flag (array_die, DW_AT_artificial, 1);
16303 equate_type_number_to_die (type, array_die);
16305 if (TREE_CODE (type) == VECTOR_TYPE)
16306 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
16308 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
16310 && TREE_CODE (type) == ARRAY_TYPE
16311 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
16312 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
16313 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
16316 /* We default the array ordering. SDB will probably do
16317 the right things even if DW_AT_ordering is not present. It's not even
16318 an issue until we start to get into multidimensional arrays anyway. If
16319 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
16320 then we'll have to put the DW_AT_ordering attribute back in. (But if
16321 and when we find out that we need to put these in, we will only do so
16322 for multidimensional arrays. */
16323 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
16326 #ifdef MIPS_DEBUGGING_INFO
16327 /* The SGI compilers handle arrays of unknown bound by setting
16328 AT_declaration and not emitting any subrange DIEs. */
16329 if (TREE_CODE (type) == ARRAY_TYPE
16330 && ! TYPE_DOMAIN (type))
16331 add_AT_flag (array_die, DW_AT_declaration, 1);
16334 if (TREE_CODE (type) == VECTOR_TYPE)
16336 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
16337 dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL);
16338 add_bound_info (subrange_die, DW_AT_lower_bound, size_zero_node);
16339 add_bound_info (subrange_die, DW_AT_upper_bound,
16340 size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
16343 add_subscript_info (array_die, type, collapse_nested_arrays);
16345 /* Add representation of the type of the elements of this array type and
16346 emit the corresponding DIE if we haven't done it already. */
16347 element_type = TREE_TYPE (type);
16348 if (collapse_nested_arrays)
16349 while (TREE_CODE (element_type) == ARRAY_TYPE)
16351 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
16353 element_type = TREE_TYPE (element_type);
16356 #ifndef MIPS_DEBUGGING_INFO
16357 gen_type_die (element_type, context_die);
16360 add_type_attribute (array_die, element_type, 0, 0, context_die);
16362 if (get_AT (array_die, DW_AT_name))
16363 add_pubtype (type, array_die);
16366 static dw_loc_descr_ref
16367 descr_info_loc (tree val, tree base_decl)
16369 HOST_WIDE_INT size;
16370 dw_loc_descr_ref loc, loc2;
16371 enum dwarf_location_atom op;
16373 if (val == base_decl)
16374 return new_loc_descr (DW_OP_push_object_address, 0, 0);
16376 switch (TREE_CODE (val))
16379 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
16381 return loc_descriptor_from_tree (val, 0);
16383 if (host_integerp (val, 0))
16384 return int_loc_descriptor (tree_low_cst (val, 0));
16387 size = int_size_in_bytes (TREE_TYPE (val));
16390 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
16393 if (size == DWARF2_ADDR_SIZE)
16394 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
16396 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
16398 case POINTER_PLUS_EXPR:
16400 if (host_integerp (TREE_OPERAND (val, 1), 1)
16401 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
16404 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
16407 loc_descr_plus_const (&loc, tree_low_cst (TREE_OPERAND (val, 1), 0));
16413 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
16416 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
16419 add_loc_descr (&loc, loc2);
16420 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
16442 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
16443 tree val, tree base_decl)
16445 dw_loc_descr_ref loc;
16447 if (host_integerp (val, 0))
16449 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
16453 loc = descr_info_loc (val, base_decl);
16457 add_AT_loc (die, attr, loc);
16460 /* This routine generates DIE for array with hidden descriptor, details
16461 are filled into *info by a langhook. */
16464 gen_descr_array_type_die (tree type, struct array_descr_info *info,
16465 dw_die_ref context_die)
16467 dw_die_ref scope_die = scope_die_for (type, context_die);
16468 dw_die_ref array_die;
16471 array_die = new_die (DW_TAG_array_type, scope_die, type);
16472 add_name_attribute (array_die, type_tag (type));
16473 equate_type_number_to_die (type, array_die);
16475 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
16477 && info->ndimensions >= 2)
16478 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
16480 if (info->data_location)
16481 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
16483 if (info->associated)
16484 add_descr_info_field (array_die, DW_AT_associated, info->associated,
16486 if (info->allocated)
16487 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
16490 for (dim = 0; dim < info->ndimensions; dim++)
16492 dw_die_ref subrange_die
16493 = new_die (DW_TAG_subrange_type, array_die, NULL);
16495 if (info->dimen[dim].lower_bound)
16497 /* If it is the default value, omit it. */
16500 if (host_integerp (info->dimen[dim].lower_bound, 0)
16501 && (dflt = lower_bound_default ()) != -1
16502 && tree_low_cst (info->dimen[dim].lower_bound, 0) == dflt)
16505 add_descr_info_field (subrange_die, DW_AT_lower_bound,
16506 info->dimen[dim].lower_bound,
16509 if (info->dimen[dim].upper_bound)
16510 add_descr_info_field (subrange_die, DW_AT_upper_bound,
16511 info->dimen[dim].upper_bound,
16513 if (info->dimen[dim].stride)
16514 add_descr_info_field (subrange_die, DW_AT_byte_stride,
16515 info->dimen[dim].stride,
16519 gen_type_die (info->element_type, context_die);
16520 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
16522 if (get_AT (array_die, DW_AT_name))
16523 add_pubtype (type, array_die);
16528 gen_entry_point_die (tree decl, dw_die_ref context_die)
16530 tree origin = decl_ultimate_origin (decl);
16531 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
16533 if (origin != NULL)
16534 add_abstract_origin_attribute (decl_die, origin);
16537 add_name_and_src_coords_attributes (decl_die, decl);
16538 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
16539 0, 0, context_die);
16542 if (DECL_ABSTRACT (decl))
16543 equate_decl_number_to_die (decl, decl_die);
16545 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
16549 /* Walk through the list of incomplete types again, trying once more to
16550 emit full debugging info for them. */
16553 retry_incomplete_types (void)
16557 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
16558 if (should_emit_struct_debug (VEC_index (tree, incomplete_types, i),
16559 DINFO_USAGE_DIR_USE))
16560 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die ());
16563 /* Determine what tag to use for a record type. */
16565 static enum dwarf_tag
16566 record_type_tag (tree type)
16568 if (! lang_hooks.types.classify_record)
16569 return DW_TAG_structure_type;
16571 switch (lang_hooks.types.classify_record (type))
16573 case RECORD_IS_STRUCT:
16574 return DW_TAG_structure_type;
16576 case RECORD_IS_CLASS:
16577 return DW_TAG_class_type;
16579 case RECORD_IS_INTERFACE:
16580 if (dwarf_version >= 3 || !dwarf_strict)
16581 return DW_TAG_interface_type;
16582 return DW_TAG_structure_type;
16585 gcc_unreachable ();
16589 /* Generate a DIE to represent an enumeration type. Note that these DIEs
16590 include all of the information about the enumeration values also. Each
16591 enumerated type name/value is listed as a child of the enumerated type
16595 gen_enumeration_type_die (tree type, dw_die_ref context_die)
16597 dw_die_ref type_die = lookup_type_die (type);
16599 if (type_die == NULL)
16601 type_die = new_die (DW_TAG_enumeration_type,
16602 scope_die_for (type, context_die), type);
16603 equate_type_number_to_die (type, type_die);
16604 add_name_attribute (type_die, type_tag (type));
16605 add_gnat_descriptive_type_attribute (type_die, type, context_die);
16606 if (TYPE_ARTIFICIAL (type))
16607 add_AT_flag (type_die, DW_AT_artificial, 1);
16608 if (dwarf_version >= 4 || !dwarf_strict)
16610 if (ENUM_IS_SCOPED (type))
16611 add_AT_flag (type_die, DW_AT_enum_class, 1);
16612 if (ENUM_IS_OPAQUE (type))
16613 add_AT_flag (type_die, DW_AT_declaration, 1);
16616 else if (! TYPE_SIZE (type))
16619 remove_AT (type_die, DW_AT_declaration);
16621 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
16622 given enum type is incomplete, do not generate the DW_AT_byte_size
16623 attribute or the DW_AT_element_list attribute. */
16624 if (TYPE_SIZE (type))
16628 TREE_ASM_WRITTEN (type) = 1;
16629 add_byte_size_attribute (type_die, type);
16630 if (TYPE_STUB_DECL (type) != NULL_TREE)
16632 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
16633 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
16636 /* If the first reference to this type was as the return type of an
16637 inline function, then it may not have a parent. Fix this now. */
16638 if (type_die->die_parent == NULL)
16639 add_child_die (scope_die_for (type, context_die), type_die);
16641 for (link = TYPE_VALUES (type);
16642 link != NULL; link = TREE_CHAIN (link))
16644 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
16645 tree value = TREE_VALUE (link);
16647 add_name_attribute (enum_die,
16648 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
16650 if (TREE_CODE (value) == CONST_DECL)
16651 value = DECL_INITIAL (value);
16653 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
16654 /* DWARF2 does not provide a way of indicating whether or
16655 not enumeration constants are signed or unsigned. GDB
16656 always assumes the values are signed, so we output all
16657 values as if they were signed. That means that
16658 enumeration constants with very large unsigned values
16659 will appear to have negative values in the debugger. */
16660 add_AT_int (enum_die, DW_AT_const_value,
16661 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
16665 add_AT_flag (type_die, DW_AT_declaration, 1);
16667 if (get_AT (type_die, DW_AT_name))
16668 add_pubtype (type, type_die);
16673 /* Generate a DIE to represent either a real live formal parameter decl or to
16674 represent just the type of some formal parameter position in some function
16677 Note that this routine is a bit unusual because its argument may be a
16678 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
16679 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
16680 node. If it's the former then this function is being called to output a
16681 DIE to represent a formal parameter object (or some inlining thereof). If
16682 it's the latter, then this function is only being called to output a
16683 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
16684 argument type of some subprogram type.
16685 If EMIT_NAME_P is true, name and source coordinate attributes
16689 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
16690 dw_die_ref context_die)
16692 tree node_or_origin = node ? node : origin;
16693 tree ultimate_origin;
16694 dw_die_ref parm_die
16695 = new_die (DW_TAG_formal_parameter, context_die, node);
16697 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
16699 case tcc_declaration:
16700 ultimate_origin = decl_ultimate_origin (node_or_origin);
16701 if (node || ultimate_origin)
16702 origin = ultimate_origin;
16703 if (origin != NULL)
16704 add_abstract_origin_attribute (parm_die, origin);
16705 else if (emit_name_p)
16706 add_name_and_src_coords_attributes (parm_die, node);
16708 || (! DECL_ABSTRACT (node_or_origin)
16709 && variably_modified_type_p (TREE_TYPE (node_or_origin),
16710 decl_function_context
16711 (node_or_origin))))
16713 tree type = TREE_TYPE (node_or_origin);
16714 if (decl_by_reference_p (node_or_origin))
16715 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
16718 add_type_attribute (parm_die, type,
16719 TREE_READONLY (node_or_origin),
16720 TREE_THIS_VOLATILE (node_or_origin),
16723 if (origin == NULL && DECL_ARTIFICIAL (node))
16724 add_AT_flag (parm_die, DW_AT_artificial, 1);
16726 if (node && node != origin)
16727 equate_decl_number_to_die (node, parm_die);
16728 if (! DECL_ABSTRACT (node_or_origin))
16729 add_location_or_const_value_attribute (parm_die, node_or_origin,
16730 node == NULL, DW_AT_location);
16735 /* We were called with some kind of a ..._TYPE node. */
16736 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
16740 gcc_unreachable ();
16746 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
16747 children DW_TAG_formal_parameter DIEs representing the arguments of the
16750 PARM_PACK must be a function parameter pack.
16751 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
16752 must point to the subsequent arguments of the function PACK_ARG belongs to.
16753 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
16754 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
16755 following the last one for which a DIE was generated. */
16758 gen_formal_parameter_pack_die (tree parm_pack,
16760 dw_die_ref subr_die,
16764 dw_die_ref parm_pack_die;
16766 gcc_assert (parm_pack
16767 && lang_hooks.function_parameter_pack_p (parm_pack)
16770 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
16771 add_src_coords_attributes (parm_pack_die, parm_pack);
16773 for (arg = pack_arg; arg; arg = DECL_CHAIN (arg))
16775 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
16778 gen_formal_parameter_die (arg, NULL,
16779 false /* Don't emit name attribute. */,
16784 return parm_pack_die;
16787 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
16788 at the end of an (ANSI prototyped) formal parameters list. */
16791 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
16793 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
16796 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
16797 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
16798 parameters as specified in some function type specification (except for
16799 those which appear as part of a function *definition*). */
16802 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
16805 tree formal_type = NULL;
16806 tree first_parm_type;
16809 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
16811 arg = DECL_ARGUMENTS (function_or_method_type);
16812 function_or_method_type = TREE_TYPE (function_or_method_type);
16817 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
16819 /* Make our first pass over the list of formal parameter types and output a
16820 DW_TAG_formal_parameter DIE for each one. */
16821 for (link = first_parm_type; link; )
16823 dw_die_ref parm_die;
16825 formal_type = TREE_VALUE (link);
16826 if (formal_type == void_type_node)
16829 /* Output a (nameless) DIE to represent the formal parameter itself. */
16830 parm_die = gen_formal_parameter_die (formal_type, NULL,
16831 true /* Emit name attribute. */,
16833 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
16834 && link == first_parm_type)
16836 add_AT_flag (parm_die, DW_AT_artificial, 1);
16837 if (dwarf_version >= 3 || !dwarf_strict)
16838 add_AT_die_ref (context_die, DW_AT_object_pointer, parm_die);
16840 else if (arg && DECL_ARTIFICIAL (arg))
16841 add_AT_flag (parm_die, DW_AT_artificial, 1);
16843 link = TREE_CHAIN (link);
16845 arg = DECL_CHAIN (arg);
16848 /* If this function type has an ellipsis, add a
16849 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
16850 if (formal_type != void_type_node)
16851 gen_unspecified_parameters_die (function_or_method_type, context_die);
16853 /* Make our second (and final) pass over the list of formal parameter types
16854 and output DIEs to represent those types (as necessary). */
16855 for (link = TYPE_ARG_TYPES (function_or_method_type);
16856 link && TREE_VALUE (link);
16857 link = TREE_CHAIN (link))
16858 gen_type_die (TREE_VALUE (link), context_die);
16861 /* We want to generate the DIE for TYPE so that we can generate the
16862 die for MEMBER, which has been defined; we will need to refer back
16863 to the member declaration nested within TYPE. If we're trying to
16864 generate minimal debug info for TYPE, processing TYPE won't do the
16865 trick; we need to attach the member declaration by hand. */
16868 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
16870 gen_type_die (type, context_die);
16872 /* If we're trying to avoid duplicate debug info, we may not have
16873 emitted the member decl for this function. Emit it now. */
16874 if (TYPE_STUB_DECL (type)
16875 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
16876 && ! lookup_decl_die (member))
16878 dw_die_ref type_die;
16879 gcc_assert (!decl_ultimate_origin (member));
16881 push_decl_scope (type);
16882 type_die = lookup_type_die_strip_naming_typedef (type);
16883 if (TREE_CODE (member) == FUNCTION_DECL)
16884 gen_subprogram_die (member, type_die);
16885 else if (TREE_CODE (member) == FIELD_DECL)
16887 /* Ignore the nameless fields that are used to skip bits but handle
16888 C++ anonymous unions and structs. */
16889 if (DECL_NAME (member) != NULL_TREE
16890 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
16891 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
16893 gen_type_die (member_declared_type (member), type_die);
16894 gen_field_die (member, type_die);
16898 gen_variable_die (member, NULL_TREE, type_die);
16904 /* Generate the DWARF2 info for the "abstract" instance of a function which we
16905 may later generate inlined and/or out-of-line instances of. */
16908 dwarf2out_abstract_function (tree decl)
16910 dw_die_ref old_die;
16914 htab_t old_decl_loc_table;
16915 htab_t old_cached_dw_loc_list_table;
16916 int old_call_site_count, old_tail_call_site_count;
16917 struct call_arg_loc_node *old_call_arg_locations;
16919 /* Make sure we have the actual abstract inline, not a clone. */
16920 decl = DECL_ORIGIN (decl);
16922 old_die = lookup_decl_die (decl);
16923 if (old_die && get_AT (old_die, DW_AT_inline))
16924 /* We've already generated the abstract instance. */
16927 /* We can be called while recursively when seeing block defining inlined subroutine
16928 DIE. Be sure to not clobber the outer location table nor use it or we would
16929 get locations in abstract instantces. */
16930 old_decl_loc_table = decl_loc_table;
16931 decl_loc_table = NULL;
16932 old_cached_dw_loc_list_table = cached_dw_loc_list_table;
16933 cached_dw_loc_list_table = NULL;
16934 old_call_arg_locations = call_arg_locations;
16935 call_arg_locations = NULL;
16936 old_call_site_count = call_site_count;
16937 call_site_count = -1;
16938 old_tail_call_site_count = tail_call_site_count;
16939 tail_call_site_count = -1;
16941 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
16942 we don't get confused by DECL_ABSTRACT. */
16943 if (debug_info_level > DINFO_LEVEL_TERSE)
16945 context = decl_class_context (decl);
16947 gen_type_die_for_member
16948 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die ());
16951 /* Pretend we've just finished compiling this function. */
16952 save_fn = current_function_decl;
16953 current_function_decl = decl;
16954 push_cfun (DECL_STRUCT_FUNCTION (decl));
16956 was_abstract = DECL_ABSTRACT (decl);
16957 set_decl_abstract_flags (decl, 1);
16958 dwarf2out_decl (decl);
16959 if (! was_abstract)
16960 set_decl_abstract_flags (decl, 0);
16962 current_function_decl = save_fn;
16963 decl_loc_table = old_decl_loc_table;
16964 cached_dw_loc_list_table = old_cached_dw_loc_list_table;
16965 call_arg_locations = old_call_arg_locations;
16966 call_site_count = old_call_site_count;
16967 tail_call_site_count = old_tail_call_site_count;
16971 /* Helper function of premark_used_types() which gets called through
16974 Marks the DIE of a given type in *SLOT as perennial, so it never gets
16975 marked as unused by prune_unused_types. */
16978 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
16983 type = (tree) *slot;
16984 die = lookup_type_die (type);
16986 die->die_perennial_p = 1;
16990 /* Helper function of premark_types_used_by_global_vars which gets called
16991 through htab_traverse.
16993 Marks the DIE of a given type in *SLOT as perennial, so it never gets
16994 marked as unused by prune_unused_types. The DIE of the type is marked
16995 only if the global variable using the type will actually be emitted. */
16998 premark_types_used_by_global_vars_helper (void **slot,
16999 void *data ATTRIBUTE_UNUSED)
17001 struct types_used_by_vars_entry *entry;
17004 entry = (struct types_used_by_vars_entry *) *slot;
17005 gcc_assert (entry->type != NULL
17006 && entry->var_decl != NULL);
17007 die = lookup_type_die (entry->type);
17010 /* Ask cgraph if the global variable really is to be emitted.
17011 If yes, then we'll keep the DIE of ENTRY->TYPE. */
17012 struct varpool_node *node = varpool_get_node (entry->var_decl);
17013 if (node && node->needed)
17015 die->die_perennial_p = 1;
17016 /* Keep the parent DIEs as well. */
17017 while ((die = die->die_parent) && die->die_perennial_p == 0)
17018 die->die_perennial_p = 1;
17024 /* Mark all members of used_types_hash as perennial. */
17027 premark_used_types (void)
17029 if (cfun && cfun->used_types_hash)
17030 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
17033 /* Mark all members of types_used_by_vars_entry as perennial. */
17036 premark_types_used_by_global_vars (void)
17038 if (types_used_by_vars_hash)
17039 htab_traverse (types_used_by_vars_hash,
17040 premark_types_used_by_global_vars_helper, NULL);
17043 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
17044 for CA_LOC call arg loc node. */
17047 gen_call_site_die (tree decl, dw_die_ref subr_die,
17048 struct call_arg_loc_node *ca_loc)
17050 dw_die_ref stmt_die = NULL, die;
17051 tree block = ca_loc->block;
17054 && block != DECL_INITIAL (decl)
17055 && TREE_CODE (block) == BLOCK)
17057 if (VEC_length (dw_die_ref, block_map) > BLOCK_NUMBER (block))
17058 stmt_die = VEC_index (dw_die_ref, block_map, BLOCK_NUMBER (block));
17061 block = BLOCK_SUPERCONTEXT (block);
17063 if (stmt_die == NULL)
17064 stmt_die = subr_die;
17065 die = new_die (DW_TAG_GNU_call_site, stmt_die, NULL_TREE);
17066 add_AT_lbl_id (die, DW_AT_low_pc, ca_loc->label);
17067 if (ca_loc->tail_call_p)
17068 add_AT_flag (die, DW_AT_GNU_tail_call, 1);
17069 if (ca_loc->symbol_ref)
17071 dw_die_ref tdie = lookup_decl_die (SYMBOL_REF_DECL (ca_loc->symbol_ref));
17073 add_AT_die_ref (die, DW_AT_abstract_origin, tdie);
17075 add_AT_addr (die, DW_AT_abstract_origin, ca_loc->symbol_ref);
17080 /* Generate a DIE to represent a declared function (either file-scope or
17084 gen_subprogram_die (tree decl, dw_die_ref context_die)
17086 tree origin = decl_ultimate_origin (decl);
17087 dw_die_ref subr_die;
17089 dw_die_ref old_die = lookup_decl_die (decl);
17090 int declaration = (current_function_decl != decl
17091 || class_or_namespace_scope_p (context_die));
17093 premark_used_types ();
17095 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
17096 started to generate the abstract instance of an inline, decided to output
17097 its containing class, and proceeded to emit the declaration of the inline
17098 from the member list for the class. If so, DECLARATION takes priority;
17099 we'll get back to the abstract instance when done with the class. */
17101 /* The class-scope declaration DIE must be the primary DIE. */
17102 if (origin && declaration && class_or_namespace_scope_p (context_die))
17105 gcc_assert (!old_die);
17108 /* Now that the C++ front end lazily declares artificial member fns, we
17109 might need to retrofit the declaration into its class. */
17110 if (!declaration && !origin && !old_die
17111 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
17112 && !class_or_namespace_scope_p (context_die)
17113 && debug_info_level > DINFO_LEVEL_TERSE)
17114 old_die = force_decl_die (decl);
17116 if (origin != NULL)
17118 gcc_assert (!declaration || local_scope_p (context_die));
17120 /* Fixup die_parent for the abstract instance of a nested
17121 inline function. */
17122 if (old_die && old_die->die_parent == NULL)
17123 add_child_die (context_die, old_die);
17125 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
17126 add_abstract_origin_attribute (subr_die, origin);
17127 /* This is where the actual code for a cloned function is.
17128 Let's emit linkage name attribute for it. This helps
17129 debuggers to e.g, set breakpoints into
17130 constructors/destructors when the user asks "break
17132 add_linkage_name (subr_die, decl);
17136 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
17137 struct dwarf_file_data * file_index = lookup_filename (s.file);
17139 if (!get_AT_flag (old_die, DW_AT_declaration)
17140 /* We can have a normal definition following an inline one in the
17141 case of redefinition of GNU C extern inlines.
17142 It seems reasonable to use AT_specification in this case. */
17143 && !get_AT (old_die, DW_AT_inline))
17145 /* Detect and ignore this case, where we are trying to output
17146 something we have already output. */
17150 /* If the definition comes from the same place as the declaration,
17151 maybe use the old DIE. We always want the DIE for this function
17152 that has the *_pc attributes to be under comp_unit_die so the
17153 debugger can find it. We also need to do this for abstract
17154 instances of inlines, since the spec requires the out-of-line copy
17155 to have the same parent. For local class methods, this doesn't
17156 apply; we just use the old DIE. */
17157 if ((is_cu_die (old_die->die_parent) || context_die == NULL)
17158 && (DECL_ARTIFICIAL (decl)
17159 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
17160 && (get_AT_unsigned (old_die, DW_AT_decl_line)
17161 == (unsigned) s.line))))
17163 subr_die = old_die;
17165 /* Clear out the declaration attribute and the formal parameters.
17166 Do not remove all children, because it is possible that this
17167 declaration die was forced using force_decl_die(). In such
17168 cases die that forced declaration die (e.g. TAG_imported_module)
17169 is one of the children that we do not want to remove. */
17170 remove_AT (subr_die, DW_AT_declaration);
17171 remove_AT (subr_die, DW_AT_object_pointer);
17172 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
17176 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
17177 add_AT_specification (subr_die, old_die);
17178 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
17179 add_AT_file (subr_die, DW_AT_decl_file, file_index);
17180 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
17181 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
17186 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
17188 if (TREE_PUBLIC (decl))
17189 add_AT_flag (subr_die, DW_AT_external, 1);
17191 add_name_and_src_coords_attributes (subr_die, decl);
17192 if (debug_info_level > DINFO_LEVEL_TERSE)
17194 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
17195 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
17196 0, 0, context_die);
17199 add_pure_or_virtual_attribute (subr_die, decl);
17200 if (DECL_ARTIFICIAL (decl))
17201 add_AT_flag (subr_die, DW_AT_artificial, 1);
17203 add_accessibility_attribute (subr_die, decl);
17208 if (!old_die || !get_AT (old_die, DW_AT_inline))
17210 add_AT_flag (subr_die, DW_AT_declaration, 1);
17212 /* If this is an explicit function declaration then generate
17213 a DW_AT_explicit attribute. */
17214 if (lang_hooks.decls.function_decl_explicit_p (decl)
17215 && (dwarf_version >= 3 || !dwarf_strict))
17216 add_AT_flag (subr_die, DW_AT_explicit, 1);
17218 /* The first time we see a member function, it is in the context of
17219 the class to which it belongs. We make sure of this by emitting
17220 the class first. The next time is the definition, which is
17221 handled above. The two may come from the same source text.
17223 Note that force_decl_die() forces function declaration die. It is
17224 later reused to represent definition. */
17225 equate_decl_number_to_die (decl, subr_die);
17228 else if (DECL_ABSTRACT (decl))
17230 if (DECL_DECLARED_INLINE_P (decl))
17232 if (cgraph_function_possibly_inlined_p (decl))
17233 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
17235 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
17239 if (cgraph_function_possibly_inlined_p (decl))
17240 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
17242 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
17245 if (DECL_DECLARED_INLINE_P (decl)
17246 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
17247 add_AT_flag (subr_die, DW_AT_artificial, 1);
17249 equate_decl_number_to_die (decl, subr_die);
17251 else if (!DECL_EXTERNAL (decl))
17253 HOST_WIDE_INT cfa_fb_offset;
17255 if (!old_die || !get_AT (old_die, DW_AT_inline))
17256 equate_decl_number_to_die (decl, subr_die);
17258 if (!flag_reorder_blocks_and_partition)
17260 dw_fde_ref fde = cfun->fde;
17261 if (fde->dw_fde_begin)
17263 /* We have already generated the labels. */
17264 add_AT_lbl_id (subr_die, DW_AT_low_pc, fde->dw_fde_begin);
17265 add_AT_lbl_id (subr_die, DW_AT_high_pc, fde->dw_fde_end);
17269 /* Create start/end labels and add the range. */
17270 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
17271 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
17272 current_function_funcdef_no);
17273 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
17274 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
17275 current_function_funcdef_no);
17276 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
17279 #if VMS_DEBUGGING_INFO
17280 /* HP OpenVMS Industry Standard 64: DWARF Extensions
17281 Section 2.3 Prologue and Epilogue Attributes:
17282 When a breakpoint is set on entry to a function, it is generally
17283 desirable for execution to be suspended, not on the very first
17284 instruction of the function, but rather at a point after the
17285 function's frame has been set up, after any language defined local
17286 declaration processing has been completed, and before execution of
17287 the first statement of the function begins. Debuggers generally
17288 cannot properly determine where this point is. Similarly for a
17289 breakpoint set on exit from a function. The prologue and epilogue
17290 attributes allow a compiler to communicate the location(s) to use. */
17293 if (fde->dw_fde_vms_end_prologue)
17294 add_AT_vms_delta (subr_die, DW_AT_HP_prologue,
17295 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue);
17297 if (fde->dw_fde_vms_begin_epilogue)
17298 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue,
17299 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue);
17303 add_pubname (decl, subr_die);
17307 /* Generate pubnames entries for the split function code ranges. */
17308 dw_fde_ref fde = cfun->fde;
17310 if (fde->dw_fde_second_begin)
17312 if (dwarf_version >= 3 || !dwarf_strict)
17314 /* We should use ranges for non-contiguous code section
17315 addresses. Use the actual code range for the initial
17316 section, since the HOT/COLD labels might precede an
17317 alignment offset. */
17318 bool range_list_added = false;
17319 add_ranges_by_labels (subr_die, fde->dw_fde_begin,
17320 fde->dw_fde_end, &range_list_added);
17321 add_ranges_by_labels (subr_die, fde->dw_fde_second_begin,
17322 fde->dw_fde_second_end,
17323 &range_list_added);
17324 add_pubname (decl, subr_die);
17325 if (range_list_added)
17330 /* There is no real support in DW2 for this .. so we make
17331 a work-around. First, emit the pub name for the segment
17332 containing the function label. Then make and emit a
17333 simplified subprogram DIE for the second segment with the
17334 name pre-fixed by __hot/cold_sect_of_. We use the same
17335 linkage name for the second die so that gdb will find both
17336 sections when given "b foo". */
17337 const char *name = NULL;
17338 tree decl_name = DECL_NAME (decl);
17339 dw_die_ref seg_die;
17341 /* Do the 'primary' section. */
17342 add_AT_lbl_id (subr_die, DW_AT_low_pc,
17343 fde->dw_fde_begin);
17344 add_AT_lbl_id (subr_die, DW_AT_high_pc,
17347 add_pubname (decl, subr_die);
17349 /* Build a minimal DIE for the secondary section. */
17350 seg_die = new_die (DW_TAG_subprogram,
17351 subr_die->die_parent, decl);
17353 if (TREE_PUBLIC (decl))
17354 add_AT_flag (seg_die, DW_AT_external, 1);
17356 if (decl_name != NULL
17357 && IDENTIFIER_POINTER (decl_name) != NULL)
17359 name = dwarf2_name (decl, 1);
17360 if (! DECL_ARTIFICIAL (decl))
17361 add_src_coords_attributes (seg_die, decl);
17363 add_linkage_name (seg_die, decl);
17365 gcc_assert (name != NULL);
17366 add_pure_or_virtual_attribute (seg_die, decl);
17367 if (DECL_ARTIFICIAL (decl))
17368 add_AT_flag (seg_die, DW_AT_artificial, 1);
17370 name = concat ("__second_sect_of_", name, NULL);
17371 add_AT_lbl_id (seg_die, DW_AT_low_pc,
17372 fde->dw_fde_second_begin);
17373 add_AT_lbl_id (seg_die, DW_AT_high_pc,
17374 fde->dw_fde_second_end);
17375 add_name_attribute (seg_die, name);
17376 add_pubname_string (name, seg_die);
17381 add_AT_lbl_id (subr_die, DW_AT_low_pc, fde->dw_fde_begin);
17382 add_AT_lbl_id (subr_die, DW_AT_high_pc, fde->dw_fde_end);
17383 add_pubname (decl, subr_die);
17387 #ifdef MIPS_DEBUGGING_INFO
17388 /* Add a reference to the FDE for this routine. */
17389 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, cfun->fde->fde_index);
17392 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
17394 /* We define the "frame base" as the function's CFA. This is more
17395 convenient for several reasons: (1) It's stable across the prologue
17396 and epilogue, which makes it better than just a frame pointer,
17397 (2) With dwarf3, there exists a one-byte encoding that allows us
17398 to reference the .debug_frame data by proxy, but failing that,
17399 (3) We can at least reuse the code inspection and interpretation
17400 code that determines the CFA position at various points in the
17402 if (dwarf_version >= 3)
17404 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
17405 add_AT_loc (subr_die, DW_AT_frame_base, op);
17409 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
17410 if (list->dw_loc_next)
17411 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
17413 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
17416 /* Compute a displacement from the "steady-state frame pointer" to
17417 the CFA. The former is what all stack slots and argument slots
17418 will reference in the rtl; the later is what we've told the
17419 debugger about. We'll need to adjust all frame_base references
17420 by this displacement. */
17421 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
17423 if (cfun->static_chain_decl)
17424 add_AT_location_description (subr_die, DW_AT_static_link,
17425 loc_list_from_tree (cfun->static_chain_decl, 2));
17428 /* Generate child dies for template paramaters. */
17429 if (debug_info_level > DINFO_LEVEL_TERSE)
17430 gen_generic_params_dies (decl);
17432 /* Now output descriptions of the arguments for this function. This gets
17433 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
17434 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
17435 `...' at the end of the formal parameter list. In order to find out if
17436 there was a trailing ellipsis or not, we must instead look at the type
17437 associated with the FUNCTION_DECL. This will be a node of type
17438 FUNCTION_TYPE. If the chain of type nodes hanging off of this
17439 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
17440 an ellipsis at the end. */
17442 /* In the case where we are describing a mere function declaration, all we
17443 need to do here (and all we *can* do here) is to describe the *types* of
17444 its formal parameters. */
17445 if (debug_info_level <= DINFO_LEVEL_TERSE)
17447 else if (declaration)
17448 gen_formal_types_die (decl, subr_die);
17451 /* Generate DIEs to represent all known formal parameters. */
17452 tree parm = DECL_ARGUMENTS (decl);
17453 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl);
17454 tree generic_decl_parm = generic_decl
17455 ? DECL_ARGUMENTS (generic_decl)
17458 /* Now we want to walk the list of parameters of the function and
17459 emit their relevant DIEs.
17461 We consider the case of DECL being an instance of a generic function
17462 as well as it being a normal function.
17464 If DECL is an instance of a generic function we walk the
17465 parameters of the generic function declaration _and_ the parameters of
17466 DECL itself. This is useful because we want to emit specific DIEs for
17467 function parameter packs and those are declared as part of the
17468 generic function declaration. In that particular case,
17469 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
17470 That DIE has children DIEs representing the set of arguments
17471 of the pack. Note that the set of pack arguments can be empty.
17472 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
17475 Otherwise, we just consider the parameters of DECL. */
17476 while (generic_decl_parm || parm)
17478 if (generic_decl_parm
17479 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
17480 gen_formal_parameter_pack_die (generic_decl_parm,
17485 dw_die_ref parm_die = gen_decl_die (parm, NULL, subr_die);
17487 if (parm == DECL_ARGUMENTS (decl)
17488 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
17490 && (dwarf_version >= 3 || !dwarf_strict))
17491 add_AT_die_ref (subr_die, DW_AT_object_pointer, parm_die);
17493 parm = DECL_CHAIN (parm);
17496 if (generic_decl_parm)
17497 generic_decl_parm = DECL_CHAIN (generic_decl_parm);
17500 /* Decide whether we need an unspecified_parameters DIE at the end.
17501 There are 2 more cases to do this for: 1) the ansi ... declaration -
17502 this is detectable when the end of the arg list is not a
17503 void_type_node 2) an unprototyped function declaration (not a
17504 definition). This just means that we have no info about the
17505 parameters at all. */
17506 if (prototype_p (TREE_TYPE (decl)))
17508 /* This is the prototyped case, check for.... */
17509 if (stdarg_p (TREE_TYPE (decl)))
17510 gen_unspecified_parameters_die (decl, subr_die);
17512 else if (DECL_INITIAL (decl) == NULL_TREE)
17513 gen_unspecified_parameters_die (decl, subr_die);
17516 /* Output Dwarf info for all of the stuff within the body of the function
17517 (if it has one - it may be just a declaration). */
17518 outer_scope = DECL_INITIAL (decl);
17520 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
17521 a function. This BLOCK actually represents the outermost binding contour
17522 for the function, i.e. the contour in which the function's formal
17523 parameters and labels get declared. Curiously, it appears that the front
17524 end doesn't actually put the PARM_DECL nodes for the current function onto
17525 the BLOCK_VARS list for this outer scope, but are strung off of the
17526 DECL_ARGUMENTS list for the function instead.
17528 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
17529 the LABEL_DECL nodes for the function however, and we output DWARF info
17530 for those in decls_for_scope. Just within the `outer_scope' there will be
17531 a BLOCK node representing the function's outermost pair of curly braces,
17532 and any blocks used for the base and member initializers of a C++
17533 constructor function. */
17534 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
17536 int call_site_note_count = 0;
17537 int tail_call_site_note_count = 0;
17539 /* Emit a DW_TAG_variable DIE for a named return value. */
17540 if (DECL_NAME (DECL_RESULT (decl)))
17541 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
17543 current_function_has_inlines = 0;
17544 decls_for_scope (outer_scope, subr_die, 0);
17546 if (call_arg_locations && !dwarf_strict)
17548 struct call_arg_loc_node *ca_loc;
17549 for (ca_loc = call_arg_locations; ca_loc; ca_loc = ca_loc->next)
17551 dw_die_ref die = NULL;
17552 rtx tloc = NULL_RTX, tlocc = NULL_RTX;
17555 for (arg = NOTE_VAR_LOCATION (ca_loc->call_arg_loc_note);
17556 arg; arg = next_arg)
17558 dw_loc_descr_ref reg, val;
17559 enum machine_mode mode = GET_MODE (XEXP (XEXP (arg, 0), 1));
17560 dw_die_ref cdie, tdie = NULL;
17562 next_arg = XEXP (arg, 1);
17563 if (REG_P (XEXP (XEXP (arg, 0), 0))
17565 && MEM_P (XEXP (XEXP (next_arg, 0), 0))
17566 && REG_P (XEXP (XEXP (XEXP (next_arg, 0), 0), 0))
17567 && REGNO (XEXP (XEXP (arg, 0), 0))
17568 == REGNO (XEXP (XEXP (XEXP (next_arg, 0), 0), 0)))
17569 next_arg = XEXP (next_arg, 1);
17570 if (mode == VOIDmode)
17572 mode = GET_MODE (XEXP (XEXP (arg, 0), 0));
17573 if (mode == VOIDmode)
17574 mode = GET_MODE (XEXP (arg, 0));
17576 if (mode == VOIDmode || mode == BLKmode)
17578 if (XEXP (XEXP (arg, 0), 0) == pc_rtx)
17580 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
17581 tloc = XEXP (XEXP (arg, 0), 1);
17584 else if (GET_CODE (XEXP (XEXP (arg, 0), 0)) == CLOBBER
17585 && XEXP (XEXP (XEXP (arg, 0), 0), 0) == pc_rtx)
17587 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
17588 tlocc = XEXP (XEXP (arg, 0), 1);
17592 if (REG_P (XEXP (XEXP (arg, 0), 0)))
17593 reg = reg_loc_descriptor (XEXP (XEXP (arg, 0), 0),
17594 VAR_INIT_STATUS_INITIALIZED);
17595 else if (MEM_P (XEXP (XEXP (arg, 0), 0)))
17597 rtx mem = XEXP (XEXP (arg, 0), 0);
17598 reg = mem_loc_descriptor (XEXP (mem, 0),
17599 get_address_mode (mem),
17601 VAR_INIT_STATUS_INITIALIZED);
17603 else if (GET_CODE (XEXP (XEXP (arg, 0), 0))
17604 == DEBUG_PARAMETER_REF)
17607 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg, 0), 0));
17608 tdie = lookup_decl_die (tdecl);
17615 && GET_CODE (XEXP (XEXP (arg, 0), 0))
17616 != DEBUG_PARAMETER_REF)
17618 val = mem_loc_descriptor (XEXP (XEXP (arg, 0), 1), mode,
17620 VAR_INIT_STATUS_INITIALIZED);
17624 die = gen_call_site_die (decl, subr_die, ca_loc);
17625 cdie = new_die (DW_TAG_GNU_call_site_parameter, die,
17628 add_AT_loc (cdie, DW_AT_location, reg);
17629 else if (tdie != NULL)
17630 add_AT_die_ref (cdie, DW_AT_abstract_origin, tdie);
17631 add_AT_loc (cdie, DW_AT_GNU_call_site_value, val);
17632 if (next_arg != XEXP (arg, 1))
17634 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 1));
17635 if (mode == VOIDmode)
17636 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 0));
17637 val = mem_loc_descriptor (XEXP (XEXP (XEXP (arg, 1),
17640 VAR_INIT_STATUS_INITIALIZED);
17642 add_AT_loc (cdie, DW_AT_GNU_call_site_data_value, val);
17646 && (ca_loc->symbol_ref || tloc))
17647 die = gen_call_site_die (decl, subr_die, ca_loc);
17648 if (die != NULL && (tloc != NULL_RTX || tlocc != NULL_RTX))
17650 dw_loc_descr_ref tval = NULL;
17652 if (tloc != NULL_RTX)
17653 tval = mem_loc_descriptor (tloc,
17654 GET_MODE (tloc) == VOIDmode
17655 ? Pmode : GET_MODE (tloc),
17657 VAR_INIT_STATUS_INITIALIZED);
17659 add_AT_loc (die, DW_AT_GNU_call_site_target, tval);
17660 else if (tlocc != NULL_RTX)
17662 tval = mem_loc_descriptor (tlocc,
17663 GET_MODE (tlocc) == VOIDmode
17664 ? Pmode : GET_MODE (tlocc),
17666 VAR_INIT_STATUS_INITIALIZED);
17668 add_AT_loc (die, DW_AT_GNU_call_site_target_clobbered,
17674 call_site_note_count++;
17675 if (ca_loc->tail_call_p)
17676 tail_call_site_note_count++;
17680 call_arg_locations = NULL;
17681 call_arg_loc_last = NULL;
17682 if (tail_call_site_count >= 0
17683 && tail_call_site_count == tail_call_site_note_count
17686 if (call_site_count >= 0
17687 && call_site_count == call_site_note_count)
17688 add_AT_flag (subr_die, DW_AT_GNU_all_call_sites, 1);
17690 add_AT_flag (subr_die, DW_AT_GNU_all_tail_call_sites, 1);
17692 call_site_count = -1;
17693 tail_call_site_count = -1;
17695 /* Add the calling convention attribute if requested. */
17696 add_calling_convention_attribute (subr_die, decl);
17700 /* Returns a hash value for X (which really is a die_struct). */
17703 common_block_die_table_hash (const void *x)
17705 const_dw_die_ref d = (const_dw_die_ref) x;
17706 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
17709 /* Return nonzero if decl_id and die_parent of die_struct X is the same
17710 as decl_id and die_parent of die_struct Y. */
17713 common_block_die_table_eq (const void *x, const void *y)
17715 const_dw_die_ref d = (const_dw_die_ref) x;
17716 const_dw_die_ref e = (const_dw_die_ref) y;
17717 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
17720 /* Generate a DIE to represent a declared data object.
17721 Either DECL or ORIGIN must be non-null. */
17724 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
17728 tree decl_or_origin = decl ? decl : origin;
17729 tree ultimate_origin;
17730 dw_die_ref var_die;
17731 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
17732 dw_die_ref origin_die;
17733 bool declaration = (DECL_EXTERNAL (decl_or_origin)
17734 || class_or_namespace_scope_p (context_die));
17735 bool specialization_p = false;
17737 ultimate_origin = decl_ultimate_origin (decl_or_origin);
17738 if (decl || ultimate_origin)
17739 origin = ultimate_origin;
17740 com_decl = fortran_common (decl_or_origin, &off);
17742 /* Symbol in common gets emitted as a child of the common block, in the form
17743 of a data member. */
17746 dw_die_ref com_die;
17747 dw_loc_list_ref loc;
17748 die_node com_die_arg;
17750 var_die = lookup_decl_die (decl_or_origin);
17753 if (get_AT (var_die, DW_AT_location) == NULL)
17755 loc = loc_list_from_tree (com_decl, off ? 1 : 2);
17760 /* Optimize the common case. */
17761 if (single_element_loc_list_p (loc)
17762 && loc->expr->dw_loc_opc == DW_OP_addr
17763 && loc->expr->dw_loc_next == NULL
17764 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
17766 loc->expr->dw_loc_oprnd1.v.val_addr
17767 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
17769 loc_list_plus_const (loc, off);
17771 add_AT_location_description (var_die, DW_AT_location, loc);
17772 remove_AT (var_die, DW_AT_declaration);
17778 if (common_block_die_table == NULL)
17779 common_block_die_table
17780 = htab_create_ggc (10, common_block_die_table_hash,
17781 common_block_die_table_eq, NULL);
17783 com_die_arg.decl_id = DECL_UID (com_decl);
17784 com_die_arg.die_parent = context_die;
17785 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
17786 loc = loc_list_from_tree (com_decl, 2);
17787 if (com_die == NULL)
17790 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
17793 com_die = new_die (DW_TAG_common_block, context_die, decl);
17794 add_name_and_src_coords_attributes (com_die, com_decl);
17797 add_AT_location_description (com_die, DW_AT_location, loc);
17798 /* Avoid sharing the same loc descriptor between
17799 DW_TAG_common_block and DW_TAG_variable. */
17800 loc = loc_list_from_tree (com_decl, 2);
17802 else if (DECL_EXTERNAL (decl))
17803 add_AT_flag (com_die, DW_AT_declaration, 1);
17804 add_pubname_string (cnam, com_die); /* ??? needed? */
17805 com_die->decl_id = DECL_UID (com_decl);
17806 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
17807 *slot = (void *) com_die;
17809 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
17811 add_AT_location_description (com_die, DW_AT_location, loc);
17812 loc = loc_list_from_tree (com_decl, 2);
17813 remove_AT (com_die, DW_AT_declaration);
17815 var_die = new_die (DW_TAG_variable, com_die, decl);
17816 add_name_and_src_coords_attributes (var_die, decl);
17817 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
17818 TREE_THIS_VOLATILE (decl), context_die);
17819 add_AT_flag (var_die, DW_AT_external, 1);
17824 /* Optimize the common case. */
17825 if (single_element_loc_list_p (loc)
17826 && loc->expr->dw_loc_opc == DW_OP_addr
17827 && loc->expr->dw_loc_next == NULL
17828 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
17829 loc->expr->dw_loc_oprnd1.v.val_addr
17830 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
17832 loc_list_plus_const (loc, off);
17834 add_AT_location_description (var_die, DW_AT_location, loc);
17836 else if (DECL_EXTERNAL (decl))
17837 add_AT_flag (var_die, DW_AT_declaration, 1);
17838 equate_decl_number_to_die (decl, var_die);
17842 /* If the compiler emitted a definition for the DECL declaration
17843 and if we already emitted a DIE for it, don't emit a second
17844 DIE for it again. Allow re-declarations of DECLs that are
17845 inside functions, though. */
17846 if (old_die && declaration && !local_scope_p (context_die))
17849 /* For static data members, the declaration in the class is supposed
17850 to have DW_TAG_member tag; the specification should still be
17851 DW_TAG_variable referencing the DW_TAG_member DIE. */
17852 if (declaration && class_scope_p (context_die))
17853 var_die = new_die (DW_TAG_member, context_die, decl);
17855 var_die = new_die (DW_TAG_variable, context_die, decl);
17858 if (origin != NULL)
17859 origin_die = add_abstract_origin_attribute (var_die, origin);
17861 /* Loop unrolling can create multiple blocks that refer to the same
17862 static variable, so we must test for the DW_AT_declaration flag.
17864 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
17865 copy decls and set the DECL_ABSTRACT flag on them instead of
17868 ??? Duplicated blocks have been rewritten to use .debug_ranges.
17870 ??? The declare_in_namespace support causes us to get two DIEs for one
17871 variable, both of which are declarations. We want to avoid considering
17872 one to be a specification, so we must test that this DIE is not a
17874 else if (old_die && TREE_STATIC (decl) && ! declaration
17875 && get_AT_flag (old_die, DW_AT_declaration) == 1)
17877 /* This is a definition of a C++ class level static. */
17878 add_AT_specification (var_die, old_die);
17879 specialization_p = true;
17880 if (DECL_NAME (decl))
17882 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
17883 struct dwarf_file_data * file_index = lookup_filename (s.file);
17885 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
17886 add_AT_file (var_die, DW_AT_decl_file, file_index);
17888 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
17889 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
17891 if (old_die->die_tag == DW_TAG_member)
17892 add_linkage_name (var_die, decl);
17896 add_name_and_src_coords_attributes (var_die, decl);
17898 if ((origin == NULL && !specialization_p)
17900 && !DECL_ABSTRACT (decl_or_origin)
17901 && variably_modified_type_p (TREE_TYPE (decl_or_origin),
17902 decl_function_context
17903 (decl_or_origin))))
17905 tree type = TREE_TYPE (decl_or_origin);
17907 if (decl_by_reference_p (decl_or_origin))
17908 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
17910 add_type_attribute (var_die, type, TREE_READONLY (decl_or_origin),
17911 TREE_THIS_VOLATILE (decl_or_origin), context_die);
17914 if (origin == NULL && !specialization_p)
17916 if (TREE_PUBLIC (decl))
17917 add_AT_flag (var_die, DW_AT_external, 1);
17919 if (DECL_ARTIFICIAL (decl))
17920 add_AT_flag (var_die, DW_AT_artificial, 1);
17922 add_accessibility_attribute (var_die, decl);
17926 add_AT_flag (var_die, DW_AT_declaration, 1);
17928 if (decl && (DECL_ABSTRACT (decl) || declaration || old_die == NULL))
17929 equate_decl_number_to_die (decl, var_die);
17932 && (! DECL_ABSTRACT (decl_or_origin)
17933 /* Local static vars are shared between all clones/inlines,
17934 so emit DW_AT_location on the abstract DIE if DECL_RTL is
17936 || (TREE_CODE (decl_or_origin) == VAR_DECL
17937 && TREE_STATIC (decl_or_origin)
17938 && DECL_RTL_SET_P (decl_or_origin)))
17939 /* When abstract origin already has DW_AT_location attribute, no need
17940 to add it again. */
17941 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
17943 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
17944 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
17945 defer_location (decl_or_origin, var_die);
17947 add_location_or_const_value_attribute (var_die, decl_or_origin,
17948 decl == NULL, DW_AT_location);
17949 add_pubname (decl_or_origin, var_die);
17952 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
17955 /* Generate a DIE to represent a named constant. */
17958 gen_const_die (tree decl, dw_die_ref context_die)
17960 dw_die_ref const_die;
17961 tree type = TREE_TYPE (decl);
17963 const_die = new_die (DW_TAG_constant, context_die, decl);
17964 add_name_and_src_coords_attributes (const_die, decl);
17965 add_type_attribute (const_die, type, 1, 0, context_die);
17966 if (TREE_PUBLIC (decl))
17967 add_AT_flag (const_die, DW_AT_external, 1);
17968 if (DECL_ARTIFICIAL (decl))
17969 add_AT_flag (const_die, DW_AT_artificial, 1);
17970 tree_add_const_value_attribute_for_decl (const_die, decl);
17973 /* Generate a DIE to represent a label identifier. */
17976 gen_label_die (tree decl, dw_die_ref context_die)
17978 tree origin = decl_ultimate_origin (decl);
17979 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
17981 char label[MAX_ARTIFICIAL_LABEL_BYTES];
17983 if (origin != NULL)
17984 add_abstract_origin_attribute (lbl_die, origin);
17986 add_name_and_src_coords_attributes (lbl_die, decl);
17988 if (DECL_ABSTRACT (decl))
17989 equate_decl_number_to_die (decl, lbl_die);
17992 insn = DECL_RTL_IF_SET (decl);
17994 /* Deleted labels are programmer specified labels which have been
17995 eliminated because of various optimizations. We still emit them
17996 here so that it is possible to put breakpoints on them. */
18000 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
18002 /* When optimization is enabled (via -O) some parts of the compiler
18003 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
18004 represent source-level labels which were explicitly declared by
18005 the user. This really shouldn't be happening though, so catch
18006 it if it ever does happen. */
18007 gcc_assert (!INSN_DELETED_P (insn));
18009 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
18010 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
18015 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
18016 attributes to the DIE for a block STMT, to describe where the inlined
18017 function was called from. This is similar to add_src_coords_attributes. */
18020 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
18022 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
18024 if (dwarf_version >= 3 || !dwarf_strict)
18026 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
18027 add_AT_unsigned (die, DW_AT_call_line, s.line);
18032 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
18033 Add low_pc and high_pc attributes to the DIE for a block STMT. */
18036 add_high_low_attributes (tree stmt, dw_die_ref die)
18038 char label[MAX_ARTIFICIAL_LABEL_BYTES];
18040 if (BLOCK_FRAGMENT_CHAIN (stmt)
18041 && (dwarf_version >= 3 || !dwarf_strict))
18045 if (inlined_function_outer_scope_p (stmt))
18047 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
18048 BLOCK_NUMBER (stmt));
18049 add_AT_lbl_id (die, DW_AT_entry_pc, label);
18052 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
18054 chain = BLOCK_FRAGMENT_CHAIN (stmt);
18057 add_ranges (chain);
18058 chain = BLOCK_FRAGMENT_CHAIN (chain);
18065 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
18066 BLOCK_NUMBER (stmt));
18067 add_AT_lbl_id (die, DW_AT_low_pc, label);
18068 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
18069 BLOCK_NUMBER (stmt));
18070 add_AT_lbl_id (die, DW_AT_high_pc, label);
18074 /* Generate a DIE for a lexical block. */
18077 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
18079 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
18081 if (call_arg_locations)
18083 if (VEC_length (dw_die_ref, block_map) <= BLOCK_NUMBER (stmt))
18084 VEC_safe_grow_cleared (dw_die_ref, heap, block_map,
18085 BLOCK_NUMBER (stmt) + 1);
18086 VEC_replace (dw_die_ref, block_map, BLOCK_NUMBER (stmt), stmt_die);
18089 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
18090 add_high_low_attributes (stmt, stmt_die);
18092 decls_for_scope (stmt, stmt_die, depth);
18095 /* Generate a DIE for an inlined subprogram. */
18098 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
18102 /* The instance of function that is effectively being inlined shall not
18104 gcc_assert (! BLOCK_ABSTRACT (stmt));
18106 decl = block_ultimate_origin (stmt);
18108 /* Emit info for the abstract instance first, if we haven't yet. We
18109 must emit this even if the block is abstract, otherwise when we
18110 emit the block below (or elsewhere), we may end up trying to emit
18111 a die whose origin die hasn't been emitted, and crashing. */
18112 dwarf2out_abstract_function (decl);
18114 if (! BLOCK_ABSTRACT (stmt))
18116 dw_die_ref subr_die
18117 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
18119 if (call_arg_locations)
18121 if (VEC_length (dw_die_ref, block_map) <= BLOCK_NUMBER (stmt))
18122 VEC_safe_grow_cleared (dw_die_ref, heap, block_map,
18123 BLOCK_NUMBER (stmt) + 1);
18124 VEC_replace (dw_die_ref, block_map, BLOCK_NUMBER (stmt), subr_die);
18126 add_abstract_origin_attribute (subr_die, decl);
18127 if (TREE_ASM_WRITTEN (stmt))
18128 add_high_low_attributes (stmt, subr_die);
18129 add_call_src_coords_attributes (stmt, subr_die);
18131 decls_for_scope (stmt, subr_die, depth);
18132 current_function_has_inlines = 1;
18136 /* Generate a DIE for a field in a record, or structure. */
18139 gen_field_die (tree decl, dw_die_ref context_die)
18141 dw_die_ref decl_die;
18143 if (TREE_TYPE (decl) == error_mark_node)
18146 decl_die = new_die (DW_TAG_member, context_die, decl);
18147 add_name_and_src_coords_attributes (decl_die, decl);
18148 add_type_attribute (decl_die, member_declared_type (decl),
18149 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
18152 if (DECL_BIT_FIELD_TYPE (decl))
18154 add_byte_size_attribute (decl_die, decl);
18155 add_bit_size_attribute (decl_die, decl);
18156 add_bit_offset_attribute (decl_die, decl);
18159 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
18160 add_data_member_location_attribute (decl_die, decl);
18162 if (DECL_ARTIFICIAL (decl))
18163 add_AT_flag (decl_die, DW_AT_artificial, 1);
18165 add_accessibility_attribute (decl_die, decl);
18167 /* Equate decl number to die, so that we can look up this decl later on. */
18168 equate_decl_number_to_die (decl, decl_die);
18172 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
18173 Use modified_type_die instead.
18174 We keep this code here just in case these types of DIEs may be needed to
18175 represent certain things in other languages (e.g. Pascal) someday. */
18178 gen_pointer_type_die (tree type, dw_die_ref context_die)
18181 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
18183 equate_type_number_to_die (type, ptr_die);
18184 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
18185 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
18188 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
18189 Use modified_type_die instead.
18190 We keep this code here just in case these types of DIEs may be needed to
18191 represent certain things in other languages (e.g. Pascal) someday. */
18194 gen_reference_type_die (tree type, dw_die_ref context_die)
18196 dw_die_ref ref_die, scope_die = scope_die_for (type, context_die);
18198 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
18199 ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type);
18201 ref_die = new_die (DW_TAG_reference_type, scope_die, type);
18203 equate_type_number_to_die (type, ref_die);
18204 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
18205 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
18209 /* Generate a DIE for a pointer to a member type. */
18212 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
18215 = new_die (DW_TAG_ptr_to_member_type,
18216 scope_die_for (type, context_die), type);
18218 equate_type_number_to_die (type, ptr_die);
18219 add_AT_die_ref (ptr_die, DW_AT_containing_type,
18220 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
18221 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
18224 typedef const char *dchar_p; /* For DEF_VEC_P. */
18225 DEF_VEC_P(dchar_p);
18226 DEF_VEC_ALLOC_P(dchar_p,heap);
18228 static char *producer_string;
18230 /* Return a heap allocated producer string including command line options
18231 if -grecord-gcc-switches. */
18234 gen_producer_string (void)
18237 VEC(dchar_p, heap) *switches = NULL;
18238 const char *language_string = lang_hooks.name;
18239 char *producer, *tail;
18241 size_t len = dwarf_record_gcc_switches ? 0 : 3;
18242 size_t plen = strlen (language_string) + 1 + strlen (version_string);
18244 for (j = 1; dwarf_record_gcc_switches && j < save_decoded_options_count; j++)
18245 switch (save_decoded_options[j].opt_index)
18252 case OPT_auxbase_strip:
18261 case OPT_SPECIAL_unknown:
18262 case OPT_SPECIAL_ignore:
18263 case OPT_SPECIAL_program_name:
18264 case OPT_SPECIAL_input_file:
18265 case OPT_grecord_gcc_switches:
18266 case OPT_gno_record_gcc_switches:
18267 case OPT__output_pch_:
18268 case OPT_fdiagnostics_show_location_:
18269 case OPT_fdiagnostics_show_option:
18270 case OPT_fverbose_asm:
18272 case OPT__sysroot_:
18274 case OPT_nostdinc__:
18275 /* Ignore these. */
18278 gcc_checking_assert (save_decoded_options[j].canonical_option[0][0]
18280 switch (save_decoded_options[j].canonical_option[0][1])
18287 if (strncmp (save_decoded_options[j].canonical_option[0] + 2,
18294 VEC_safe_push (dchar_p, heap, switches,
18295 save_decoded_options[j].orig_option_with_args_text);
18296 len += strlen (save_decoded_options[j].orig_option_with_args_text) + 1;
18300 producer = XNEWVEC (char, plen + 1 + len + 1);
18302 sprintf (tail, "%s %s", language_string, version_string);
18305 if (!dwarf_record_gcc_switches)
18307 #ifdef MIPS_DEBUGGING_INFO
18308 /* The MIPS/SGI compilers place the 'cc' command line options in the
18309 producer string. The SGI debugger looks for -g, -g1, -g2, or -g3;
18310 if they do not appear in the producer string, the debugger reaches
18311 the conclusion that the object file is stripped and has no debugging
18312 information. To get the MIPS/SGI debugger to believe that there is
18313 debugging information in the object file, we add a -g to the producer
18315 if (debug_info_level > DINFO_LEVEL_TERSE)
18317 memcpy (tail, " -g", 3);
18323 FOR_EACH_VEC_ELT (dchar_p, switches, j, p)
18327 memcpy (tail + 1, p, len);
18332 VEC_free (dchar_p, heap, switches);
18336 /* Generate the DIE for the compilation unit. */
18339 gen_compile_unit_die (const char *filename)
18342 const char *language_string = lang_hooks.name;
18345 die = new_die (DW_TAG_compile_unit, NULL, NULL);
18349 add_name_attribute (die, filename);
18350 /* Don't add cwd for <built-in>. */
18351 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
18352 add_comp_dir_attribute (die);
18355 if (producer_string == NULL)
18356 producer_string = gen_producer_string ();
18357 add_AT_string (die, DW_AT_producer, producer_string);
18359 /* If our producer is LTO try to figure out a common language to use
18360 from the global list of translation units. */
18361 if (strcmp (language_string, "GNU GIMPLE") == 0)
18365 const char *common_lang = NULL;
18367 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
18369 if (!TRANSLATION_UNIT_LANGUAGE (t))
18372 common_lang = TRANSLATION_UNIT_LANGUAGE (t);
18373 else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
18375 else if (strncmp (common_lang, "GNU C", 5) == 0
18376 && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
18377 /* Mixing C and C++ is ok, use C++ in that case. */
18378 common_lang = "GNU C++";
18381 /* Fall back to C. */
18382 common_lang = NULL;
18388 language_string = common_lang;
18391 language = DW_LANG_C89;
18392 if (strcmp (language_string, "GNU C++") == 0)
18393 language = DW_LANG_C_plus_plus;
18394 else if (strcmp (language_string, "GNU F77") == 0)
18395 language = DW_LANG_Fortran77;
18396 else if (strcmp (language_string, "GNU Pascal") == 0)
18397 language = DW_LANG_Pascal83;
18398 else if (dwarf_version >= 3 || !dwarf_strict)
18400 if (strcmp (language_string, "GNU Ada") == 0)
18401 language = DW_LANG_Ada95;
18402 else if (strcmp (language_string, "GNU Fortran") == 0)
18403 language = DW_LANG_Fortran95;
18404 else if (strcmp (language_string, "GNU Java") == 0)
18405 language = DW_LANG_Java;
18406 else if (strcmp (language_string, "GNU Objective-C") == 0)
18407 language = DW_LANG_ObjC;
18408 else if (strcmp (language_string, "GNU Objective-C++") == 0)
18409 language = DW_LANG_ObjC_plus_plus;
18412 add_AT_unsigned (die, DW_AT_language, language);
18416 case DW_LANG_Fortran77:
18417 case DW_LANG_Fortran90:
18418 case DW_LANG_Fortran95:
18419 /* Fortran has case insensitive identifiers and the front-end
18420 lowercases everything. */
18421 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case);
18424 /* The default DW_ID_case_sensitive doesn't need to be specified. */
18430 /* Generate the DIE for a base class. */
18433 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
18435 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
18437 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
18438 add_data_member_location_attribute (die, binfo);
18440 if (BINFO_VIRTUAL_P (binfo))
18441 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
18443 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
18444 children, otherwise the default is DW_ACCESS_public. In DWARF2
18445 the default has always been DW_ACCESS_private. */
18446 if (access == access_public_node)
18448 if (dwarf_version == 2
18449 || context_die->die_tag == DW_TAG_class_type)
18450 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
18452 else if (access == access_protected_node)
18453 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
18454 else if (dwarf_version > 2
18455 && context_die->die_tag != DW_TAG_class_type)
18456 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
18459 /* Generate a DIE for a class member. */
18462 gen_member_die (tree type, dw_die_ref context_die)
18465 tree binfo = TYPE_BINFO (type);
18468 /* If this is not an incomplete type, output descriptions of each of its
18469 members. Note that as we output the DIEs necessary to represent the
18470 members of this record or union type, we will also be trying to output
18471 DIEs to represent the *types* of those members. However the `type'
18472 function (above) will specifically avoid generating type DIEs for member
18473 types *within* the list of member DIEs for this (containing) type except
18474 for those types (of members) which are explicitly marked as also being
18475 members of this (containing) type themselves. The g++ front- end can
18476 force any given type to be treated as a member of some other (containing)
18477 type by setting the TYPE_CONTEXT of the given (member) type to point to
18478 the TREE node representing the appropriate (containing) type. */
18480 /* First output info about the base classes. */
18483 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
18487 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
18488 gen_inheritance_die (base,
18489 (accesses ? VEC_index (tree, accesses, i)
18490 : access_public_node), context_die);
18493 /* Now output info about the data members and type members. */
18494 for (member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
18496 /* If we thought we were generating minimal debug info for TYPE
18497 and then changed our minds, some of the member declarations
18498 may have already been defined. Don't define them again, but
18499 do put them in the right order. */
18501 child = lookup_decl_die (member);
18503 splice_child_die (context_die, child);
18505 gen_decl_die (member, NULL, context_die);
18508 /* Now output info about the function members (if any). */
18509 for (member = TYPE_METHODS (type); member; member = DECL_CHAIN (member))
18511 /* Don't include clones in the member list. */
18512 if (DECL_ABSTRACT_ORIGIN (member))
18515 child = lookup_decl_die (member);
18517 splice_child_die (context_die, child);
18519 gen_decl_die (member, NULL, context_die);
18523 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
18524 is set, we pretend that the type was never defined, so we only get the
18525 member DIEs needed by later specification DIEs. */
18528 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
18529 enum debug_info_usage usage)
18531 dw_die_ref type_die = lookup_type_die (type);
18532 dw_die_ref scope_die = 0;
18534 int complete = (TYPE_SIZE (type)
18535 && (! TYPE_STUB_DECL (type)
18536 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
18537 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
18538 complete = complete && should_emit_struct_debug (type, usage);
18540 if (type_die && ! complete)
18543 if (TYPE_CONTEXT (type) != NULL_TREE
18544 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
18545 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
18548 scope_die = scope_die_for (type, context_die);
18550 if (! type_die || (nested && is_cu_die (scope_die)))
18551 /* First occurrence of type or toplevel definition of nested class. */
18553 dw_die_ref old_die = type_die;
18555 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
18556 ? record_type_tag (type) : DW_TAG_union_type,
18558 equate_type_number_to_die (type, type_die);
18560 add_AT_specification (type_die, old_die);
18563 add_name_attribute (type_die, type_tag (type));
18564 add_gnat_descriptive_type_attribute (type_die, type, context_die);
18565 if (TYPE_ARTIFICIAL (type))
18566 add_AT_flag (type_die, DW_AT_artificial, 1);
18570 remove_AT (type_die, DW_AT_declaration);
18572 /* Generate child dies for template paramaters. */
18573 if (debug_info_level > DINFO_LEVEL_TERSE
18574 && COMPLETE_TYPE_P (type))
18575 schedule_generic_params_dies_gen (type);
18577 /* If this type has been completed, then give it a byte_size attribute and
18578 then give a list of members. */
18579 if (complete && !ns_decl)
18581 /* Prevent infinite recursion in cases where the type of some member of
18582 this type is expressed in terms of this type itself. */
18583 TREE_ASM_WRITTEN (type) = 1;
18584 add_byte_size_attribute (type_die, type);
18585 if (TYPE_STUB_DECL (type) != NULL_TREE)
18587 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
18588 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
18591 /* If the first reference to this type was as the return type of an
18592 inline function, then it may not have a parent. Fix this now. */
18593 if (type_die->die_parent == NULL)
18594 add_child_die (scope_die, type_die);
18596 push_decl_scope (type);
18597 gen_member_die (type, type_die);
18600 /* GNU extension: Record what type our vtable lives in. */
18601 if (TYPE_VFIELD (type))
18603 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
18605 gen_type_die (vtype, context_die);
18606 add_AT_die_ref (type_die, DW_AT_containing_type,
18607 lookup_type_die (vtype));
18612 add_AT_flag (type_die, DW_AT_declaration, 1);
18614 /* We don't need to do this for function-local types. */
18615 if (TYPE_STUB_DECL (type)
18616 && ! decl_function_context (TYPE_STUB_DECL (type)))
18617 VEC_safe_push (tree, gc, incomplete_types, type);
18620 if (get_AT (type_die, DW_AT_name))
18621 add_pubtype (type, type_die);
18624 /* Generate a DIE for a subroutine _type_. */
18627 gen_subroutine_type_die (tree type, dw_die_ref context_die)
18629 tree return_type = TREE_TYPE (type);
18630 dw_die_ref subr_die
18631 = new_die (DW_TAG_subroutine_type,
18632 scope_die_for (type, context_die), type);
18634 equate_type_number_to_die (type, subr_die);
18635 add_prototyped_attribute (subr_die, type);
18636 add_type_attribute (subr_die, return_type, 0, 0, context_die);
18637 gen_formal_types_die (type, subr_die);
18639 if (get_AT (subr_die, DW_AT_name))
18640 add_pubtype (type, subr_die);
18643 /* Generate a DIE for a type definition. */
18646 gen_typedef_die (tree decl, dw_die_ref context_die)
18648 dw_die_ref type_die;
18651 if (TREE_ASM_WRITTEN (decl))
18654 TREE_ASM_WRITTEN (decl) = 1;
18655 type_die = new_die (DW_TAG_typedef, context_die, decl);
18656 origin = decl_ultimate_origin (decl);
18657 if (origin != NULL)
18658 add_abstract_origin_attribute (type_die, origin);
18663 add_name_and_src_coords_attributes (type_die, decl);
18664 if (DECL_ORIGINAL_TYPE (decl))
18666 type = DECL_ORIGINAL_TYPE (decl);
18668 gcc_assert (type != TREE_TYPE (decl));
18669 equate_type_number_to_die (TREE_TYPE (decl), type_die);
18673 type = TREE_TYPE (decl);
18675 if (is_naming_typedef_decl (TYPE_NAME (type)))
18677 /* Here, we are in the case of decl being a typedef naming
18678 an anonymous type, e.g:
18679 typedef struct {...} foo;
18680 In that case TREE_TYPE (decl) is not a typedef variant
18681 type and TYPE_NAME of the anonymous type is set to the
18682 TYPE_DECL of the typedef. This construct is emitted by
18685 TYPE is the anonymous struct named by the typedef
18686 DECL. As we need the DW_AT_type attribute of the
18687 DW_TAG_typedef to point to the DIE of TYPE, let's
18688 generate that DIE right away. add_type_attribute
18689 called below will then pick (via lookup_type_die) that
18690 anonymous struct DIE. */
18691 if (!TREE_ASM_WRITTEN (type))
18692 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE);
18694 /* This is a GNU Extension. We are adding a
18695 DW_AT_linkage_name attribute to the DIE of the
18696 anonymous struct TYPE. The value of that attribute
18697 is the name of the typedef decl naming the anonymous
18698 struct. This greatly eases the work of consumers of
18699 this debug info. */
18700 add_linkage_attr (lookup_type_die (type), decl);
18704 add_type_attribute (type_die, type, TREE_READONLY (decl),
18705 TREE_THIS_VOLATILE (decl), context_die);
18707 if (is_naming_typedef_decl (decl))
18708 /* We want that all subsequent calls to lookup_type_die with
18709 TYPE in argument yield the DW_TAG_typedef we have just
18711 equate_type_number_to_die (type, type_die);
18713 add_accessibility_attribute (type_die, decl);
18716 if (DECL_ABSTRACT (decl))
18717 equate_decl_number_to_die (decl, type_die);
18719 if (get_AT (type_die, DW_AT_name))
18720 add_pubtype (decl, type_die);
18723 /* Generate a DIE for a struct, class, enum or union type. */
18726 gen_tagged_type_die (tree type,
18727 dw_die_ref context_die,
18728 enum debug_info_usage usage)
18732 if (type == NULL_TREE
18733 || !is_tagged_type (type))
18736 /* If this is a nested type whose containing class hasn't been written
18737 out yet, writing it out will cover this one, too. This does not apply
18738 to instantiations of member class templates; they need to be added to
18739 the containing class as they are generated. FIXME: This hurts the
18740 idea of combining type decls from multiple TUs, since we can't predict
18741 what set of template instantiations we'll get. */
18742 if (TYPE_CONTEXT (type)
18743 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
18744 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
18746 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
18748 if (TREE_ASM_WRITTEN (type))
18751 /* If that failed, attach ourselves to the stub. */
18752 push_decl_scope (TYPE_CONTEXT (type));
18753 context_die = lookup_type_die (TYPE_CONTEXT (type));
18756 else if (TYPE_CONTEXT (type) != NULL_TREE
18757 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
18759 /* If this type is local to a function that hasn't been written
18760 out yet, use a NULL context for now; it will be fixed up in
18761 decls_for_scope. */
18762 context_die = lookup_decl_die (TYPE_CONTEXT (type));
18763 /* A declaration DIE doesn't count; nested types need to go in the
18765 if (context_die && is_declaration_die (context_die))
18766 context_die = NULL;
18771 context_die = declare_in_namespace (type, context_die);
18775 if (TREE_CODE (type) == ENUMERAL_TYPE)
18777 /* This might have been written out by the call to
18778 declare_in_namespace. */
18779 if (!TREE_ASM_WRITTEN (type))
18780 gen_enumeration_type_die (type, context_die);
18783 gen_struct_or_union_type_die (type, context_die, usage);
18788 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
18789 it up if it is ever completed. gen_*_type_die will set it for us
18790 when appropriate. */
18793 /* Generate a type description DIE. */
18796 gen_type_die_with_usage (tree type, dw_die_ref context_die,
18797 enum debug_info_usage usage)
18799 struct array_descr_info info;
18801 if (type == NULL_TREE || type == error_mark_node)
18804 if (TYPE_NAME (type) != NULL_TREE
18805 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
18806 && is_redundant_typedef (TYPE_NAME (type))
18807 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
18808 /* The DECL of this type is a typedef we don't want to emit debug
18809 info for but we want debug info for its underlying typedef.
18810 This can happen for e.g, the injected-class-name of a C++
18812 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
18814 /* If TYPE is a typedef type variant, let's generate debug info
18815 for the parent typedef which TYPE is a type of. */
18816 if (typedef_variant_p (type))
18818 if (TREE_ASM_WRITTEN (type))
18821 /* Prevent broken recursion; we can't hand off to the same type. */
18822 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
18824 /* Use the DIE of the containing namespace as the parent DIE of
18825 the type description DIE we want to generate. */
18826 if (DECL_CONTEXT (TYPE_NAME (type))
18827 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
18828 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
18830 TREE_ASM_WRITTEN (type) = 1;
18832 gen_decl_die (TYPE_NAME (type), NULL, context_die);
18836 /* If type is an anonymous tagged type named by a typedef, let's
18837 generate debug info for the typedef. */
18838 if (is_naming_typedef_decl (TYPE_NAME (type)))
18840 /* Use the DIE of the containing namespace as the parent DIE of
18841 the type description DIE we want to generate. */
18842 if (DECL_CONTEXT (TYPE_NAME (type))
18843 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
18844 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
18846 gen_decl_die (TYPE_NAME (type), NULL, context_die);
18850 /* If this is an array type with hidden descriptor, handle it first. */
18851 if (!TREE_ASM_WRITTEN (type)
18852 && lang_hooks.types.get_array_descr_info
18853 && lang_hooks.types.get_array_descr_info (type, &info)
18854 && (dwarf_version >= 3 || !dwarf_strict))
18856 gen_descr_array_type_die (type, &info, context_die);
18857 TREE_ASM_WRITTEN (type) = 1;
18861 /* We are going to output a DIE to represent the unqualified version
18862 of this type (i.e. without any const or volatile qualifiers) so
18863 get the main variant (i.e. the unqualified version) of this type
18864 now. (Vectors are special because the debugging info is in the
18865 cloned type itself). */
18866 if (TREE_CODE (type) != VECTOR_TYPE)
18867 type = type_main_variant (type);
18869 if (TREE_ASM_WRITTEN (type))
18872 switch (TREE_CODE (type))
18878 case REFERENCE_TYPE:
18879 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
18880 ensures that the gen_type_die recursion will terminate even if the
18881 type is recursive. Recursive types are possible in Ada. */
18882 /* ??? We could perhaps do this for all types before the switch
18884 TREE_ASM_WRITTEN (type) = 1;
18886 /* For these types, all that is required is that we output a DIE (or a
18887 set of DIEs) to represent the "basis" type. */
18888 gen_type_die_with_usage (TREE_TYPE (type), context_die,
18889 DINFO_USAGE_IND_USE);
18893 /* This code is used for C++ pointer-to-data-member types.
18894 Output a description of the relevant class type. */
18895 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
18896 DINFO_USAGE_IND_USE);
18898 /* Output a description of the type of the object pointed to. */
18899 gen_type_die_with_usage (TREE_TYPE (type), context_die,
18900 DINFO_USAGE_IND_USE);
18902 /* Now output a DIE to represent this pointer-to-data-member type
18904 gen_ptr_to_mbr_type_die (type, context_die);
18907 case FUNCTION_TYPE:
18908 /* Force out return type (in case it wasn't forced out already). */
18909 gen_type_die_with_usage (TREE_TYPE (type), context_die,
18910 DINFO_USAGE_DIR_USE);
18911 gen_subroutine_type_die (type, context_die);
18915 /* Force out return type (in case it wasn't forced out already). */
18916 gen_type_die_with_usage (TREE_TYPE (type), context_die,
18917 DINFO_USAGE_DIR_USE);
18918 gen_subroutine_type_die (type, context_die);
18922 gen_array_type_die (type, context_die);
18926 gen_array_type_die (type, context_die);
18929 case ENUMERAL_TYPE:
18932 case QUAL_UNION_TYPE:
18933 gen_tagged_type_die (type, context_die, usage);
18939 case FIXED_POINT_TYPE:
18942 /* No DIEs needed for fundamental types. */
18947 /* Just use DW_TAG_unspecified_type. */
18949 dw_die_ref type_die = lookup_type_die (type);
18950 if (type_die == NULL)
18952 tree name = TYPE_NAME (type);
18953 if (TREE_CODE (name) == TYPE_DECL)
18954 name = DECL_NAME (name);
18955 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die (), type);
18956 add_name_attribute (type_die, IDENTIFIER_POINTER (name));
18957 equate_type_number_to_die (type, type_die);
18963 gcc_unreachable ();
18966 TREE_ASM_WRITTEN (type) = 1;
18970 gen_type_die (tree type, dw_die_ref context_die)
18972 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
18975 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
18976 things which are local to the given block. */
18979 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
18981 int must_output_die = 0;
18984 /* Ignore blocks that are NULL. */
18985 if (stmt == NULL_TREE)
18988 inlined_func = inlined_function_outer_scope_p (stmt);
18990 /* If the block is one fragment of a non-contiguous block, do not
18991 process the variables, since they will have been done by the
18992 origin block. Do process subblocks. */
18993 if (BLOCK_FRAGMENT_ORIGIN (stmt))
18997 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
18998 gen_block_die (sub, context_die, depth + 1);
19003 /* Determine if we need to output any Dwarf DIEs at all to represent this
19006 /* The outer scopes for inlinings *must* always be represented. We
19007 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
19008 must_output_die = 1;
19011 /* Determine if this block directly contains any "significant"
19012 local declarations which we will need to output DIEs for. */
19013 if (debug_info_level > DINFO_LEVEL_TERSE)
19014 /* We are not in terse mode so *any* local declaration counts
19015 as being a "significant" one. */
19016 must_output_die = ((BLOCK_VARS (stmt) != NULL
19017 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
19018 && (TREE_USED (stmt)
19019 || TREE_ASM_WRITTEN (stmt)
19020 || BLOCK_ABSTRACT (stmt)));
19021 else if ((TREE_USED (stmt)
19022 || TREE_ASM_WRITTEN (stmt)
19023 || BLOCK_ABSTRACT (stmt))
19024 && !dwarf2out_ignore_block (stmt))
19025 must_output_die = 1;
19028 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
19029 DIE for any block which contains no significant local declarations at
19030 all. Rather, in such cases we just call `decls_for_scope' so that any
19031 needed Dwarf info for any sub-blocks will get properly generated. Note
19032 that in terse mode, our definition of what constitutes a "significant"
19033 local declaration gets restricted to include only inlined function
19034 instances and local (nested) function definitions. */
19035 if (must_output_die)
19039 /* If STMT block is abstract, that means we have been called
19040 indirectly from dwarf2out_abstract_function.
19041 That function rightfully marks the descendent blocks (of
19042 the abstract function it is dealing with) as being abstract,
19043 precisely to prevent us from emitting any
19044 DW_TAG_inlined_subroutine DIE as a descendent
19045 of an abstract function instance. So in that case, we should
19046 not call gen_inlined_subroutine_die.
19048 Later though, when cgraph asks dwarf2out to emit info
19049 for the concrete instance of the function decl into which
19050 the concrete instance of STMT got inlined, the later will lead
19051 to the generation of a DW_TAG_inlined_subroutine DIE. */
19052 if (! BLOCK_ABSTRACT (stmt))
19053 gen_inlined_subroutine_die (stmt, context_die, depth);
19056 gen_lexical_block_die (stmt, context_die, depth);
19059 decls_for_scope (stmt, context_die, depth);
19062 /* Process variable DECL (or variable with origin ORIGIN) within
19063 block STMT and add it to CONTEXT_DIE. */
19065 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
19068 tree decl_or_origin = decl ? decl : origin;
19070 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
19071 die = lookup_decl_die (decl_or_origin);
19072 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
19073 && TYPE_DECL_IS_STUB (decl_or_origin))
19074 die = lookup_type_die (TREE_TYPE (decl_or_origin));
19078 if (die != NULL && die->die_parent == NULL)
19079 add_child_die (context_die, die);
19080 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
19081 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
19082 stmt, context_die);
19084 gen_decl_die (decl, origin, context_die);
19087 /* Generate all of the decls declared within a given scope and (recursively)
19088 all of its sub-blocks. */
19091 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
19097 /* Ignore NULL blocks. */
19098 if (stmt == NULL_TREE)
19101 /* Output the DIEs to represent all of the data objects and typedefs
19102 declared directly within this block but not within any nested
19103 sub-blocks. Also, nested function and tag DIEs have been
19104 generated with a parent of NULL; fix that up now. */
19105 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = DECL_CHAIN (decl))
19106 process_scope_var (stmt, decl, NULL_TREE, context_die);
19107 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
19108 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
19111 /* If we're at -g1, we're not interested in subblocks. */
19112 if (debug_info_level <= DINFO_LEVEL_TERSE)
19115 /* Output the DIEs to represent all sub-blocks (and the items declared
19116 therein) of this block. */
19117 for (subblocks = BLOCK_SUBBLOCKS (stmt);
19119 subblocks = BLOCK_CHAIN (subblocks))
19120 gen_block_die (subblocks, context_die, depth + 1);
19123 /* Is this a typedef we can avoid emitting? */
19126 is_redundant_typedef (const_tree decl)
19128 if (TYPE_DECL_IS_STUB (decl))
19131 if (DECL_ARTIFICIAL (decl)
19132 && DECL_CONTEXT (decl)
19133 && is_tagged_type (DECL_CONTEXT (decl))
19134 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
19135 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
19136 /* Also ignore the artificial member typedef for the class name. */
19142 /* Return TRUE if TYPE is a typedef that names a type for linkage
19143 purposes. This kind of typedefs is produced by the C++ FE for
19146 typedef struct {...} foo;
19148 In that case, there is no typedef variant type produced for foo.
19149 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
19153 is_naming_typedef_decl (const_tree decl)
19155 if (decl == NULL_TREE
19156 || TREE_CODE (decl) != TYPE_DECL
19157 || !is_tagged_type (TREE_TYPE (decl))
19158 || DECL_IS_BUILTIN (decl)
19159 || is_redundant_typedef (decl)
19160 /* It looks like Ada produces TYPE_DECLs that are very similar
19161 to C++ naming typedefs but that have different
19162 semantics. Let's be specific to c++ for now. */
19166 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE
19167 && TYPE_NAME (TREE_TYPE (decl)) == decl
19168 && (TYPE_STUB_DECL (TREE_TYPE (decl))
19169 != TYPE_NAME (TREE_TYPE (decl))));
19172 /* Returns the DIE for a context. */
19174 static inline dw_die_ref
19175 get_context_die (tree context)
19179 /* Find die that represents this context. */
19180 if (TYPE_P (context))
19182 context = TYPE_MAIN_VARIANT (context);
19183 return strip_naming_typedef (context, force_type_die (context));
19186 return force_decl_die (context);
19188 return comp_unit_die ();
19191 /* Returns the DIE for decl. A DIE will always be returned. */
19194 force_decl_die (tree decl)
19196 dw_die_ref decl_die;
19197 unsigned saved_external_flag;
19198 tree save_fn = NULL_TREE;
19199 decl_die = lookup_decl_die (decl);
19202 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
19204 decl_die = lookup_decl_die (decl);
19208 switch (TREE_CODE (decl))
19210 case FUNCTION_DECL:
19211 /* Clear current_function_decl, so that gen_subprogram_die thinks
19212 that this is a declaration. At this point, we just want to force
19213 declaration die. */
19214 save_fn = current_function_decl;
19215 current_function_decl = NULL_TREE;
19216 gen_subprogram_die (decl, context_die);
19217 current_function_decl = save_fn;
19221 /* Set external flag to force declaration die. Restore it after
19222 gen_decl_die() call. */
19223 saved_external_flag = DECL_EXTERNAL (decl);
19224 DECL_EXTERNAL (decl) = 1;
19225 gen_decl_die (decl, NULL, context_die);
19226 DECL_EXTERNAL (decl) = saved_external_flag;
19229 case NAMESPACE_DECL:
19230 if (dwarf_version >= 3 || !dwarf_strict)
19231 dwarf2out_decl (decl);
19233 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
19234 decl_die = comp_unit_die ();
19237 case TRANSLATION_UNIT_DECL:
19238 decl_die = comp_unit_die ();
19242 gcc_unreachable ();
19245 /* We should be able to find the DIE now. */
19247 decl_die = lookup_decl_die (decl);
19248 gcc_assert (decl_die);
19254 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
19255 always returned. */
19258 force_type_die (tree type)
19260 dw_die_ref type_die;
19262 type_die = lookup_type_die (type);
19265 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
19267 type_die = modified_type_die (type, TYPE_READONLY (type),
19268 TYPE_VOLATILE (type), context_die);
19269 gcc_assert (type_die);
19274 /* Force out any required namespaces to be able to output DECL,
19275 and return the new context_die for it, if it's changed. */
19278 setup_namespace_context (tree thing, dw_die_ref context_die)
19280 tree context = (DECL_P (thing)
19281 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
19282 if (context && TREE_CODE (context) == NAMESPACE_DECL)
19283 /* Force out the namespace. */
19284 context_die = force_decl_die (context);
19286 return context_die;
19289 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
19290 type) within its namespace, if appropriate.
19292 For compatibility with older debuggers, namespace DIEs only contain
19293 declarations; all definitions are emitted at CU scope. */
19296 declare_in_namespace (tree thing, dw_die_ref context_die)
19298 dw_die_ref ns_context;
19300 if (debug_info_level <= DINFO_LEVEL_TERSE)
19301 return context_die;
19303 /* If this decl is from an inlined function, then don't try to emit it in its
19304 namespace, as we will get confused. It would have already been emitted
19305 when the abstract instance of the inline function was emitted anyways. */
19306 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
19307 return context_die;
19309 ns_context = setup_namespace_context (thing, context_die);
19311 if (ns_context != context_die)
19315 if (DECL_P (thing))
19316 gen_decl_die (thing, NULL, ns_context);
19318 gen_type_die (thing, ns_context);
19320 return context_die;
19323 /* Generate a DIE for a namespace or namespace alias. */
19326 gen_namespace_die (tree decl, dw_die_ref context_die)
19328 dw_die_ref namespace_die;
19330 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
19331 they are an alias of. */
19332 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
19334 /* Output a real namespace or module. */
19335 context_die = setup_namespace_context (decl, comp_unit_die ());
19336 namespace_die = new_die (is_fortran ()
19337 ? DW_TAG_module : DW_TAG_namespace,
19338 context_die, decl);
19339 /* For Fortran modules defined in different CU don't add src coords. */
19340 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
19342 const char *name = dwarf2_name (decl, 0);
19344 add_name_attribute (namespace_die, name);
19347 add_name_and_src_coords_attributes (namespace_die, decl);
19348 if (DECL_EXTERNAL (decl))
19349 add_AT_flag (namespace_die, DW_AT_declaration, 1);
19350 equate_decl_number_to_die (decl, namespace_die);
19354 /* Output a namespace alias. */
19356 /* Force out the namespace we are an alias of, if necessary. */
19357 dw_die_ref origin_die
19358 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
19360 if (DECL_FILE_SCOPE_P (decl)
19361 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
19362 context_die = setup_namespace_context (decl, comp_unit_die ());
19363 /* Now create the namespace alias DIE. */
19364 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
19365 add_name_and_src_coords_attributes (namespace_die, decl);
19366 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
19367 equate_decl_number_to_die (decl, namespace_die);
19371 /* Generate Dwarf debug information for a decl described by DECL.
19372 The return value is currently only meaningful for PARM_DECLs,
19373 for all other decls it returns NULL. */
19376 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
19378 tree decl_or_origin = decl ? decl : origin;
19379 tree class_origin = NULL, ultimate_origin;
19381 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
19384 switch (TREE_CODE (decl_or_origin))
19390 if (!is_fortran () && !is_ada ())
19392 /* The individual enumerators of an enum type get output when we output
19393 the Dwarf representation of the relevant enum type itself. */
19397 /* Emit its type. */
19398 gen_type_die (TREE_TYPE (decl), context_die);
19400 /* And its containing namespace. */
19401 context_die = declare_in_namespace (decl, context_die);
19403 gen_const_die (decl, context_die);
19406 case FUNCTION_DECL:
19407 /* Don't output any DIEs to represent mere function declarations,
19408 unless they are class members or explicit block externs. */
19409 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
19410 && DECL_FILE_SCOPE_P (decl_or_origin)
19411 && (current_function_decl == NULL_TREE
19412 || DECL_ARTIFICIAL (decl_or_origin)))
19417 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
19418 on local redeclarations of global functions. That seems broken. */
19419 if (current_function_decl != decl)
19420 /* This is only a declaration. */;
19423 /* If we're emitting a clone, emit info for the abstract instance. */
19424 if (origin || DECL_ORIGIN (decl) != decl)
19425 dwarf2out_abstract_function (origin
19426 ? DECL_ORIGIN (origin)
19427 : DECL_ABSTRACT_ORIGIN (decl));
19429 /* If we're emitting an out-of-line copy of an inline function,
19430 emit info for the abstract instance and set up to refer to it. */
19431 else if (cgraph_function_possibly_inlined_p (decl)
19432 && ! DECL_ABSTRACT (decl)
19433 && ! class_or_namespace_scope_p (context_die)
19434 /* dwarf2out_abstract_function won't emit a die if this is just
19435 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
19436 that case, because that works only if we have a die. */
19437 && DECL_INITIAL (decl) != NULL_TREE)
19439 dwarf2out_abstract_function (decl);
19440 set_decl_origin_self (decl);
19443 /* Otherwise we're emitting the primary DIE for this decl. */
19444 else if (debug_info_level > DINFO_LEVEL_TERSE)
19446 /* Before we describe the FUNCTION_DECL itself, make sure that we
19447 have its containing type. */
19449 origin = decl_class_context (decl);
19450 if (origin != NULL_TREE)
19451 gen_type_die (origin, context_die);
19453 /* And its return type. */
19454 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
19456 /* And its virtual context. */
19457 if (DECL_VINDEX (decl) != NULL_TREE)
19458 gen_type_die (DECL_CONTEXT (decl), context_die);
19460 /* Make sure we have a member DIE for decl. */
19461 if (origin != NULL_TREE)
19462 gen_type_die_for_member (origin, decl, context_die);
19464 /* And its containing namespace. */
19465 context_die = declare_in_namespace (decl, context_die);
19468 /* Now output a DIE to represent the function itself. */
19470 gen_subprogram_die (decl, context_die);
19474 /* If we are in terse mode, don't generate any DIEs to represent any
19475 actual typedefs. */
19476 if (debug_info_level <= DINFO_LEVEL_TERSE)
19479 /* In the special case of a TYPE_DECL node representing the declaration
19480 of some type tag, if the given TYPE_DECL is marked as having been
19481 instantiated from some other (original) TYPE_DECL node (e.g. one which
19482 was generated within the original definition of an inline function) we
19483 used to generate a special (abbreviated) DW_TAG_structure_type,
19484 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
19485 should be actually referencing those DIEs, as variable DIEs with that
19486 type would be emitted already in the abstract origin, so it was always
19487 removed during unused type prunning. Don't add anything in this
19489 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
19492 if (is_redundant_typedef (decl))
19493 gen_type_die (TREE_TYPE (decl), context_die);
19495 /* Output a DIE to represent the typedef itself. */
19496 gen_typedef_die (decl, context_die);
19500 if (debug_info_level >= DINFO_LEVEL_NORMAL)
19501 gen_label_die (decl, context_die);
19506 /* If we are in terse mode, don't generate any DIEs to represent any
19507 variable declarations or definitions. */
19508 if (debug_info_level <= DINFO_LEVEL_TERSE)
19511 /* Output any DIEs that are needed to specify the type of this data
19513 if (decl_by_reference_p (decl_or_origin))
19514 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
19516 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
19518 /* And its containing type. */
19519 class_origin = decl_class_context (decl_or_origin);
19520 if (class_origin != NULL_TREE)
19521 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
19523 /* And its containing namespace. */
19524 context_die = declare_in_namespace (decl_or_origin, context_die);
19526 /* Now output the DIE to represent the data object itself. This gets
19527 complicated because of the possibility that the VAR_DECL really
19528 represents an inlined instance of a formal parameter for an inline
19530 ultimate_origin = decl_ultimate_origin (decl_or_origin);
19531 if (ultimate_origin != NULL_TREE
19532 && TREE_CODE (ultimate_origin) == PARM_DECL)
19533 gen_formal_parameter_die (decl, origin,
19534 true /* Emit name attribute. */,
19537 gen_variable_die (decl, origin, context_die);
19541 /* Ignore the nameless fields that are used to skip bits but handle C++
19542 anonymous unions and structs. */
19543 if (DECL_NAME (decl) != NULL_TREE
19544 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
19545 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
19547 gen_type_die (member_declared_type (decl), context_die);
19548 gen_field_die (decl, context_die);
19553 if (DECL_BY_REFERENCE (decl_or_origin))
19554 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
19556 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
19557 return gen_formal_parameter_die (decl, origin,
19558 true /* Emit name attribute. */,
19561 case NAMESPACE_DECL:
19562 case IMPORTED_DECL:
19563 if (dwarf_version >= 3 || !dwarf_strict)
19564 gen_namespace_die (decl, context_die);
19568 /* Probably some frontend-internal decl. Assume we don't care. */
19569 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
19576 /* Output debug information for global decl DECL. Called from toplev.c after
19577 compilation proper has finished. */
19580 dwarf2out_global_decl (tree decl)
19582 /* Output DWARF2 information for file-scope tentative data object
19583 declarations, file-scope (extern) function declarations (which
19584 had no corresponding body) and file-scope tagged type declarations
19585 and definitions which have not yet been forced out. */
19586 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
19587 dwarf2out_decl (decl);
19590 /* Output debug information for type decl DECL. Called from toplev.c
19591 and from language front ends (to record built-in types). */
19593 dwarf2out_type_decl (tree decl, int local)
19596 dwarf2out_decl (decl);
19599 /* Output debug information for imported module or decl DECL.
19600 NAME is non-NULL name in the lexical block if the decl has been renamed.
19601 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
19602 that DECL belongs to.
19603 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
19605 dwarf2out_imported_module_or_decl_1 (tree decl,
19607 tree lexical_block,
19608 dw_die_ref lexical_block_die)
19610 expanded_location xloc;
19611 dw_die_ref imported_die = NULL;
19612 dw_die_ref at_import_die;
19614 if (TREE_CODE (decl) == IMPORTED_DECL)
19616 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
19617 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
19621 xloc = expand_location (input_location);
19623 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
19625 at_import_die = force_type_die (TREE_TYPE (decl));
19626 /* For namespace N { typedef void T; } using N::T; base_type_die
19627 returns NULL, but DW_TAG_imported_declaration requires
19628 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
19629 if (!at_import_die)
19631 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
19632 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
19633 at_import_die = lookup_type_die (TREE_TYPE (decl));
19634 gcc_assert (at_import_die);
19639 at_import_die = lookup_decl_die (decl);
19640 if (!at_import_die)
19642 /* If we're trying to avoid duplicate debug info, we may not have
19643 emitted the member decl for this field. Emit it now. */
19644 if (TREE_CODE (decl) == FIELD_DECL)
19646 tree type = DECL_CONTEXT (decl);
19648 if (TYPE_CONTEXT (type)
19649 && TYPE_P (TYPE_CONTEXT (type))
19650 && !should_emit_struct_debug (TYPE_CONTEXT (type),
19651 DINFO_USAGE_DIR_USE))
19653 gen_type_die_for_member (type, decl,
19654 get_context_die (TYPE_CONTEXT (type)));
19656 at_import_die = force_decl_die (decl);
19660 if (TREE_CODE (decl) == NAMESPACE_DECL)
19662 if (dwarf_version >= 3 || !dwarf_strict)
19663 imported_die = new_die (DW_TAG_imported_module,
19670 imported_die = new_die (DW_TAG_imported_declaration,
19674 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
19675 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
19677 add_AT_string (imported_die, DW_AT_name,
19678 IDENTIFIER_POINTER (name));
19679 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
19682 /* Output debug information for imported module or decl DECL.
19683 NAME is non-NULL name in context if the decl has been renamed.
19684 CHILD is true if decl is one of the renamed decls as part of
19685 importing whole module. */
19688 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
19691 /* dw_die_ref at_import_die; */
19692 dw_die_ref scope_die;
19694 if (debug_info_level <= DINFO_LEVEL_TERSE)
19699 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
19700 We need decl DIE for reference and scope die. First, get DIE for the decl
19703 /* Get the scope die for decl context. Use comp_unit_die for global module
19704 or decl. If die is not found for non globals, force new die. */
19706 && TYPE_P (context)
19707 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
19710 if (!(dwarf_version >= 3 || !dwarf_strict))
19713 scope_die = get_context_die (context);
19717 gcc_assert (scope_die->die_child);
19718 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
19719 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
19720 scope_die = scope_die->die_child;
19723 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
19724 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
19728 /* Write the debugging output for DECL. */
19731 dwarf2out_decl (tree decl)
19733 dw_die_ref context_die = comp_unit_die ();
19735 switch (TREE_CODE (decl))
19740 case FUNCTION_DECL:
19741 /* What we would really like to do here is to filter out all mere
19742 file-scope declarations of file-scope functions which are never
19743 referenced later within this translation unit (and keep all of ones
19744 that *are* referenced later on) but we aren't clairvoyant, so we have
19745 no idea which functions will be referenced in the future (i.e. later
19746 on within the current translation unit). So here we just ignore all
19747 file-scope function declarations which are not also definitions. If
19748 and when the debugger needs to know something about these functions,
19749 it will have to hunt around and find the DWARF information associated
19750 with the definition of the function.
19752 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
19753 nodes represent definitions and which ones represent mere
19754 declarations. We have to check DECL_INITIAL instead. That's because
19755 the C front-end supports some weird semantics for "extern inline"
19756 function definitions. These can get inlined within the current
19757 translation unit (and thus, we need to generate Dwarf info for their
19758 abstract instances so that the Dwarf info for the concrete inlined
19759 instances can have something to refer to) but the compiler never
19760 generates any out-of-lines instances of such things (despite the fact
19761 that they *are* definitions).
19763 The important point is that the C front-end marks these "extern
19764 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
19765 them anyway. Note that the C++ front-end also plays some similar games
19766 for inline function definitions appearing within include files which
19767 also contain `#pragma interface' pragmas. */
19768 if (DECL_INITIAL (decl) == NULL_TREE)
19771 /* If we're a nested function, initially use a parent of NULL; if we're
19772 a plain function, this will be fixed up in decls_for_scope. If
19773 we're a method, it will be ignored, since we already have a DIE. */
19774 if (decl_function_context (decl)
19775 /* But if we're in terse mode, we don't care about scope. */
19776 && debug_info_level > DINFO_LEVEL_TERSE)
19777 context_die = NULL;
19781 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
19782 declaration and if the declaration was never even referenced from
19783 within this entire compilation unit. We suppress these DIEs in
19784 order to save space in the .debug section (by eliminating entries
19785 which are probably useless). Note that we must not suppress
19786 block-local extern declarations (whether used or not) because that
19787 would screw-up the debugger's name lookup mechanism and cause it to
19788 miss things which really ought to be in scope at a given point. */
19789 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
19792 /* For local statics lookup proper context die. */
19793 if (TREE_STATIC (decl) && decl_function_context (decl))
19794 context_die = lookup_decl_die (DECL_CONTEXT (decl));
19796 /* If we are in terse mode, don't generate any DIEs to represent any
19797 variable declarations or definitions. */
19798 if (debug_info_level <= DINFO_LEVEL_TERSE)
19803 if (debug_info_level <= DINFO_LEVEL_TERSE)
19805 if (!is_fortran () && !is_ada ())
19807 if (TREE_STATIC (decl) && decl_function_context (decl))
19808 context_die = lookup_decl_die (DECL_CONTEXT (decl));
19811 case NAMESPACE_DECL:
19812 case IMPORTED_DECL:
19813 if (debug_info_level <= DINFO_LEVEL_TERSE)
19815 if (lookup_decl_die (decl) != NULL)
19820 /* Don't emit stubs for types unless they are needed by other DIEs. */
19821 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
19824 /* Don't bother trying to generate any DIEs to represent any of the
19825 normal built-in types for the language we are compiling. */
19826 if (DECL_IS_BUILTIN (decl))
19829 /* If we are in terse mode, don't generate any DIEs for types. */
19830 if (debug_info_level <= DINFO_LEVEL_TERSE)
19833 /* If we're a function-scope tag, initially use a parent of NULL;
19834 this will be fixed up in decls_for_scope. */
19835 if (decl_function_context (decl))
19836 context_die = NULL;
19844 gen_decl_die (decl, NULL, context_die);
19847 /* Write the debugging output for DECL. */
19850 dwarf2out_function_decl (tree decl)
19852 dwarf2out_decl (decl);
19853 call_arg_locations = NULL;
19854 call_arg_loc_last = NULL;
19855 call_site_count = -1;
19856 tail_call_site_count = -1;
19857 VEC_free (dw_die_ref, heap, block_map);
19858 htab_empty (decl_loc_table);
19859 htab_empty (cached_dw_loc_list_table);
19862 /* Output a marker (i.e. a label) for the beginning of the generated code for
19863 a lexical block. */
19866 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
19867 unsigned int blocknum)
19869 switch_to_section (current_function_section ());
19870 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
19873 /* Output a marker (i.e. a label) for the end of the generated code for a
19877 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
19879 switch_to_section (current_function_section ());
19880 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
19883 /* Returns nonzero if it is appropriate not to emit any debugging
19884 information for BLOCK, because it doesn't contain any instructions.
19886 Don't allow this for blocks with nested functions or local classes
19887 as we would end up with orphans, and in the presence of scheduling
19888 we may end up calling them anyway. */
19891 dwarf2out_ignore_block (const_tree block)
19896 for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
19897 if (TREE_CODE (decl) == FUNCTION_DECL
19898 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
19900 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
19902 decl = BLOCK_NONLOCALIZED_VAR (block, i);
19903 if (TREE_CODE (decl) == FUNCTION_DECL
19904 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
19911 /* Hash table routines for file_hash. */
19914 file_table_eq (const void *p1_p, const void *p2_p)
19916 const struct dwarf_file_data *const p1 =
19917 (const struct dwarf_file_data *) p1_p;
19918 const char *const p2 = (const char *) p2_p;
19919 return filename_cmp (p1->filename, p2) == 0;
19923 file_table_hash (const void *p_p)
19925 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
19926 return htab_hash_string (p->filename);
19929 /* Lookup FILE_NAME (in the list of filenames that we know about here in
19930 dwarf2out.c) and return its "index". The index of each (known) filename is
19931 just a unique number which is associated with only that one filename. We
19932 need such numbers for the sake of generating labels (in the .debug_sfnames
19933 section) and references to those files numbers (in the .debug_srcinfo
19934 and.debug_macinfo sections). If the filename given as an argument is not
19935 found in our current list, add it to the list and assign it the next
19936 available unique index number. In order to speed up searches, we remember
19937 the index of the filename was looked up last. This handles the majority of
19940 static struct dwarf_file_data *
19941 lookup_filename (const char *file_name)
19944 struct dwarf_file_data * created;
19946 /* Check to see if the file name that was searched on the previous
19947 call matches this file name. If so, return the index. */
19948 if (file_table_last_lookup
19949 && (file_name == file_table_last_lookup->filename
19950 || filename_cmp (file_table_last_lookup->filename, file_name) == 0))
19951 return file_table_last_lookup;
19953 /* Didn't match the previous lookup, search the table. */
19954 slot = htab_find_slot_with_hash (file_table, file_name,
19955 htab_hash_string (file_name), INSERT);
19957 return (struct dwarf_file_data *) *slot;
19959 created = ggc_alloc_dwarf_file_data ();
19960 created->filename = file_name;
19961 created->emitted_number = 0;
19966 /* If the assembler will construct the file table, then translate the compiler
19967 internal file table number into the assembler file table number, and emit
19968 a .file directive if we haven't already emitted one yet. The file table
19969 numbers are different because we prune debug info for unused variables and
19970 types, which may include filenames. */
19973 maybe_emit_file (struct dwarf_file_data * fd)
19975 if (! fd->emitted_number)
19977 if (last_emitted_file)
19978 fd->emitted_number = last_emitted_file->emitted_number + 1;
19980 fd->emitted_number = 1;
19981 last_emitted_file = fd;
19983 if (DWARF2_ASM_LINE_DEBUG_INFO)
19985 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
19986 output_quoted_string (asm_out_file,
19987 remap_debug_filename (fd->filename));
19988 fputc ('\n', asm_out_file);
19992 return fd->emitted_number;
19995 /* Schedule generation of a DW_AT_const_value attribute to DIE.
19996 That generation should happen after function debug info has been
19997 generated. The value of the attribute is the constant value of ARG. */
20000 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
20002 die_arg_entry entry;
20007 if (!tmpl_value_parm_die_table)
20008 tmpl_value_parm_die_table
20009 = VEC_alloc (die_arg_entry, gc, 32);
20013 VEC_safe_push (die_arg_entry, gc,
20014 tmpl_value_parm_die_table,
20018 /* Return TRUE if T is an instance of generic type, FALSE
20022 generic_type_p (tree t)
20024 if (t == NULL_TREE || !TYPE_P (t))
20026 return lang_hooks.get_innermost_generic_parms (t) != NULL_TREE;
20029 /* Schedule the generation of the generic parameter dies for the
20030 instance of generic type T. The proper generation itself is later
20031 done by gen_scheduled_generic_parms_dies. */
20034 schedule_generic_params_dies_gen (tree t)
20036 if (!generic_type_p (t))
20039 if (generic_type_instances == NULL)
20040 generic_type_instances = VEC_alloc (tree, gc, 256);
20042 VEC_safe_push (tree, gc, generic_type_instances, t);
20045 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
20046 by append_entry_to_tmpl_value_parm_die_table. This function must
20047 be called after function DIEs have been generated. */
20050 gen_remaining_tmpl_value_param_die_attribute (void)
20052 if (tmpl_value_parm_die_table)
20057 FOR_EACH_VEC_ELT (die_arg_entry, tmpl_value_parm_die_table, i, e)
20058 tree_add_const_value_attribute (e->die, e->arg);
20062 /* Generate generic parameters DIEs for instances of generic types
20063 that have been previously scheduled by
20064 schedule_generic_params_dies_gen. This function must be called
20065 after all the types of the CU have been laid out. */
20068 gen_scheduled_generic_parms_dies (void)
20073 if (generic_type_instances == NULL)
20076 FOR_EACH_VEC_ELT (tree, generic_type_instances, i, t)
20077 gen_generic_params_dies (t);
20081 /* Replace DW_AT_name for the decl with name. */
20084 dwarf2out_set_name (tree decl, tree name)
20090 die = TYPE_SYMTAB_DIE (decl);
20094 dname = dwarf2_name (name, 0);
20098 attr = get_AT (die, DW_AT_name);
20101 struct indirect_string_node *node;
20103 node = find_AT_string (dname);
20104 /* replace the string. */
20105 attr->dw_attr_val.v.val_str = node;
20109 add_name_attribute (die, dname);
20112 /* Called by the final INSN scan whenever we see a var location. We
20113 use it to drop labels in the right places, and throw the location in
20114 our lookup table. */
20117 dwarf2out_var_location (rtx loc_note)
20119 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
20120 struct var_loc_node *newloc;
20122 static const char *last_label;
20123 static const char *last_postcall_label;
20124 static bool last_in_cold_section_p;
20128 if (!NOTE_P (loc_note))
20130 if (CALL_P (loc_note))
20133 if (SIBLING_CALL_P (loc_note))
20134 tail_call_site_count++;
20139 var_loc_p = NOTE_KIND (loc_note) == NOTE_INSN_VAR_LOCATION;
20140 if (var_loc_p && !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
20143 next_real = next_real_insn (loc_note);
20145 /* If there are no instructions which would be affected by this note,
20146 don't do anything. */
20148 && next_real == NULL_RTX
20149 && !NOTE_DURING_CALL_P (loc_note))
20152 if (next_real == NULL_RTX)
20153 next_real = get_last_insn ();
20155 /* If there were any real insns between note we processed last time
20156 and this note (or if it is the first note), clear
20157 last_{,postcall_}label so that they are not reused this time. */
20158 if (last_var_location_insn == NULL_RTX
20159 || last_var_location_insn != next_real
20160 || last_in_cold_section_p != in_cold_section_p)
20163 last_postcall_label = NULL;
20168 decl = NOTE_VAR_LOCATION_DECL (loc_note);
20169 newloc = add_var_loc_to_decl (decl, loc_note,
20170 NOTE_DURING_CALL_P (loc_note)
20171 ? last_postcall_label : last_label);
20172 if (newloc == NULL)
20181 /* If there were no real insns between note we processed last time
20182 and this note, use the label we emitted last time. Otherwise
20183 create a new label and emit it. */
20184 if (last_label == NULL)
20186 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
20187 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
20189 last_label = ggc_strdup (loclabel);
20194 struct call_arg_loc_node *ca_loc
20195 = ggc_alloc_cleared_call_arg_loc_node ();
20196 rtx prev = prev_real_insn (loc_note), x;
20197 ca_loc->call_arg_loc_note = loc_note;
20198 ca_loc->next = NULL;
20199 ca_loc->label = last_label;
20202 || (NONJUMP_INSN_P (prev)
20203 && GET_CODE (PATTERN (prev)) == SEQUENCE
20204 && CALL_P (XVECEXP (PATTERN (prev), 0, 0)))));
20205 if (!CALL_P (prev))
20206 prev = XVECEXP (PATTERN (prev), 0, 0);
20207 ca_loc->tail_call_p = SIBLING_CALL_P (prev);
20208 x = PATTERN (prev);
20209 if (GET_CODE (x) == PARALLEL)
20210 x = XVECEXP (x, 0, 0);
20211 if (GET_CODE (x) == SET)
20213 if (GET_CODE (x) == CALL && MEM_P (XEXP (x, 0)))
20215 x = XEXP (XEXP (x, 0), 0);
20216 if (GET_CODE (x) == SYMBOL_REF
20217 && SYMBOL_REF_DECL (x)
20218 && TREE_CODE (SYMBOL_REF_DECL (x)) == FUNCTION_DECL)
20219 ca_loc->symbol_ref = x;
20221 ca_loc->block = insn_scope (prev);
20222 if (call_arg_locations)
20223 call_arg_loc_last->next = ca_loc;
20225 call_arg_locations = ca_loc;
20226 call_arg_loc_last = ca_loc;
20228 else if (!NOTE_DURING_CALL_P (loc_note))
20229 newloc->label = last_label;
20232 if (!last_postcall_label)
20234 sprintf (loclabel, "%s-1", last_label);
20235 last_postcall_label = ggc_strdup (loclabel);
20237 newloc->label = last_postcall_label;
20240 last_var_location_insn = next_real;
20241 last_in_cold_section_p = in_cold_section_p;
20244 /* Note in one location list that text section has changed. */
20247 var_location_switch_text_section_1 (void **slot, void *data ATTRIBUTE_UNUSED)
20249 var_loc_list *list = (var_loc_list *) *slot;
20251 list->last_before_switch
20252 = list->last->next ? list->last->next : list->last;
20256 /* Note in all location lists that text section has changed. */
20259 var_location_switch_text_section (void)
20261 if (decl_loc_table == NULL)
20264 htab_traverse (decl_loc_table, var_location_switch_text_section_1, NULL);
20267 /* Create a new line number table. */
20269 static dw_line_info_table *
20270 new_line_info_table (void)
20272 dw_line_info_table *table;
20274 table = ggc_alloc_cleared_dw_line_info_table_struct ();
20275 table->file_num = 1;
20276 table->line_num = 1;
20277 table->is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
20282 /* Lookup the "current" table into which we emit line info, so
20283 that we don't have to do it for every source line. */
20286 set_cur_line_info_table (section *sec)
20288 dw_line_info_table *table;
20290 if (sec == text_section)
20291 table = text_section_line_info;
20292 else if (sec == cold_text_section)
20294 table = cold_text_section_line_info;
20297 cold_text_section_line_info = table = new_line_info_table ();
20298 table->end_label = cold_end_label;
20303 const char *end_label;
20305 if (flag_reorder_blocks_and_partition)
20307 if (in_cold_section_p)
20308 end_label = crtl->subsections.cold_section_end_label;
20310 end_label = crtl->subsections.hot_section_end_label;
20314 char label[MAX_ARTIFICIAL_LABEL_BYTES];
20315 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
20316 current_function_funcdef_no);
20317 end_label = ggc_strdup (label);
20320 table = new_line_info_table ();
20321 table->end_label = end_label;
20323 VEC_safe_push (dw_line_info_table_p, gc, separate_line_info, table);
20326 cur_line_info_table = table;
20330 /* We need to reset the locations at the beginning of each
20331 function. We can't do this in the end_function hook, because the
20332 declarations that use the locations won't have been output when
20333 that hook is called. Also compute have_multiple_function_sections here. */
20336 dwarf2out_begin_function (tree fun)
20338 section *sec = function_section (fun);
20340 if (sec != text_section)
20341 have_multiple_function_sections = true;
20343 if (flag_reorder_blocks_and_partition && !cold_text_section)
20345 gcc_assert (current_function_decl == fun);
20346 cold_text_section = unlikely_text_section ();
20347 switch_to_section (cold_text_section);
20348 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
20349 switch_to_section (sec);
20352 dwarf2out_note_section_used ();
20353 call_site_count = 0;
20354 tail_call_site_count = 0;
20356 set_cur_line_info_table (sec);
20359 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
20362 push_dw_line_info_entry (dw_line_info_table *table,
20363 enum dw_line_info_opcode opcode, unsigned int val)
20365 dw_line_info_entry e;
20368 VEC_safe_push (dw_line_info_entry, gc, table->entries, &e);
20371 /* Output a label to mark the beginning of a source code line entry
20372 and record information relating to this source line, in
20373 'line_info_table' for later output of the .debug_line section. */
20374 /* ??? The discriminator parameter ought to be unsigned. */
20377 dwarf2out_source_line (unsigned int line, const char *filename,
20378 int discriminator, bool is_stmt)
20380 unsigned int file_num;
20381 dw_line_info_table *table;
20383 if (debug_info_level < DINFO_LEVEL_NORMAL || line == 0)
20386 /* The discriminator column was added in dwarf4. Simplify the below
20387 by simply removing it if we're not supposed to output it. */
20388 if (dwarf_version < 4 && dwarf_strict)
20391 table = cur_line_info_table;
20392 file_num = maybe_emit_file (lookup_filename (filename));
20394 /* ??? TODO: Elide duplicate line number entries. Traditionally,
20395 the debugger has used the second (possibly duplicate) line number
20396 at the beginning of the function to mark the end of the prologue.
20397 We could eliminate any other duplicates within the function. For
20398 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
20399 that second line number entry. */
20400 /* Recall that this end-of-prologue indication is *not* the same thing
20401 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
20402 to which the hook corresponds, follows the last insn that was
20403 emitted by gen_prologue. What we need is to preceed the first insn
20404 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
20405 insn that corresponds to something the user wrote. These may be
20406 very different locations once scheduling is enabled. */
20408 if (0 && file_num == table->file_num
20409 && line == table->line_num
20410 && discriminator == table->discrim_num
20411 && is_stmt == table->is_stmt)
20414 switch_to_section (current_function_section ());
20416 /* If requested, emit something human-readable. */
20417 if (flag_debug_asm)
20418 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line);
20420 if (DWARF2_ASM_LINE_DEBUG_INFO)
20422 /* Emit the .loc directive understood by GNU as. */
20423 fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
20424 if (is_stmt != table->is_stmt)
20425 fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
20426 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
20427 fprintf (asm_out_file, " discriminator %d", discriminator);
20428 fputc ('\n', asm_out_file);
20432 unsigned int label_num = ++line_info_label_num;
20434 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, label_num);
20436 push_dw_line_info_entry (table, LI_set_address, label_num);
20437 if (file_num != table->file_num)
20438 push_dw_line_info_entry (table, LI_set_file, file_num);
20439 if (discriminator != table->discrim_num)
20440 push_dw_line_info_entry (table, LI_set_discriminator, discriminator);
20441 if (is_stmt != table->is_stmt)
20442 push_dw_line_info_entry (table, LI_negate_stmt, 0);
20443 push_dw_line_info_entry (table, LI_set_line, line);
20446 table->file_num = file_num;
20447 table->line_num = line;
20448 table->discrim_num = discriminator;
20449 table->is_stmt = is_stmt;
20450 table->in_use = true;
20453 /* Record the beginning of a new source file. */
20456 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
20458 if (flag_eliminate_dwarf2_dups && ! use_debug_types)
20460 /* Record the beginning of the file for break_out_includes. */
20461 dw_die_ref bincl_die;
20463 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die (), NULL);
20464 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
20467 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20470 e.code = DW_MACINFO_start_file;
20472 e.info = xstrdup (filename);
20473 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
20477 /* Record the end of a source file. */
20480 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
20482 if (flag_eliminate_dwarf2_dups && ! use_debug_types)
20483 /* Record the end of the file for break_out_includes. */
20484 new_die (DW_TAG_GNU_EINCL, comp_unit_die (), NULL);
20486 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20489 e.code = DW_MACINFO_end_file;
20492 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
20496 /* Called from debug_define in toplev.c. The `buffer' parameter contains
20497 the tail part of the directive line, i.e. the part which is past the
20498 initial whitespace, #, whitespace, directive-name, whitespace part. */
20501 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
20502 const char *buffer ATTRIBUTE_UNUSED)
20504 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20507 /* Insert a dummy first entry to be able to optimize the whole
20508 predefined macro block using DW_MACRO_GNU_transparent_include. */
20509 if (VEC_empty (macinfo_entry, macinfo_table) && lineno == 0)
20514 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
20516 e.code = DW_MACINFO_define;
20518 e.info = xstrdup (buffer);;
20519 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
20523 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
20524 the tail part of the directive line, i.e. the part which is past the
20525 initial whitespace, #, whitespace, directive-name, whitespace part. */
20528 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
20529 const char *buffer ATTRIBUTE_UNUSED)
20531 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20534 /* Insert a dummy first entry to be able to optimize the whole
20535 predefined macro block using DW_MACRO_GNU_transparent_include. */
20536 if (VEC_empty (macinfo_entry, macinfo_table) && lineno == 0)
20541 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
20543 e.code = DW_MACINFO_undef;
20545 e.info = xstrdup (buffer);
20546 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
20550 /* Routines to manipulate hash table of CUs. */
20553 htab_macinfo_hash (const void *of)
20555 const macinfo_entry *const entry =
20556 (const macinfo_entry *) of;
20558 return htab_hash_string (entry->info);
20562 htab_macinfo_eq (const void *of1, const void *of2)
20564 const macinfo_entry *const entry1 = (const macinfo_entry *) of1;
20565 const macinfo_entry *const entry2 = (const macinfo_entry *) of2;
20567 return !strcmp (entry1->info, entry2->info);
20570 /* Output a single .debug_macinfo entry. */
20573 output_macinfo_op (macinfo_entry *ref)
20577 struct indirect_string_node *node;
20578 char label[MAX_ARTIFICIAL_LABEL_BYTES];
20579 struct dwarf_file_data *fd;
20583 case DW_MACINFO_start_file:
20584 fd = lookup_filename (ref->info);
20585 if (fd->filename == ref->info)
20586 fd->filename = ggc_strdup (fd->filename);
20587 file_num = maybe_emit_file (fd);
20588 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
20589 dw2_asm_output_data_uleb128 (ref->lineno,
20590 "Included from line number %lu",
20591 (unsigned long) ref->lineno);
20592 dw2_asm_output_data_uleb128 (file_num, "file %s", ref->info);
20594 case DW_MACINFO_end_file:
20595 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
20597 case DW_MACINFO_define:
20598 case DW_MACINFO_undef:
20599 len = strlen (ref->info) + 1;
20601 && len > DWARF_OFFSET_SIZE
20602 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
20603 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
20605 ref->code = ref->code == DW_MACINFO_define
20606 ? DW_MACRO_GNU_define_indirect
20607 : DW_MACRO_GNU_undef_indirect;
20608 output_macinfo_op (ref);
20611 dw2_asm_output_data (1, ref->code,
20612 ref->code == DW_MACINFO_define
20613 ? "Define macro" : "Undefine macro");
20614 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
20615 (unsigned long) ref->lineno);
20616 dw2_asm_output_nstring (ref->info, -1, "The macro");
20618 case DW_MACRO_GNU_define_indirect:
20619 case DW_MACRO_GNU_undef_indirect:
20620 node = find_AT_string (ref->info);
20621 if (node->form != DW_FORM_strp)
20624 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
20625 ++dw2_string_counter;
20626 node->label = xstrdup (label);
20627 node->form = DW_FORM_strp;
20629 dw2_asm_output_data (1, ref->code,
20630 ref->code == DW_MACRO_GNU_define_indirect
20631 ? "Define macro indirect"
20632 : "Undefine macro indirect");
20633 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
20634 (unsigned long) ref->lineno);
20635 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label,
20636 debug_str_section, "The macro: \"%s\"",
20639 case DW_MACRO_GNU_transparent_include:
20640 dw2_asm_output_data (1, ref->code, "Transparent include");
20641 ASM_GENERATE_INTERNAL_LABEL (label,
20642 DEBUG_MACRO_SECTION_LABEL, ref->lineno);
20643 dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL);
20646 fprintf (asm_out_file, "%s unrecognized macinfo code %lu\n",
20647 ASM_COMMENT_START, (unsigned long) ref->code);
20652 /* Attempt to make a sequence of define/undef macinfo ops shareable with
20653 other compilation unit .debug_macinfo sections. IDX is the first
20654 index of a define/undef, return the number of ops that should be
20655 emitted in a comdat .debug_macinfo section and emit
20656 a DW_MACRO_GNU_transparent_include entry referencing it.
20657 If the define/undef entry should be emitted normally, return 0. */
20660 optimize_macinfo_range (unsigned int idx, VEC (macinfo_entry, gc) *files,
20661 htab_t *macinfo_htab)
20663 macinfo_entry *first, *second, *cur, *inc;
20664 char linebuf[sizeof (HOST_WIDE_INT) * 3 + 1];
20665 unsigned char checksum[16];
20666 struct md5_ctx ctx;
20667 char *grp_name, *tail;
20669 unsigned int i, count, encoded_filename_len, linebuf_len;
20672 first = VEC_index (macinfo_entry, macinfo_table, idx);
20673 second = VEC_index (macinfo_entry, macinfo_table, idx + 1);
20675 /* Optimize only if there are at least two consecutive define/undef ops,
20676 and either all of them are before first DW_MACINFO_start_file
20677 with lineno 0 (i.e. predefined macro block), or all of them are
20678 in some included header file. */
20679 if (second->code != DW_MACINFO_define && second->code != DW_MACINFO_undef)
20681 if (VEC_empty (macinfo_entry, files))
20683 if (first->lineno != 0 || second->lineno != 0)
20686 else if (first->lineno == 0)
20689 /* Find the last define/undef entry that can be grouped together
20690 with first and at the same time compute md5 checksum of their
20691 codes, linenumbers and strings. */
20692 md5_init_ctx (&ctx);
20693 for (i = idx; VEC_iterate (macinfo_entry, macinfo_table, i, cur); i++)
20694 if (cur->code != DW_MACINFO_define && cur->code != DW_MACINFO_undef)
20696 else if (first->lineno == 0 && cur->lineno != 0)
20700 unsigned char code = cur->code;
20701 md5_process_bytes (&code, 1, &ctx);
20702 checksum_uleb128 (cur->lineno, &ctx);
20703 md5_process_bytes (cur->info, strlen (cur->info) + 1, &ctx);
20705 md5_finish_ctx (&ctx, checksum);
20708 /* From the containing include filename (if any) pick up just
20709 usable characters from its basename. */
20710 if (first->lineno == 0)
20713 base = lbasename (VEC_last (macinfo_entry, files)->info);
20714 for (encoded_filename_len = 0, i = 0; base[i]; i++)
20715 if (ISIDNUM (base[i]) || base[i] == '.')
20716 encoded_filename_len++;
20717 /* Count . at the end. */
20718 if (encoded_filename_len)
20719 encoded_filename_len++;
20721 sprintf (linebuf, HOST_WIDE_INT_PRINT_UNSIGNED, first->lineno);
20722 linebuf_len = strlen (linebuf);
20724 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
20725 grp_name = XNEWVEC (char, 4 + encoded_filename_len + linebuf_len + 1
20727 memcpy (grp_name, DWARF_OFFSET_SIZE == 4 ? "wm4." : "wm8.", 4);
20728 tail = grp_name + 4;
20729 if (encoded_filename_len)
20731 for (i = 0; base[i]; i++)
20732 if (ISIDNUM (base[i]) || base[i] == '.')
20736 memcpy (tail, linebuf, linebuf_len);
20737 tail += linebuf_len;
20739 for (i = 0; i < 16; i++)
20740 sprintf (tail + i * 2, "%02x", checksum[i] & 0xff);
20742 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
20743 in the empty vector entry before the first define/undef. */
20744 inc = VEC_index (macinfo_entry, macinfo_table, idx - 1);
20745 inc->code = DW_MACRO_GNU_transparent_include;
20747 inc->info = grp_name;
20748 if (*macinfo_htab == NULL)
20749 *macinfo_htab = htab_create (10, htab_macinfo_hash, htab_macinfo_eq, NULL);
20750 /* Avoid emitting duplicates. */
20751 slot = htab_find_slot (*macinfo_htab, inc, INSERT);
20754 free (CONST_CAST (char *, inc->info));
20757 /* If such an entry has been used before, just emit
20758 a DW_MACRO_GNU_transparent_include op. */
20759 inc = (macinfo_entry *) *slot;
20760 output_macinfo_op (inc);
20761 /* And clear all macinfo_entry in the range to avoid emitting them
20762 in the second pass. */
20764 VEC_iterate (macinfo_entry, macinfo_table, i, cur)
20765 && i < idx + count;
20769 free (CONST_CAST (char *, cur->info));
20776 inc->lineno = htab_elements (*macinfo_htab);
20777 output_macinfo_op (inc);
20782 /* Output macinfo section(s). */
20785 output_macinfo (void)
20788 unsigned long length = VEC_length (macinfo_entry, macinfo_table);
20789 macinfo_entry *ref;
20790 VEC (macinfo_entry, gc) *files = NULL;
20791 htab_t macinfo_htab = NULL;
20796 /* output_macinfo* uses these interchangeably. */
20797 gcc_assert ((int) DW_MACINFO_define == (int) DW_MACRO_GNU_define
20798 && (int) DW_MACINFO_undef == (int) DW_MACRO_GNU_undef
20799 && (int) DW_MACINFO_start_file == (int) DW_MACRO_GNU_start_file
20800 && (int) DW_MACINFO_end_file == (int) DW_MACRO_GNU_end_file);
20802 /* For .debug_macro emit the section header. */
20805 dw2_asm_output_data (2, 4, "DWARF macro version number");
20806 if (DWARF_OFFSET_SIZE == 8)
20807 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
20809 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
20810 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_line_section_label,
20811 debug_line_section, NULL);
20814 /* In the first loop, it emits the primary .debug_macinfo section
20815 and after each emitted op the macinfo_entry is cleared.
20816 If a longer range of define/undef ops can be optimized using
20817 DW_MACRO_GNU_transparent_include, the
20818 DW_MACRO_GNU_transparent_include op is emitted and kept in
20819 the vector before the first define/undef in the range and the
20820 whole range of define/undef ops is not emitted and kept. */
20821 for (i = 0; VEC_iterate (macinfo_entry, macinfo_table, i, ref); i++)
20825 case DW_MACINFO_start_file:
20826 VEC_safe_push (macinfo_entry, gc, files, ref);
20828 case DW_MACINFO_end_file:
20829 if (!VEC_empty (macinfo_entry, files))
20831 macinfo_entry *file = VEC_last (macinfo_entry, files);
20832 free (CONST_CAST (char *, file->info));
20833 VEC_pop (macinfo_entry, files);
20836 case DW_MACINFO_define:
20837 case DW_MACINFO_undef:
20839 && HAVE_COMDAT_GROUP
20840 && VEC_length (macinfo_entry, files) != 1
20843 && VEC_index (macinfo_entry, macinfo_table, i - 1)->code == 0)
20845 unsigned count = optimize_macinfo_range (i, files, &macinfo_htab);
20854 /* A dummy entry may be inserted at the beginning to be able
20855 to optimize the whole block of predefined macros. */
20861 output_macinfo_op (ref);
20862 /* For DW_MACINFO_start_file ref->info has been copied into files
20864 if (ref->code != DW_MACINFO_start_file)
20865 free (CONST_CAST (char *, ref->info));
20870 if (macinfo_htab == NULL)
20873 htab_delete (macinfo_htab);
20875 /* If any DW_MACRO_GNU_transparent_include were used, on those
20876 DW_MACRO_GNU_transparent_include entries terminate the
20877 current chain and switch to a new comdat .debug_macinfo
20878 section and emit the define/undef entries within it. */
20879 for (i = 0; VEC_iterate (macinfo_entry, macinfo_table, i, ref); i++)
20884 case DW_MACRO_GNU_transparent_include:
20886 char label[MAX_ARTIFICIAL_LABEL_BYTES];
20887 tree comdat_key = get_identifier (ref->info);
20888 /* Terminate the previous .debug_macinfo section. */
20889 dw2_asm_output_data (1, 0, "End compilation unit");
20890 targetm.asm_out.named_section (DEBUG_MACRO_SECTION,
20892 | SECTION_LINKONCE,
20894 ASM_GENERATE_INTERNAL_LABEL (label,
20895 DEBUG_MACRO_SECTION_LABEL,
20897 ASM_OUTPUT_LABEL (asm_out_file, label);
20899 free (CONST_CAST (char *, ref->info));
20901 dw2_asm_output_data (2, 4, "DWARF macro version number");
20902 if (DWARF_OFFSET_SIZE == 8)
20903 dw2_asm_output_data (1, 1, "Flags: 64-bit");
20905 dw2_asm_output_data (1, 0, "Flags: 32-bit");
20908 case DW_MACINFO_define:
20909 case DW_MACINFO_undef:
20910 output_macinfo_op (ref);
20912 free (CONST_CAST (char *, ref->info));
20916 gcc_unreachable ();
20920 /* Set up for Dwarf output at the start of compilation. */
20923 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
20925 /* Allocate the file_table. */
20926 file_table = htab_create_ggc (50, file_table_hash,
20927 file_table_eq, NULL);
20929 /* Allocate the decl_die_table. */
20930 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
20931 decl_die_table_eq, NULL);
20933 /* Allocate the decl_loc_table. */
20934 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
20935 decl_loc_table_eq, NULL);
20937 /* Allocate the cached_dw_loc_list_table. */
20938 cached_dw_loc_list_table
20939 = htab_create_ggc (10, cached_dw_loc_list_table_hash,
20940 cached_dw_loc_list_table_eq, NULL);
20942 /* Allocate the initial hunk of the decl_scope_table. */
20943 decl_scope_table = VEC_alloc (tree, gc, 256);
20945 /* Allocate the initial hunk of the abbrev_die_table. */
20946 abbrev_die_table = ggc_alloc_cleared_vec_dw_die_ref
20947 (ABBREV_DIE_TABLE_INCREMENT);
20948 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
20949 /* Zero-th entry is allocated, but unused. */
20950 abbrev_die_table_in_use = 1;
20952 /* Allocate the pubtypes and pubnames vectors. */
20953 pubname_table = VEC_alloc (pubname_entry, gc, 32);
20954 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
20956 incomplete_types = VEC_alloc (tree, gc, 64);
20958 used_rtx_array = VEC_alloc (rtx, gc, 32);
20960 debug_info_section = get_section (DEBUG_INFO_SECTION,
20961 SECTION_DEBUG, NULL);
20962 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
20963 SECTION_DEBUG, NULL);
20964 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
20965 SECTION_DEBUG, NULL);
20966 debug_macinfo_section = get_section (dwarf_strict
20967 ? DEBUG_MACINFO_SECTION
20968 : DEBUG_MACRO_SECTION,
20969 SECTION_DEBUG, NULL);
20970 debug_line_section = get_section (DEBUG_LINE_SECTION,
20971 SECTION_DEBUG, NULL);
20972 debug_loc_section = get_section (DEBUG_LOC_SECTION,
20973 SECTION_DEBUG, NULL);
20974 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
20975 SECTION_DEBUG, NULL);
20976 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
20977 SECTION_DEBUG, NULL);
20978 debug_str_section = get_section (DEBUG_STR_SECTION,
20979 DEBUG_STR_SECTION_FLAGS, NULL);
20980 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
20981 SECTION_DEBUG, NULL);
20982 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
20983 SECTION_DEBUG, NULL);
20985 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
20986 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
20987 DEBUG_ABBREV_SECTION_LABEL, 0);
20988 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
20989 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
20990 COLD_TEXT_SECTION_LABEL, 0);
20991 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
20993 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
20994 DEBUG_INFO_SECTION_LABEL, 0);
20995 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
20996 DEBUG_LINE_SECTION_LABEL, 0);
20997 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
20998 DEBUG_RANGES_SECTION_LABEL, 0);
20999 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
21001 ? DEBUG_MACINFO_SECTION_LABEL
21002 : DEBUG_MACRO_SECTION_LABEL, 0);
21004 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21005 macinfo_table = VEC_alloc (macinfo_entry, gc, 64);
21007 switch_to_section (text_section);
21008 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
21010 /* Make sure the line number table for .text always exists. */
21011 text_section_line_info = new_line_info_table ();
21012 text_section_line_info->end_label = text_end_label;
21015 /* Called before cgraph_optimize starts outputtting functions, variables
21016 and toplevel asms into assembly. */
21019 dwarf2out_assembly_start (void)
21021 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
21022 && dwarf2out_do_cfi_asm ()
21023 && (!(flag_unwind_tables || flag_exceptions)
21024 || targetm_common.except_unwind_info (&global_options) != UI_DWARF2))
21025 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
21028 /* A helper function for dwarf2out_finish called through
21029 htab_traverse. Emit one queued .debug_str string. */
21032 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
21034 struct indirect_string_node *node = (struct indirect_string_node *) *h;
21036 if (node->form == DW_FORM_strp)
21038 switch_to_section (debug_str_section);
21039 ASM_OUTPUT_LABEL (asm_out_file, node->label);
21040 assemble_string (node->str, strlen (node->str) + 1);
21046 #if ENABLE_ASSERT_CHECKING
21047 /* Verify that all marks are clear. */
21050 verify_marks_clear (dw_die_ref die)
21054 gcc_assert (! die->die_mark);
21055 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
21057 #endif /* ENABLE_ASSERT_CHECKING */
21059 /* Clear the marks for a die and its children.
21060 Be cool if the mark isn't set. */
21063 prune_unmark_dies (dw_die_ref die)
21069 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
21072 /* Given DIE that we're marking as used, find any other dies
21073 it references as attributes and mark them as used. */
21076 prune_unused_types_walk_attribs (dw_die_ref die)
21081 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
21083 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
21085 /* A reference to another DIE.
21086 Make sure that it will get emitted.
21087 If it was broken out into a comdat group, don't follow it. */
21088 if (! use_debug_types
21089 || a->dw_attr == DW_AT_specification
21090 || a->dw_attr_val.v.val_die_ref.die->die_id.die_type_node == NULL)
21091 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
21093 /* Set the string's refcount to 0 so that prune_unused_types_mark
21094 accounts properly for it. */
21095 if (AT_class (a) == dw_val_class_str)
21096 a->dw_attr_val.v.val_str->refcount = 0;
21100 /* Mark the generic parameters and arguments children DIEs of DIE. */
21103 prune_unused_types_mark_generic_parms_dies (dw_die_ref die)
21107 if (die == NULL || die->die_child == NULL)
21109 c = die->die_child;
21112 switch (c->die_tag)
21114 case DW_TAG_template_type_param:
21115 case DW_TAG_template_value_param:
21116 case DW_TAG_GNU_template_template_param:
21117 case DW_TAG_GNU_template_parameter_pack:
21118 prune_unused_types_mark (c, 1);
21124 } while (c && c != die->die_child);
21127 /* Mark DIE as being used. If DOKIDS is true, then walk down
21128 to DIE's children. */
21131 prune_unused_types_mark (dw_die_ref die, int dokids)
21135 if (die->die_mark == 0)
21137 /* We haven't done this node yet. Mark it as used. */
21139 /* If this is the DIE of a generic type instantiation,
21140 mark the children DIEs that describe its generic parms and
21142 prune_unused_types_mark_generic_parms_dies (die);
21144 /* We also have to mark its parents as used.
21145 (But we don't want to mark our parents' kids due to this.) */
21146 if (die->die_parent)
21147 prune_unused_types_mark (die->die_parent, 0);
21149 /* Mark any referenced nodes. */
21150 prune_unused_types_walk_attribs (die);
21152 /* If this node is a specification,
21153 also mark the definition, if it exists. */
21154 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
21155 prune_unused_types_mark (die->die_definition, 1);
21158 if (dokids && die->die_mark != 2)
21160 /* We need to walk the children, but haven't done so yet.
21161 Remember that we've walked the kids. */
21164 /* If this is an array type, we need to make sure our
21165 kids get marked, even if they're types. If we're
21166 breaking out types into comdat sections, do this
21167 for all type definitions. */
21168 if (die->die_tag == DW_TAG_array_type
21169 || (use_debug_types
21170 && is_type_die (die) && ! is_declaration_die (die)))
21171 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
21173 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
21177 /* For local classes, look if any static member functions were emitted
21178 and if so, mark them. */
21181 prune_unused_types_walk_local_classes (dw_die_ref die)
21185 if (die->die_mark == 2)
21188 switch (die->die_tag)
21190 case DW_TAG_structure_type:
21191 case DW_TAG_union_type:
21192 case DW_TAG_class_type:
21195 case DW_TAG_subprogram:
21196 if (!get_AT_flag (die, DW_AT_declaration)
21197 || die->die_definition != NULL)
21198 prune_unused_types_mark (die, 1);
21205 /* Mark children. */
21206 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
21209 /* Walk the tree DIE and mark types that we actually use. */
21212 prune_unused_types_walk (dw_die_ref die)
21216 /* Don't do anything if this node is already marked and
21217 children have been marked as well. */
21218 if (die->die_mark == 2)
21221 switch (die->die_tag)
21223 case DW_TAG_structure_type:
21224 case DW_TAG_union_type:
21225 case DW_TAG_class_type:
21226 if (die->die_perennial_p)
21229 for (c = die->die_parent; c; c = c->die_parent)
21230 if (c->die_tag == DW_TAG_subprogram)
21233 /* Finding used static member functions inside of classes
21234 is needed just for local classes, because for other classes
21235 static member function DIEs with DW_AT_specification
21236 are emitted outside of the DW_TAG_*_type. If we ever change
21237 it, we'd need to call this even for non-local classes. */
21239 prune_unused_types_walk_local_classes (die);
21241 /* It's a type node --- don't mark it. */
21244 case DW_TAG_const_type:
21245 case DW_TAG_packed_type:
21246 case DW_TAG_pointer_type:
21247 case DW_TAG_reference_type:
21248 case DW_TAG_rvalue_reference_type:
21249 case DW_TAG_volatile_type:
21250 case DW_TAG_typedef:
21251 case DW_TAG_array_type:
21252 case DW_TAG_interface_type:
21253 case DW_TAG_friend:
21254 case DW_TAG_variant_part:
21255 case DW_TAG_enumeration_type:
21256 case DW_TAG_subroutine_type:
21257 case DW_TAG_string_type:
21258 case DW_TAG_set_type:
21259 case DW_TAG_subrange_type:
21260 case DW_TAG_ptr_to_member_type:
21261 case DW_TAG_file_type:
21262 if (die->die_perennial_p)
21265 /* It's a type node --- don't mark it. */
21269 /* Mark everything else. */
21273 if (die->die_mark == 0)
21277 /* Now, mark any dies referenced from here. */
21278 prune_unused_types_walk_attribs (die);
21283 /* Mark children. */
21284 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
21287 /* Increment the string counts on strings referred to from DIE's
21291 prune_unused_types_update_strings (dw_die_ref die)
21296 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
21297 if (AT_class (a) == dw_val_class_str)
21299 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
21301 /* Avoid unnecessarily putting strings that are used less than
21302 twice in the hash table. */
21304 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
21307 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
21308 htab_hash_string (s->str),
21310 gcc_assert (*slot == NULL);
21316 /* Remove from the tree DIE any dies that aren't marked. */
21319 prune_unused_types_prune (dw_die_ref die)
21323 gcc_assert (die->die_mark);
21324 prune_unused_types_update_strings (die);
21326 if (! die->die_child)
21329 c = die->die_child;
21331 dw_die_ref prev = c;
21332 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
21333 if (c == die->die_child)
21335 /* No marked children between 'prev' and the end of the list. */
21337 /* No marked children at all. */
21338 die->die_child = NULL;
21341 prev->die_sib = c->die_sib;
21342 die->die_child = prev;
21347 if (c != prev->die_sib)
21349 prune_unused_types_prune (c);
21350 } while (c != die->die_child);
21353 /* Remove dies representing declarations that we never use. */
21356 prune_unused_types (void)
21359 limbo_die_node *node;
21360 comdat_type_node *ctnode;
21362 dw_die_ref base_type;
21364 #if ENABLE_ASSERT_CHECKING
21365 /* All the marks should already be clear. */
21366 verify_marks_clear (comp_unit_die ());
21367 for (node = limbo_die_list; node; node = node->next)
21368 verify_marks_clear (node->die);
21369 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
21370 verify_marks_clear (ctnode->root_die);
21371 #endif /* ENABLE_ASSERT_CHECKING */
21373 /* Mark types that are used in global variables. */
21374 premark_types_used_by_global_vars ();
21376 /* Set the mark on nodes that are actually used. */
21377 prune_unused_types_walk (comp_unit_die ());
21378 for (node = limbo_die_list; node; node = node->next)
21379 prune_unused_types_walk (node->die);
21380 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
21382 prune_unused_types_walk (ctnode->root_die);
21383 prune_unused_types_mark (ctnode->type_die, 1);
21386 /* Also set the mark on nodes referenced from the
21388 FOR_EACH_VEC_ELT (pubname_entry, pubname_table, i, pub)
21389 prune_unused_types_mark (pub->die, 1);
21390 for (i = 0; VEC_iterate (dw_die_ref, base_types, i, base_type); i++)
21391 prune_unused_types_mark (base_type, 1);
21393 if (debug_str_hash)
21394 htab_empty (debug_str_hash);
21395 prune_unused_types_prune (comp_unit_die ());
21396 for (node = limbo_die_list; node; node = node->next)
21397 prune_unused_types_prune (node->die);
21398 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
21399 prune_unused_types_prune (ctnode->root_die);
21401 /* Leave the marks clear. */
21402 prune_unmark_dies (comp_unit_die ());
21403 for (node = limbo_die_list; node; node = node->next)
21404 prune_unmark_dies (node->die);
21405 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
21406 prune_unmark_dies (ctnode->root_die);
21409 /* Set the parameter to true if there are any relative pathnames in
21412 file_table_relative_p (void ** slot, void *param)
21414 bool *p = (bool *) param;
21415 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
21416 if (!IS_ABSOLUTE_PATH (d->filename))
21424 /* Routines to manipulate hash table of comdat type units. */
21427 htab_ct_hash (const void *of)
21430 const comdat_type_node *const type_node = (const comdat_type_node *) of;
21432 memcpy (&h, type_node->signature, sizeof (h));
21437 htab_ct_eq (const void *of1, const void *of2)
21439 const comdat_type_node *const type_node_1 = (const comdat_type_node *) of1;
21440 const comdat_type_node *const type_node_2 = (const comdat_type_node *) of2;
21442 return (! memcmp (type_node_1->signature, type_node_2->signature,
21443 DWARF_TYPE_SIGNATURE_SIZE));
21446 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
21447 to the location it would have been added, should we know its
21448 DECL_ASSEMBLER_NAME when we added other attributes. This will
21449 probably improve compactness of debug info, removing equivalent
21450 abbrevs, and hide any differences caused by deferring the
21451 computation of the assembler name, triggered by e.g. PCH. */
21454 move_linkage_attr (dw_die_ref die)
21456 unsigned ix = VEC_length (dw_attr_node, die->die_attr);
21457 dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1);
21459 gcc_assert (linkage.dw_attr == DW_AT_linkage_name
21460 || linkage.dw_attr == DW_AT_MIPS_linkage_name);
21464 dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1);
21466 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
21470 if (ix != VEC_length (dw_attr_node, die->die_attr) - 1)
21472 VEC_pop (dw_attr_node, die->die_attr);
21473 VEC_quick_insert (dw_attr_node, die->die_attr, ix, &linkage);
21477 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
21478 referenced from typed stack ops and count how often they are used. */
21481 mark_base_types (dw_loc_descr_ref loc)
21483 dw_die_ref base_type = NULL;
21485 for (; loc; loc = loc->dw_loc_next)
21487 switch (loc->dw_loc_opc)
21489 case DW_OP_GNU_regval_type:
21490 case DW_OP_GNU_deref_type:
21491 base_type = loc->dw_loc_oprnd2.v.val_die_ref.die;
21493 case DW_OP_GNU_convert:
21494 case DW_OP_GNU_reinterpret:
21495 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
21498 case DW_OP_GNU_const_type:
21499 base_type = loc->dw_loc_oprnd1.v.val_die_ref.die;
21501 case DW_OP_GNU_entry_value:
21502 mark_base_types (loc->dw_loc_oprnd1.v.val_loc);
21507 gcc_assert (base_type->die_parent == comp_unit_die ());
21508 if (base_type->die_mark)
21509 base_type->die_mark++;
21512 VEC_safe_push (dw_die_ref, heap, base_types, base_type);
21513 base_type->die_mark = 1;
21518 /* Comparison function for sorting marked base types. */
21521 base_type_cmp (const void *x, const void *y)
21523 dw_die_ref dx = *(const dw_die_ref *) x;
21524 dw_die_ref dy = *(const dw_die_ref *) y;
21525 unsigned int byte_size1, byte_size2;
21526 unsigned int encoding1, encoding2;
21527 if (dx->die_mark > dy->die_mark)
21529 if (dx->die_mark < dy->die_mark)
21531 byte_size1 = get_AT_unsigned (dx, DW_AT_byte_size);
21532 byte_size2 = get_AT_unsigned (dy, DW_AT_byte_size);
21533 if (byte_size1 < byte_size2)
21535 if (byte_size1 > byte_size2)
21537 encoding1 = get_AT_unsigned (dx, DW_AT_encoding);
21538 encoding2 = get_AT_unsigned (dy, DW_AT_encoding);
21539 if (encoding1 < encoding2)
21541 if (encoding1 > encoding2)
21546 /* Move base types marked by mark_base_types as early as possible
21547 in the CU, sorted by decreasing usage count both to make the
21548 uleb128 references as small as possible and to make sure they
21549 will have die_offset already computed by calc_die_sizes when
21550 sizes of typed stack loc ops is computed. */
21553 move_marked_base_types (void)
21556 dw_die_ref base_type, die, c;
21558 if (VEC_empty (dw_die_ref, base_types))
21561 /* Sort by decreasing usage count, they will be added again in that
21563 VEC_qsort (dw_die_ref, base_types, base_type_cmp);
21564 die = comp_unit_die ();
21565 c = die->die_child;
21568 dw_die_ref prev = c;
21570 while (c->die_mark)
21572 remove_child_with_prev (c, prev);
21573 /* As base types got marked, there must be at least
21574 one node other than DW_TAG_base_type. */
21575 gcc_assert (c != c->die_sib);
21579 while (c != die->die_child);
21580 gcc_assert (die->die_child);
21581 c = die->die_child;
21582 for (i = 0; VEC_iterate (dw_die_ref, base_types, i, base_type); i++)
21584 base_type->die_mark = 0;
21585 base_type->die_sib = c->die_sib;
21586 c->die_sib = base_type;
21591 /* Helper function for resolve_addr, attempt to resolve
21592 one CONST_STRING, return non-zero if not successful. Similarly verify that
21593 SYMBOL_REFs refer to variables emitted in the current CU. */
21596 resolve_one_addr (rtx *addr, void *data ATTRIBUTE_UNUSED)
21600 if (GET_CODE (rtl) == CONST_STRING)
21602 size_t len = strlen (XSTR (rtl, 0)) + 1;
21603 tree t = build_string (len, XSTR (rtl, 0));
21604 tree tlen = size_int (len - 1);
21606 = build_array_type (char_type_node, build_index_type (tlen));
21607 rtl = lookup_constant_def (t);
21608 if (!rtl || !MEM_P (rtl))
21610 rtl = XEXP (rtl, 0);
21611 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
21616 if (GET_CODE (rtl) == SYMBOL_REF
21617 && SYMBOL_REF_DECL (rtl))
21619 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl))
21621 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl))))
21624 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
21628 if (GET_CODE (rtl) == CONST
21629 && for_each_rtx (&XEXP (rtl, 0), resolve_one_addr, NULL))
21635 /* Helper function for resolve_addr, handle one location
21636 expression, return false if at least one CONST_STRING or SYMBOL_REF in
21637 the location list couldn't be resolved. */
21640 resolve_addr_in_expr (dw_loc_descr_ref loc)
21642 dw_loc_descr_ref keep = NULL;
21643 for (; loc; loc = loc->dw_loc_next)
21644 switch (loc->dw_loc_opc)
21647 if (resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr, NULL))
21650 case DW_OP_const4u:
21651 case DW_OP_const8u:
21653 && resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr, NULL))
21656 case DW_OP_plus_uconst:
21657 if (size_of_loc_descr (loc)
21658 > size_of_int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned)
21660 && loc->dw_loc_oprnd1.v.val_unsigned > 0)
21662 dw_loc_descr_ref repl
21663 = int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned);
21664 add_loc_descr (&repl, new_loc_descr (DW_OP_plus, 0, 0));
21665 add_loc_descr (&repl, loc->dw_loc_next);
21669 case DW_OP_implicit_value:
21670 if (loc->dw_loc_oprnd2.val_class == dw_val_class_addr
21671 && resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr, NULL))
21674 case DW_OP_GNU_implicit_pointer:
21675 case DW_OP_GNU_parameter_ref:
21676 if (loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
21679 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref);
21682 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
21683 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
21684 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
21687 case DW_OP_GNU_const_type:
21688 case DW_OP_GNU_regval_type:
21689 case DW_OP_GNU_deref_type:
21690 case DW_OP_GNU_convert:
21691 case DW_OP_GNU_reinterpret:
21692 while (loc->dw_loc_next
21693 && loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_convert)
21695 dw_die_ref base1, base2;
21696 unsigned enc1, enc2, size1, size2;
21697 if (loc->dw_loc_opc == DW_OP_GNU_regval_type
21698 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
21699 base1 = loc->dw_loc_oprnd2.v.val_die_ref.die;
21700 else if (loc->dw_loc_oprnd1.val_class
21701 == dw_val_class_unsigned_const)
21704 base1 = loc->dw_loc_oprnd1.v.val_die_ref.die;
21705 if (loc->dw_loc_next->dw_loc_oprnd1.val_class
21706 == dw_val_class_unsigned_const)
21708 base2 = loc->dw_loc_next->dw_loc_oprnd1.v.val_die_ref.die;
21709 gcc_assert (base1->die_tag == DW_TAG_base_type
21710 && base2->die_tag == DW_TAG_base_type);
21711 enc1 = get_AT_unsigned (base1, DW_AT_encoding);
21712 enc2 = get_AT_unsigned (base2, DW_AT_encoding);
21713 size1 = get_AT_unsigned (base1, DW_AT_byte_size);
21714 size2 = get_AT_unsigned (base2, DW_AT_byte_size);
21716 && (((enc1 == DW_ATE_unsigned || enc1 == DW_ATE_signed)
21717 && (enc2 == DW_ATE_unsigned || enc2 == DW_ATE_signed)
21721 /* Optimize away next DW_OP_GNU_convert after
21722 adjusting LOC's base type die reference. */
21723 if (loc->dw_loc_opc == DW_OP_GNU_regval_type
21724 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
21725 loc->dw_loc_oprnd2.v.val_die_ref.die = base2;
21727 loc->dw_loc_oprnd1.v.val_die_ref.die = base2;
21728 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
21731 /* Don't change integer DW_OP_GNU_convert after e.g. floating
21732 point typed stack entry. */
21733 else if (enc1 != DW_ATE_unsigned && enc1 != DW_ATE_signed)
21734 keep = loc->dw_loc_next;
21744 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
21745 an address in .rodata section if the string literal is emitted there,
21746 or remove the containing location list or replace DW_AT_const_value
21747 with DW_AT_location and empty location expression, if it isn't found
21748 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
21749 to something that has been emitted in the current CU. */
21752 resolve_addr (dw_die_ref die)
21756 dw_loc_list_ref *curr, *start, loc;
21759 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
21760 switch (AT_class (a))
21762 case dw_val_class_loc_list:
21763 start = curr = AT_loc_list_ptr (a);
21766 /* The same list can be referenced more than once. See if we have
21767 already recorded the result from a previous pass. */
21769 *curr = loc->dw_loc_next;
21770 else if (!loc->resolved_addr)
21772 /* As things stand, we do not expect or allow one die to
21773 reference a suffix of another die's location list chain.
21774 References must be identical or completely separate.
21775 There is therefore no need to cache the result of this
21776 pass on any list other than the first; doing so
21777 would lead to unnecessary writes. */
21780 gcc_assert (!(*curr)->replaced && !(*curr)->resolved_addr);
21781 if (!resolve_addr_in_expr ((*curr)->expr))
21783 dw_loc_list_ref next = (*curr)->dw_loc_next;
21784 if (next && (*curr)->ll_symbol)
21786 gcc_assert (!next->ll_symbol);
21787 next->ll_symbol = (*curr)->ll_symbol;
21793 mark_base_types ((*curr)->expr);
21794 curr = &(*curr)->dw_loc_next;
21798 loc->resolved_addr = 1;
21802 loc->dw_loc_next = *start;
21807 remove_AT (die, a->dw_attr);
21811 case dw_val_class_loc:
21813 dw_loc_descr_ref l = AT_loc (a);
21814 /* For -gdwarf-2 don't attempt to optimize
21815 DW_AT_data_member_location containing
21816 DW_OP_plus_uconst - older consumers might
21817 rely on it being that op instead of a more complex,
21818 but shorter, location description. */
21819 if ((dwarf_version > 2
21820 || a->dw_attr != DW_AT_data_member_location
21822 || l->dw_loc_opc != DW_OP_plus_uconst
21823 || l->dw_loc_next != NULL)
21824 && !resolve_addr_in_expr (l))
21826 remove_AT (die, a->dw_attr);
21830 mark_base_types (l);
21833 case dw_val_class_addr:
21834 if (a->dw_attr == DW_AT_const_value
21835 && resolve_one_addr (&a->dw_attr_val.v.val_addr, NULL))
21837 remove_AT (die, a->dw_attr);
21840 if (die->die_tag == DW_TAG_GNU_call_site
21841 && a->dw_attr == DW_AT_abstract_origin)
21843 tree tdecl = SYMBOL_REF_DECL (a->dw_attr_val.v.val_addr);
21844 dw_die_ref tdie = lookup_decl_die (tdecl);
21846 && DECL_EXTERNAL (tdecl)
21847 && DECL_ABSTRACT_ORIGIN (tdecl) == NULL_TREE)
21849 force_decl_die (tdecl);
21850 tdie = lookup_decl_die (tdecl);
21854 a->dw_attr_val.val_class = dw_val_class_die_ref;
21855 a->dw_attr_val.v.val_die_ref.die = tdie;
21856 a->dw_attr_val.v.val_die_ref.external = 0;
21860 remove_AT (die, a->dw_attr);
21869 FOR_EACH_CHILD (die, c, resolve_addr (c));
21872 /* Helper routines for optimize_location_lists.
21873 This pass tries to share identical local lists in .debug_loc
21876 /* Iteratively hash operands of LOC opcode. */
21878 static inline hashval_t
21879 hash_loc_operands (dw_loc_descr_ref loc, hashval_t hash)
21881 dw_val_ref val1 = &loc->dw_loc_oprnd1;
21882 dw_val_ref val2 = &loc->dw_loc_oprnd2;
21884 switch (loc->dw_loc_opc)
21886 case DW_OP_const4u:
21887 case DW_OP_const8u:
21891 case DW_OP_const1u:
21892 case DW_OP_const1s:
21893 case DW_OP_const2u:
21894 case DW_OP_const2s:
21895 case DW_OP_const4s:
21896 case DW_OP_const8s:
21900 case DW_OP_plus_uconst:
21936 case DW_OP_deref_size:
21937 case DW_OP_xderef_size:
21938 hash = iterative_hash_object (val1->v.val_int, hash);
21945 gcc_assert (val1->val_class == dw_val_class_loc);
21946 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
21947 hash = iterative_hash_object (offset, hash);
21950 case DW_OP_implicit_value:
21951 hash = iterative_hash_object (val1->v.val_unsigned, hash);
21952 switch (val2->val_class)
21954 case dw_val_class_const:
21955 hash = iterative_hash_object (val2->v.val_int, hash);
21957 case dw_val_class_vec:
21959 unsigned int elt_size = val2->v.val_vec.elt_size;
21960 unsigned int len = val2->v.val_vec.length;
21962 hash = iterative_hash_object (elt_size, hash);
21963 hash = iterative_hash_object (len, hash);
21964 hash = iterative_hash (val2->v.val_vec.array,
21965 len * elt_size, hash);
21968 case dw_val_class_const_double:
21969 hash = iterative_hash_object (val2->v.val_double.low, hash);
21970 hash = iterative_hash_object (val2->v.val_double.high, hash);
21972 case dw_val_class_addr:
21973 hash = iterative_hash_rtx (val2->v.val_addr, hash);
21976 gcc_unreachable ();
21980 case DW_OP_bit_piece:
21981 hash = iterative_hash_object (val1->v.val_int, hash);
21982 hash = iterative_hash_object (val2->v.val_int, hash);
21988 unsigned char dtprel = 0xd1;
21989 hash = iterative_hash_object (dtprel, hash);
21991 hash = iterative_hash_rtx (val1->v.val_addr, hash);
21993 case DW_OP_GNU_implicit_pointer:
21994 hash = iterative_hash_object (val2->v.val_int, hash);
21996 case DW_OP_GNU_entry_value:
21997 hash = hash_loc_operands (val1->v.val_loc, hash);
21999 case DW_OP_GNU_regval_type:
22000 case DW_OP_GNU_deref_type:
22002 unsigned int byte_size
22003 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_byte_size);
22004 unsigned int encoding
22005 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_encoding);
22006 hash = iterative_hash_object (val1->v.val_int, hash);
22007 hash = iterative_hash_object (byte_size, hash);
22008 hash = iterative_hash_object (encoding, hash);
22011 case DW_OP_GNU_convert:
22012 case DW_OP_GNU_reinterpret:
22013 if (val1->val_class == dw_val_class_unsigned_const)
22015 hash = iterative_hash_object (val1->v.val_unsigned, hash);
22019 case DW_OP_GNU_const_type:
22021 unsigned int byte_size
22022 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_byte_size);
22023 unsigned int encoding
22024 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_encoding);
22025 hash = iterative_hash_object (byte_size, hash);
22026 hash = iterative_hash_object (encoding, hash);
22027 if (loc->dw_loc_opc != DW_OP_GNU_const_type)
22029 hash = iterative_hash_object (val2->val_class, hash);
22030 switch (val2->val_class)
22032 case dw_val_class_const:
22033 hash = iterative_hash_object (val2->v.val_int, hash);
22035 case dw_val_class_vec:
22037 unsigned int elt_size = val2->v.val_vec.elt_size;
22038 unsigned int len = val2->v.val_vec.length;
22040 hash = iterative_hash_object (elt_size, hash);
22041 hash = iterative_hash_object (len, hash);
22042 hash = iterative_hash (val2->v.val_vec.array,
22043 len * elt_size, hash);
22046 case dw_val_class_const_double:
22047 hash = iterative_hash_object (val2->v.val_double.low, hash);
22048 hash = iterative_hash_object (val2->v.val_double.high, hash);
22051 gcc_unreachable ();
22057 /* Other codes have no operands. */
22063 /* Iteratively hash the whole DWARF location expression LOC. */
22065 static inline hashval_t
22066 hash_locs (dw_loc_descr_ref loc, hashval_t hash)
22068 dw_loc_descr_ref l;
22069 bool sizes_computed = false;
22070 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
22071 size_of_locs (loc);
22073 for (l = loc; l != NULL; l = l->dw_loc_next)
22075 enum dwarf_location_atom opc = l->dw_loc_opc;
22076 hash = iterative_hash_object (opc, hash);
22077 if ((opc == DW_OP_skip || opc == DW_OP_bra) && !sizes_computed)
22079 size_of_locs (loc);
22080 sizes_computed = true;
22082 hash = hash_loc_operands (l, hash);
22087 /* Compute hash of the whole location list LIST_HEAD. */
22090 hash_loc_list (dw_loc_list_ref list_head)
22092 dw_loc_list_ref curr = list_head;
22093 hashval_t hash = 0;
22095 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
22097 hash = iterative_hash (curr->begin, strlen (curr->begin) + 1, hash);
22098 hash = iterative_hash (curr->end, strlen (curr->end) + 1, hash);
22100 hash = iterative_hash (curr->section, strlen (curr->section) + 1,
22102 hash = hash_locs (curr->expr, hash);
22104 list_head->hash = hash;
22107 /* Return true if X and Y opcodes have the same operands. */
22110 compare_loc_operands (dw_loc_descr_ref x, dw_loc_descr_ref y)
22112 dw_val_ref valx1 = &x->dw_loc_oprnd1;
22113 dw_val_ref valx2 = &x->dw_loc_oprnd2;
22114 dw_val_ref valy1 = &y->dw_loc_oprnd1;
22115 dw_val_ref valy2 = &y->dw_loc_oprnd2;
22117 switch (x->dw_loc_opc)
22119 case DW_OP_const4u:
22120 case DW_OP_const8u:
22124 case DW_OP_const1u:
22125 case DW_OP_const1s:
22126 case DW_OP_const2u:
22127 case DW_OP_const2s:
22128 case DW_OP_const4s:
22129 case DW_OP_const8s:
22133 case DW_OP_plus_uconst:
22169 case DW_OP_deref_size:
22170 case DW_OP_xderef_size:
22171 return valx1->v.val_int == valy1->v.val_int;
22174 gcc_assert (valx1->val_class == dw_val_class_loc
22175 && valy1->val_class == dw_val_class_loc
22176 && x->dw_loc_addr == y->dw_loc_addr);
22177 return valx1->v.val_loc->dw_loc_addr == valy1->v.val_loc->dw_loc_addr;
22178 case DW_OP_implicit_value:
22179 if (valx1->v.val_unsigned != valy1->v.val_unsigned
22180 || valx2->val_class != valy2->val_class)
22182 switch (valx2->val_class)
22184 case dw_val_class_const:
22185 return valx2->v.val_int == valy2->v.val_int;
22186 case dw_val_class_vec:
22187 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
22188 && valx2->v.val_vec.length == valy2->v.val_vec.length
22189 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
22190 valx2->v.val_vec.elt_size
22191 * valx2->v.val_vec.length) == 0;
22192 case dw_val_class_const_double:
22193 return valx2->v.val_double.low == valy2->v.val_double.low
22194 && valx2->v.val_double.high == valy2->v.val_double.high;
22195 case dw_val_class_addr:
22196 return rtx_equal_p (valx2->v.val_addr, valy2->v.val_addr);
22198 gcc_unreachable ();
22201 case DW_OP_bit_piece:
22202 return valx1->v.val_int == valy1->v.val_int
22203 && valx2->v.val_int == valy2->v.val_int;
22206 return rtx_equal_p (valx1->v.val_addr, valy1->v.val_addr);
22207 case DW_OP_GNU_implicit_pointer:
22208 return valx1->val_class == dw_val_class_die_ref
22209 && valx1->val_class == valy1->val_class
22210 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die
22211 && valx2->v.val_int == valy2->v.val_int;
22212 case DW_OP_GNU_entry_value:
22213 return compare_loc_operands (valx1->v.val_loc, valy1->v.val_loc);
22214 case DW_OP_GNU_const_type:
22215 if (valx1->v.val_die_ref.die != valy1->v.val_die_ref.die
22216 || valx2->val_class != valy2->val_class)
22218 switch (valx2->val_class)
22220 case dw_val_class_const:
22221 return valx2->v.val_int == valy2->v.val_int;
22222 case dw_val_class_vec:
22223 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
22224 && valx2->v.val_vec.length == valy2->v.val_vec.length
22225 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
22226 valx2->v.val_vec.elt_size
22227 * valx2->v.val_vec.length) == 0;
22228 case dw_val_class_const_double:
22229 return valx2->v.val_double.low == valy2->v.val_double.low
22230 && valx2->v.val_double.high == valy2->v.val_double.high;
22232 gcc_unreachable ();
22234 case DW_OP_GNU_regval_type:
22235 case DW_OP_GNU_deref_type:
22236 return valx1->v.val_int == valy1->v.val_int
22237 && valx2->v.val_die_ref.die == valy2->v.val_die_ref.die;
22238 case DW_OP_GNU_convert:
22239 case DW_OP_GNU_reinterpret:
22240 if (valx1->val_class != valy1->val_class)
22242 if (valx1->val_class == dw_val_class_unsigned_const)
22243 return valx1->v.val_unsigned == valy1->v.val_unsigned;
22244 return valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
22245 case DW_OP_GNU_parameter_ref:
22246 return valx1->val_class == dw_val_class_die_ref
22247 && valx1->val_class == valy1->val_class
22248 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
22250 /* Other codes have no operands. */
22255 /* Return true if DWARF location expressions X and Y are the same. */
22258 compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y)
22260 for (; x != NULL && y != NULL; x = x->dw_loc_next, y = y->dw_loc_next)
22261 if (x->dw_loc_opc != y->dw_loc_opc
22262 || x->dtprel != y->dtprel
22263 || !compare_loc_operands (x, y))
22265 return x == NULL && y == NULL;
22268 /* Return precomputed hash of location list X. */
22271 loc_list_hash (const void *x)
22273 return ((const struct dw_loc_list_struct *) x)->hash;
22276 /* Return 1 if location lists X and Y are the same. */
22279 loc_list_eq (const void *x, const void *y)
22281 const struct dw_loc_list_struct *a = (const struct dw_loc_list_struct *) x;
22282 const struct dw_loc_list_struct *b = (const struct dw_loc_list_struct *) y;
22285 if (a->hash != b->hash)
22287 for (; a != NULL && b != NULL; a = a->dw_loc_next, b = b->dw_loc_next)
22288 if (strcmp (a->begin, b->begin) != 0
22289 || strcmp (a->end, b->end) != 0
22290 || (a->section == NULL) != (b->section == NULL)
22291 || (a->section && strcmp (a->section, b->section) != 0)
22292 || !compare_locs (a->expr, b->expr))
22294 return a == NULL && b == NULL;
22297 /* Recursively optimize location lists referenced from DIE
22298 children and share them whenever possible. */
22301 optimize_location_lists_1 (dw_die_ref die, htab_t htab)
22308 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
22309 if (AT_class (a) == dw_val_class_loc_list)
22311 dw_loc_list_ref list = AT_loc_list (a);
22312 /* TODO: perform some optimizations here, before hashing
22313 it and storing into the hash table. */
22314 hash_loc_list (list);
22315 slot = htab_find_slot_with_hash (htab, list, list->hash,
22318 *slot = (void *) list;
22320 a->dw_attr_val.v.val_loc_list = (dw_loc_list_ref) *slot;
22323 FOR_EACH_CHILD (die, c, optimize_location_lists_1 (c, htab));
22326 /* Optimize location lists referenced from DIE
22327 children and share them whenever possible. */
22330 optimize_location_lists (dw_die_ref die)
22332 htab_t htab = htab_create (500, loc_list_hash, loc_list_eq, NULL);
22333 optimize_location_lists_1 (die, htab);
22334 htab_delete (htab);
22337 /* Output stuff that dwarf requires at the end of every file,
22338 and generate the DWARF-2 debugging info. */
22341 dwarf2out_finish (const char *filename)
22343 limbo_die_node *node, *next_node;
22344 comdat_type_node *ctnode;
22345 htab_t comdat_type_table;
22348 /* PCH might result in DW_AT_producer string being restored from the
22349 header compilation, fix it up if needed. */
22350 dw_attr_ref producer = get_AT (comp_unit_die (), DW_AT_producer);
22351 if (strcmp (AT_string (producer), producer_string) != 0)
22353 struct indirect_string_node *node = find_AT_string (producer_string);
22354 producer->dw_attr_val.v.val_str = node;
22357 gen_scheduled_generic_parms_dies ();
22358 gen_remaining_tmpl_value_param_die_attribute ();
22360 /* Add the name for the main input file now. We delayed this from
22361 dwarf2out_init to avoid complications with PCH. */
22362 add_name_attribute (comp_unit_die (), remap_debug_filename (filename));
22363 if (!IS_ABSOLUTE_PATH (filename))
22364 add_comp_dir_attribute (comp_unit_die ());
22365 else if (get_AT (comp_unit_die (), DW_AT_comp_dir) == NULL)
22368 htab_traverse (file_table, file_table_relative_p, &p);
22370 add_comp_dir_attribute (comp_unit_die ());
22373 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
22375 add_location_or_const_value_attribute (
22376 VEC_index (deferred_locations, deferred_locations_list, i)->die,
22377 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
22382 /* Traverse the limbo die list, and add parent/child links. The only
22383 dies without parents that should be here are concrete instances of
22384 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
22385 For concrete instances, we can get the parent die from the abstract
22387 for (node = limbo_die_list; node; node = next_node)
22389 dw_die_ref die = node->die;
22390 next_node = node->next;
22392 if (die->die_parent == NULL)
22394 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
22396 if (origin && origin->die_parent)
22397 add_child_die (origin->die_parent, die);
22398 else if (is_cu_die (die))
22400 else if (seen_error ())
22401 /* It's OK to be confused by errors in the input. */
22402 add_child_die (comp_unit_die (), die);
22405 /* In certain situations, the lexical block containing a
22406 nested function can be optimized away, which results
22407 in the nested function die being orphaned. Likewise
22408 with the return type of that nested function. Force
22409 this to be a child of the containing function.
22411 It may happen that even the containing function got fully
22412 inlined and optimized out. In that case we are lost and
22413 assign the empty child. This should not be big issue as
22414 the function is likely unreachable too. */
22415 tree context = NULL_TREE;
22417 gcc_assert (node->created_for);
22419 if (DECL_P (node->created_for))
22420 context = DECL_CONTEXT (node->created_for);
22421 else if (TYPE_P (node->created_for))
22422 context = TYPE_CONTEXT (node->created_for);
22424 gcc_assert (context
22425 && (TREE_CODE (context) == FUNCTION_DECL
22426 || TREE_CODE (context) == NAMESPACE_DECL));
22428 origin = lookup_decl_die (context);
22430 add_child_die (origin, die);
22432 add_child_die (comp_unit_die (), die);
22437 limbo_die_list = NULL;
22439 #if ENABLE_ASSERT_CHECKING
22441 dw_die_ref die = comp_unit_die (), c;
22442 FOR_EACH_CHILD (die, c, gcc_assert (! c->die_mark));
22445 resolve_addr (comp_unit_die ());
22446 move_marked_base_types ();
22448 for (node = deferred_asm_name; node; node = node->next)
22450 tree decl = node->created_for;
22451 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
22453 add_linkage_attr (node->die, decl);
22454 move_linkage_attr (node->die);
22458 deferred_asm_name = NULL;
22460 /* Walk through the list of incomplete types again, trying once more to
22461 emit full debugging info for them. */
22462 retry_incomplete_types ();
22464 if (flag_eliminate_unused_debug_types)
22465 prune_unused_types ();
22467 /* Generate separate CUs for each of the include files we've seen.
22468 They will go into limbo_die_list. */
22469 if (flag_eliminate_dwarf2_dups && ! use_debug_types)
22470 break_out_includes (comp_unit_die ());
22472 /* Generate separate COMDAT sections for type DIEs. */
22473 if (use_debug_types)
22475 break_out_comdat_types (comp_unit_die ());
22477 /* Each new type_unit DIE was added to the limbo die list when created.
22478 Since these have all been added to comdat_type_list, clear the
22480 limbo_die_list = NULL;
22482 /* For each new comdat type unit, copy declarations for incomplete
22483 types to make the new unit self-contained (i.e., no direct
22484 references to the main compile unit). */
22485 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
22486 copy_decls_for_unworthy_types (ctnode->root_die);
22487 copy_decls_for_unworthy_types (comp_unit_die ());
22489 /* In the process of copying declarations from one unit to another,
22490 we may have left some declarations behind that are no longer
22491 referenced. Prune them. */
22492 prune_unused_types ();
22495 /* Traverse the DIE's and add add sibling attributes to those DIE's
22496 that have children. */
22497 add_sibling_attributes (comp_unit_die ());
22498 for (node = limbo_die_list; node; node = node->next)
22499 add_sibling_attributes (node->die);
22500 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
22501 add_sibling_attributes (ctnode->root_die);
22503 /* Output a terminator label for the .text section. */
22504 switch_to_section (text_section);
22505 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
22506 if (cold_text_section)
22508 switch_to_section (cold_text_section);
22509 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
22512 /* We can only use the low/high_pc attributes if all of the code was
22514 if (!have_multiple_function_sections
22515 || (dwarf_version < 3 && dwarf_strict))
22517 /* Don't add if the CU has no associated code. */
22518 if (text_section_used)
22520 add_AT_lbl_id (comp_unit_die (), DW_AT_low_pc, text_section_label);
22521 add_AT_lbl_id (comp_unit_die (), DW_AT_high_pc, text_end_label);
22528 bool range_list_added = false;
22530 if (text_section_used)
22531 add_ranges_by_labels (comp_unit_die (), text_section_label,
22532 text_end_label, &range_list_added);
22533 if (cold_text_section_used)
22534 add_ranges_by_labels (comp_unit_die (), cold_text_section_label,
22535 cold_end_label, &range_list_added);
22537 FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, fde_idx, fde)
22539 if (!fde->in_std_section)
22540 add_ranges_by_labels (comp_unit_die (), fde->dw_fde_begin,
22541 fde->dw_fde_end, &range_list_added);
22542 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
22543 add_ranges_by_labels (comp_unit_die (), fde->dw_fde_second_begin,
22544 fde->dw_fde_second_end, &range_list_added);
22547 if (range_list_added)
22549 /* We need to give .debug_loc and .debug_ranges an appropriate
22550 "base address". Use zero so that these addresses become
22551 absolute. Historically, we've emitted the unexpected
22552 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
22553 Emit both to give time for other tools to adapt. */
22554 add_AT_addr (comp_unit_die (), DW_AT_low_pc, const0_rtx);
22555 if (! dwarf_strict && dwarf_version < 4)
22556 add_AT_addr (comp_unit_die (), DW_AT_entry_pc, const0_rtx);
22562 if (debug_info_level >= DINFO_LEVEL_NORMAL)
22563 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list,
22564 debug_line_section_label);
22566 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22567 add_AT_macptr (comp_unit_die (),
22568 dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros,
22569 macinfo_section_label);
22571 if (have_location_lists)
22572 optimize_location_lists (comp_unit_die ());
22574 /* Output all of the compilation units. We put the main one last so that
22575 the offsets are available to output_pubnames. */
22576 for (node = limbo_die_list; node; node = node->next)
22577 output_comp_unit (node->die, 0);
22579 comdat_type_table = htab_create (100, htab_ct_hash, htab_ct_eq, NULL);
22580 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
22582 void **slot = htab_find_slot (comdat_type_table, ctnode, INSERT);
22584 /* Don't output duplicate types. */
22585 if (*slot != HTAB_EMPTY_ENTRY)
22588 /* Add a pointer to the line table for the main compilation unit
22589 so that the debugger can make sense of DW_AT_decl_file
22591 if (debug_info_level >= DINFO_LEVEL_NORMAL)
22592 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
22593 debug_line_section_label);
22595 output_comdat_type_unit (ctnode);
22598 htab_delete (comdat_type_table);
22600 /* Output the main compilation unit if non-empty or if .debug_macinfo
22601 will be emitted. */
22602 output_comp_unit (comp_unit_die (), debug_info_level >= DINFO_LEVEL_VERBOSE);
22604 /* Output the abbreviation table. */
22605 if (abbrev_die_table_in_use != 1)
22607 switch_to_section (debug_abbrev_section);
22608 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
22609 output_abbrev_section ();
22612 /* Output location list section if necessary. */
22613 if (have_location_lists)
22615 /* Output the location lists info. */
22616 switch_to_section (debug_loc_section);
22617 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
22618 DEBUG_LOC_SECTION_LABEL, 0);
22619 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
22620 output_location_lists (comp_unit_die ());
22623 /* Output public names table if necessary. */
22624 if (!VEC_empty (pubname_entry, pubname_table))
22626 gcc_assert (info_section_emitted);
22627 switch_to_section (debug_pubnames_section);
22628 output_pubnames (pubname_table);
22631 /* Output public types table if necessary. */
22632 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
22633 It shouldn't hurt to emit it always, since pure DWARF2 consumers
22634 simply won't look for the section. */
22635 if (!VEC_empty (pubname_entry, pubtype_table))
22637 bool empty = false;
22639 if (flag_eliminate_unused_debug_types)
22641 /* The pubtypes table might be emptied by pruning unused items. */
22645 FOR_EACH_VEC_ELT (pubname_entry, pubtype_table, i, p)
22646 if (p->die->die_offset != 0)
22654 gcc_assert (info_section_emitted);
22655 switch_to_section (debug_pubtypes_section);
22656 output_pubnames (pubtype_table);
22660 /* Output the address range information if a CU (.debug_info section)
22661 was emitted. We output an empty table even if we had no functions
22662 to put in it. This because the consumer has no way to tell the
22663 difference between an empty table that we omitted and failure to
22664 generate a table that would have contained data. */
22665 if (info_section_emitted)
22667 unsigned long aranges_length = size_of_aranges ();
22669 switch_to_section (debug_aranges_section);
22670 output_aranges (aranges_length);
22673 /* Output ranges section if necessary. */
22674 if (ranges_table_in_use)
22676 switch_to_section (debug_ranges_section);
22677 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
22681 /* Have to end the macro section. */
22682 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22684 switch_to_section (debug_macinfo_section);
22685 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
22686 if (!VEC_empty (macinfo_entry, macinfo_table))
22688 dw2_asm_output_data (1, 0, "End compilation unit");
22691 /* Output the source line correspondence table. We must do this
22692 even if there is no line information. Otherwise, on an empty
22693 translation unit, we will generate a present, but empty,
22694 .debug_info section. IRIX 6.5 `nm' will then complain when
22695 examining the file. This is done late so that any filenames
22696 used by the debug_info section are marked as 'used'. */
22697 switch_to_section (debug_line_section);
22698 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
22699 if (! DWARF2_ASM_LINE_DEBUG_INFO)
22700 output_line_info ();
22702 /* If we emitted any DW_FORM_strp form attribute, output the string
22704 if (debug_str_hash)
22705 htab_traverse (debug_str_hash, output_indirect_string, NULL);
22708 #include "gt-dwarf2out.h"